Remove initialize to zero on output variables for inline.

source/scale_neon.cc

 /*
  *  Copyright 2011 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 514 matching lines @@
     "+r"(dst_width),     // %2
     "+r"(src_stride)     // %3
   : "r"(&kMult38_Div6),  // %4
     "r"(&kShuf38_2)      // %5
   : "q0", "q1", "q2", "q3", "q13", "q14", "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       r12, %5                         \n"
     "veor      q2, q2, q2                      \n"
     "veor      q3, q3, q3                      \n"
   "2:                                          \n"
     // load 16 pixels into q0
     MEMACCESS(0)
     "vld1.8     {q0}, [%0], %3                 \n"
     "vaddw.u8   q3, q3, d1                     \n"
     "vaddw.u8   q2, q2, d0                     \n"
     "subs       r12, r12, #1                   \n"
     "bgt        2b                             \n"
     MEMACCESS(2)
     "vst1.16    {q2, q3}, [%2]!                \n"  // store pixels
     "add        %1, %1, #16                    \n"
     "subs       %4, %4, #16                    \n"  // 16 processed per loop
     "bgt        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", "r12", "q0", "q1", "q2", "q3"  // 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 331 matching lines @@
 // the x/dx stepping
 #define LOAD1_DATA32_LANE(dn, n)                               \
     "lsr        %5, %3, #16                    \n"             \
     "add        %6, %1, %5, lsl #2             \n"             \
     "add        %3, %3, %4                     \n"             \
     MEMACCESS(6)                                               \
     "vld1.32    {"#dn"["#n"]}, [%6]            \n"
 
 void ScaleARGBCols_NEON(uint8* dst_argb, const uint8* src_argb,
                         int dst_width, int x, int dx) {
-  int tmp = 0;
+  int tmp;
   const uint8* src_tmp = src_argb;
   asm volatile (
   "1:                                          \n"
     LOAD1_DATA32_LANE(d0, 0)
     LOAD1_DATA32_LANE(d0, 1)
     LOAD1_DATA32_LANE(d1, 0)
     LOAD1_DATA32_LANE(d1, 1)
     LOAD1_DATA32_LANE(d2, 0)
     LOAD1_DATA32_LANE(d2, 1)
     LOAD1_DATA32_LANE(d3, 0)
     LOAD1_DATA32_LANE(d3, 1)
 
     MEMACCESS(0)
     "vst1.32     {q0, q1}, [%0]!               \n"  // store pixels
     "subs       %2, %2, #8                     \n"  // 8 processed per loop
     "bgt        1b                             \n"
-  : "+r"(dst_argb),         // %0
-    "+r"(src_argb),         // %1
-    "+r"(dst_width),        // %2
-    "+r"(x),                // %3
-    "+r"(dx),               // %4
-    "+r"(tmp),              // %5
-    "+r"(src_tmp)           // %6
+  : "+r"(dst_argb),   // %0
+    "+r"(src_argb),   // %1
+    "+r"(dst_width),  // %2
+    "+r"(x),          // %3
+    "+r"(dx),         // %4
+    "=&r"(tmp),       // %5
+    "+r"(src_tmp)     // %6
   :
   : "memory", "cc", "q0", "q1"
   );
 }
 
 #undef LOAD1_DATA32_LANE
 
 // TODO(Yang Zhang): Investigate less load instructions for
 // the x/dx stepping
 #define LOAD2_DATA32_LANE(dn1, dn2, n)                         \
@@ skipping 62 matching lines @@
 }
 
 #undef LOAD2_DATA32_LANE
 
 #endif  // defined(__ARM_NEON__) && !defined(__aarch64__)
 
 #ifdef __cplusplus
 }  // extern "C"
 }  // namespace libyuv
 #endif