Fix presubmit errors in runtime-simd.cc.

src/runtime/runtime-simd.cc

 // Copyright 2015 the V8 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.
 
 #include "src/v8.h"
 
 #include "src/arguments.h"
 #include "src/base/macros.h"
 #include "src/conversions.h"
 #include "src/runtime/runtime-utils.h"
 
 // Implement Single Instruction Multiple Data (SIMD) operations as defined in
 // the SIMD.js draft spec:
 // http://littledan.github.io/simd.html
 
 #define CONVERT_SIMD_LANE_ARG_CHECKED(name, index, lanes) \
   CONVERT_INT32_ARG_CHECKED(name, index);                 \
   RUNTIME_ASSERT(name >= 0 && name < lanes);
 
 #define SIMD_CREATE_NUMERIC_FUNCTION(type, lane_type, lane_count) \
   RUNTIME_FUNCTION(Runtime_Create##type) {                        \
+    static const int kLaneCount = lane_count;                     \
     HandleScope scope(isolate);                                   \
-    DCHECK(args.length() == lane_count);                          \
-    lane_type lanes[lane_count];                                  \
-    for (int i = 0; i < lane_count; i++) {                        \
+    DCHECK(args.length() == kLaneCount);                          \
+    lane_type lanes[kLaneCount];                                  \
+    for (int i = 0; i < kLaneCount; i++) {                        \
       CONVERT_NUMBER_ARG_HANDLE_CHECKED(number, i);               \
       lanes[i] = ConvertNumber<lane_type>(number->Number());      \
     }                                                             \
     return *isolate->factory()->New##type(lanes);                 \
   }
 
 #define SIMD_CREATE_BOOLEAN_FUNCTION(type, lane_count) \
   RUNTIME_FUNCTION(Runtime_Create##type) {             \
+    static const int kLaneCount = lane_count;          \
     HandleScope scope(isolate);                        \
-    DCHECK(args.length() == lane_count);               \
-    bool lanes[lane_count];                            \
-    for (int i = 0; i < lane_count; i++) {             \
+    DCHECK(args.length() == kLaneCount);               \
+    bool lanes[kLaneCount];                            \
+    for (int i = 0; i < kLaneCount; i++) {             \
       lanes[i] = args[i]->BooleanValue();              \
     }                                                  \
     return *isolate->factory()->New##type(lanes);      \
   }
 
 #define SIMD_CHECK_FUNCTION(type)           \
   RUNTIME_FUNCTION(Runtime_##type##Check) { \
     HandleScope scope(isolate);             \
     CONVERT_ARG_HANDLE_CHECKED(type, a, 0); \
     return *a;                              \
   }
 
 #define SIMD_EXTRACT_LANE_FUNCTION(type, lanes, extract_fn)    \
   RUNTIME_FUNCTION(Runtime_##type##ExtractLane) {              \
     HandleScope scope(isolate);                                \
     DCHECK(args.length() == 2);                                \
     CONVERT_ARG_HANDLE_CHECKED(type, a, 0);                    \
     CONVERT_SIMD_LANE_ARG_CHECKED(lane, 1, lanes);             \
     return *isolate->factory()->extract_fn(a->get_lane(lane)); \
   }
 
 #define SIMD_REPLACE_NUMERIC_LANE_FUNCTION(type, lane_type, lane_count) \
   RUNTIME_FUNCTION(Runtime_##type##ReplaceLane) {                       \
+    static const int kLaneCount = lane_count;                           \
     HandleScope scope(isolate);                                         \
     DCHECK(args.length() == 3);                                         \
     CONVERT_ARG_HANDLE_CHECKED(type, simd, 0);                          \
-    CONVERT_SIMD_LANE_ARG_CHECKED(lane, 1, lane_count);                 \
+    CONVERT_SIMD_LANE_ARG_CHECKED(lane, 1, kLaneCount);                 \
     CONVERT_NUMBER_ARG_HANDLE_CHECKED(number, 2);                       \
-    lane_type lanes[lane_count];                                        \
-    for (int i = 0; i < lane_count; i++) {                              \
+    lane_type lanes[kLaneCount];                                        \
+    for (int i = 0; i < kLaneCount; i++) {                              \
       lanes[i] = simd->get_lane(i);                                     \
     }                                                                   \
     lanes[lane] = ConvertNumber<lane_type>(number->Number());           \
     Handle<type> result = isolate->factory()->New##type(lanes);         \
     return *result;                                                     \
   }
 
 #define SIMD_REPLACE_BOOLEAN_LANE_FUNCTION(type, lane_count)    \
   RUNTIME_FUNCTION(Runtime_##type##ReplaceLane) {               \
+    static const int kLaneCount = lane_count;                   \
     HandleScope scope(isolate);                                 \
     DCHECK(args.length() == 3);                                 \
     CONVERT_ARG_HANDLE_CHECKED(type, simd, 0);                  \
-    CONVERT_SIMD_LANE_ARG_CHECKED(lane, 1, lane_count);         \
-    bool lanes[lane_count];                                     \
-    for (int i = 0; i < lane_count; i++) {                      \
+    CONVERT_SIMD_LANE_ARG_CHECKED(lane, 1, kLaneCount);         \
+    bool lanes[kLaneCount];                                     \
+    for (int i = 0; i < kLaneCount; i++) {                      \
       lanes[i] = simd->get_lane(i);                             \
     }                                                           \
     lanes[lane] = args[2]->BooleanValue();                      \
     Handle<type> result = isolate->factory()->New##type(lanes); \
     return *result;                                             \
   }
 
 
 namespace v8 {
 namespace internal {
@@ skipping 162 matching lines @@
 
 SIMD_REPLACE_NUMERIC_LANE_FUNCTION(Float32x4, float, 4)
 SIMD_REPLACE_NUMERIC_LANE_FUNCTION(Int32x4, int32_t, 4)
 SIMD_REPLACE_BOOLEAN_LANE_FUNCTION(Bool32x4, 4)
 SIMD_REPLACE_NUMERIC_LANE_FUNCTION(Int16x8, int16_t, 8)
 SIMD_REPLACE_BOOLEAN_LANE_FUNCTION(Bool16x8, 8)
 SIMD_REPLACE_NUMERIC_LANE_FUNCTION(Int8x16, int8_t, 16)
 SIMD_REPLACE_BOOLEAN_LANE_FUNCTION(Bool8x16, 16)
 }  // namespace internal
 }  // namespace v8