Remove initialize to zero on output variables for inline.

source/scale_neon64.cc

 /*
  *  Copyright 2014 The LibYuv Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS. All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 529 matching lines @@
     "+r"(dst_width)        // %3
   : "r"(&kMult38_Div6),    // %4
     "r"(&kShuf38_2)        // %5
   : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16", "v17",
     "v18", "v19", "v30", "v31", "memory", "cc"
   );
 }
 
 void ScaleAddRows_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
                     uint16* dst_ptr, int src_width, int src_height) {
-  const uint8* src_tmp = NULL;
+  const uint8* src_tmp;
   asm volatile (
   "1:                                          \n"
     "mov       %0, %1                          \n"
     "mov       w12, %w5                        \n"
     "eor       v2.16b, v2.16b, v2.16b          \n"
     "eor       v3.16b, v3.16b, v3.16b          \n"
   "2:                                          \n"
     // load 16 pixels into q0
     MEMACCESS(0)
     "ld1       {v0.16b}, [%0], %3              \n"
     "uaddw2    v3.8h, v3.8h, v0.16b            \n"
     "uaddw     v2.8h, v2.8h, v0.8b             \n"
     "subs      w12, w12, #1                    \n"
     "b.gt      2b                              \n"
     MEMACCESS(2)
     "st1      {v2.8h, v3.8h}, [%2], #32        \n"  // store pixels
     "add      %1, %1, #16                      \n"
     "subs     %w4, %w4, #16                    \n"  // 16 processed per loop
     "b.gt     1b                               \n"
-  : "+r"(src_tmp),          // %0
-    "+r"(src_ptr),          // %1
-    "+r"(dst_ptr),          // %2
-    "+r"(src_stride),       // %3
-    "+r"(src_width),        // %4
-    "+r"(src_height)        // %5
+  : "=&r"(src_tmp),    // %0
+    "+r"(src_ptr),     // %1
+    "+r"(dst_ptr),     // %2
+    "+r"(src_stride),  // %3
+    "+r"(src_width),   // %4
+    "+r"(src_height)   // %5
   :
   : "memory", "cc", "w12", "v0", "v1", "v2", "v3"  // Clobber List
   );
 }
 
 // TODO(Yang Zhang): Investigate less load instructions for
 // the x/dx stepping
 #define LOAD2_DATA8_LANE(n)                                    \
     "lsr        %5, %3, #16                    \n"             \
     "add        %6, %1, %5                    \n"              \
@@ skipping 338 matching lines @@
     "add        %3, %3, %4                     \n"             \
     MEMACCESS(6)                                               \
     "ld1        {"#vn".s}["#n"], [%6]          \n"
 
 void ScaleARGBCols_NEON(uint8* dst_argb, const uint8* src_argb,
                         int dst_width, int x, int dx) {
   const uint8* src_tmp = src_argb;
   int64 dst_width64 = (int64) dst_width;  // Work around ios 64 bit warning.
   int64 x64 = (int64) x;
   int64 dx64 = (int64) dx;
-  int64 tmp64 = 0;
+  int64 tmp64;
   asm volatile (
   "1:                                          \n"
     LOAD1_DATA32_LANE(v0, 0)
     LOAD1_DATA32_LANE(v0, 1)
     LOAD1_DATA32_LANE(v0, 2)
     LOAD1_DATA32_LANE(v0, 3)
     LOAD1_DATA32_LANE(v1, 0)
     LOAD1_DATA32_LANE(v1, 1)
     LOAD1_DATA32_LANE(v1, 2)
     LOAD1_DATA32_LANE(v1, 3)
 
     MEMACCESS(0)
     "st1        {v0.4s, v1.4s}, [%0], #32      \n"  // store pixels
     "subs       %w2, %w2, #8                   \n"  // 8 processed per loop
     "b.gt        1b                            \n"
-  : "+r"(dst_argb),         // %0
-    "+r"(src_argb),         // %1
-    "+r"(dst_width64),      // %2
-    "+r"(x64),              // %3
-    "+r"(dx64),             // %4
-    "+r"(tmp64),            // %5
-    "+r"(src_tmp)           // %6
+  : "+r"(dst_argb),     // %0
+    "+r"(src_argb),     // %1
+    "+r"(dst_width64),  // %2
+    "+r"(x64),          // %3
+    "+r"(dx64),         // %4
+    "=&r"(tmp64),       // %5
+    "+r"(src_tmp)       // %6
   :
   : "memory", "cc", "v0", "v1"
   );
 }
 
 #undef LOAD1_DATA32_LANE
 
 // TODO(Yang Zhang): Investigate less load instructions for
 // the x/dx stepping
 #define LOAD2_DATA32_LANE(vn1, vn2, n)                         \
@@ skipping 66 matching lines @@
 }
 
 #undef LOAD2_DATA32_LANE
 
 #endif  // !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
 
 #ifdef __cplusplus
 }  // extern "C"
 }  // namespace libyuv
 #endif