[runtime] Use DCHECK_EQ instead of DCHECK for number of args.

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/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/base/macros.h"
 #include "src/conversions.h"
 #include "src/factory.h"
@@ skipping 142 matching lines @@
 }
 
 }  // namespace
 
 //-------------------------------------------------------------------
 
 // SIMD helper functions.
 
 RUNTIME_FUNCTION(Runtime_IsSimdValue) {
   HandleScope scope(isolate);
-  DCHECK(args.length() == 1);
+  DCHECK_EQ(1, args.length());
   return isolate->heap()->ToBoolean(args[0]->IsSimd128Value());
 }
 
 
 //-------------------------------------------------------------------
 
 // Utility macros.
 
 // TODO(gdeepti): Fix to use ToNumber conversion once polyfill is updated.
 #define CONVERT_SIMD_LANE_ARG_CHECKED(name, index, lanes)            \
@@ skipping 13 matching lines @@
   Handle<Type> name;                                                    \
   if (args[index]->Is##Type()) {                                        \
     name = args.at<Type>(index);                                        \
   } else {                                                              \
     THROW_NEW_ERROR_RETURN_FAILURE(                                     \
         isolate, NewTypeError(MessageTemplate::kInvalidSimdOperation)); \
   }
 
 #define SIMD_UNARY_OP(type, lane_type, lane_count, op, result) \
   static const int kLaneCount = lane_count;                    \
-  DCHECK(args.length() == 1);                                  \
+  DCHECK_EQ(1, args.length());                                 \
   CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 0);                   \
   lane_type lanes[kLaneCount];                                 \
   for (int i = 0; i < kLaneCount; i++) {                       \
     lanes[i] = op(a->get_lane(i));                             \
   }                                                            \
   Handle<type> result = isolate->factory()->New##type(lanes);
 
 #define SIMD_BINARY_OP(type, lane_type, lane_count, op, result) \
   static const int kLaneCount = lane_count;                     \
-  DCHECK(args.length() == 2);                                   \
+  DCHECK_EQ(2, args.length());                                  \
   CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 0);                    \
   CONVERT_SIMD_ARG_HANDLE_THROW(type, b, 1);                    \
   lane_type lanes[kLaneCount];                                  \
   for (int i = 0; i < kLaneCount; i++) {                        \
     lanes[i] = op(a->get_lane(i), b->get_lane(i));              \
   }                                                             \
   Handle<type> result = isolate->factory()->New##type(lanes);
 
 #define SIMD_RELATIONAL_OP(type, bool_type, lane_count, a, b, op, result) \
   static const int kLaneCount = lane_count;                               \
-  DCHECK(args.length() == 2);                                             \
+  DCHECK_EQ(2, args.length());                                            \
   CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 0);                              \
   CONVERT_SIMD_ARG_HANDLE_THROW(type, b, 1);                              \
   bool lanes[kLaneCount];                                                 \
   for (int i = 0; i < kLaneCount; i++) {                                  \
     lanes[i] = a->get_lane(i) op b->get_lane(i);                          \
   }                                                                       \
   Handle<bool_type> result = isolate->factory()->New##bool_type(lanes);
 
 //-------------------------------------------------------------------
 
@@ skipping 28 matching lines @@
     lane_type lanes[kLaneCount];                                            \
     for (int i = 0; i < kLaneCount; i++) {                                  \
       replace(lane_type, lanes[i], i)                                       \
     }                                                                       \
     return *isolate->factory()->New##type(lanes);                           \
   }
 
 #define SIMD_EXTRACT_FUNCTION(type, lane_type, lane_count, extract, replace) \
   RUNTIME_FUNCTION(Runtime_##type##ExtractLane) {                            \
     HandleScope scope(isolate);                                              \
-    DCHECK(args.length() == 2);                                              \
+    DCHECK_EQ(2, args.length());                                             \
     CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 0);                               \
     CONVERT_SIMD_LANE_ARG_CHECKED(lane, 1, lane_count);                      \
     return *isolate->factory()->extract(a->get_lane(lane));                  \
   }
 
 #define SIMD_REPLACE_FUNCTION(type, lane_type, lane_count, extract, replace) \
   RUNTIME_FUNCTION(Runtime_##type##ReplaceLane) {                            \
     static const int kLaneCount = lane_count;                                \
     HandleScope scope(isolate);                                              \
-    DCHECK(args.length() == 3);                                              \
+    DCHECK_EQ(3, args.length());                                             \
     CONVERT_SIMD_ARG_HANDLE_THROW(type, simd, 0);                            \
     CONVERT_SIMD_LANE_ARG_CHECKED(lane, 1, kLaneCount);                      \
     lane_type lanes[kLaneCount];                                             \
     for (int i = 0; i < kLaneCount; i++) {                                   \
       lanes[i] = simd->get_lane(i);                                          \
     }                                                                        \
     replace(lane_type, lanes[lane], 2);                                      \
     Handle<type> result = isolate->factory()->New##type(lanes);              \
     return *result;                                                          \
   }
@@ skipping 127 matching lines @@
         isolate, NewTypeError(MessageTemplate::kInvalidSimdOperation)); \
   }                                                                     \
   int32_t signed_shift = 0;                                             \
   args[index]->ToInt32(&signed_shift);                                  \
   uint32_t name = bit_cast<uint32_t>(signed_shift);
 
 #define SIMD_LSL_FUNCTION(type, lane_type, lane_bits, lane_count) \
   RUNTIME_FUNCTION(Runtime_##type##ShiftLeftByScalar) {           \
     static const int kLaneCount = lane_count;                     \
     HandleScope scope(isolate);                                   \
-    DCHECK(args.length() == 2);                                   \
+    DCHECK_EQ(2, args.length());                                  \
     CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 0);                    \
     CONVERT_SHIFT_ARG_CHECKED(shift, 1);                          \
     lane_type lanes[kLaneCount] = {0};                            \
     shift &= lane_bits - 1;                                       \
     for (int i = 0; i < kLaneCount; i++) {                        \
       lanes[i] = a->get_lane(i) << shift;                         \
     }                                                             \
     Handle<type> result = isolate->factory()->New##type(lanes);   \
     return *result;                                               \
   }
 
 #define SIMD_LSR_FUNCTION(type, lane_type, lane_bits, lane_count)              \
   RUNTIME_FUNCTION(Runtime_##type##ShiftRightByScalar) {                       \
     static const int kLaneCount = lane_count;                                  \
     HandleScope scope(isolate);                                                \
-    DCHECK(args.length() == 2);                                                \
+    DCHECK_EQ(2, args.length());                                               \
     CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 0);                                 \
     CONVERT_SHIFT_ARG_CHECKED(shift, 1);                                       \
     lane_type lanes[kLaneCount] = {0};                                         \
     shift &= lane_bits - 1;                                                    \
     for (int i = 0; i < kLaneCount; i++) {                                     \
       lanes[i] = static_cast<lane_type>(bit_cast<lane_type>(a->get_lane(i)) >> \
                                         shift);                                \
     }                                                                          \
     Handle<type> result = isolate->factory()->New##type(lanes);                \
     return *result;                                                            \
   }
 
 #define SIMD_ASR_FUNCTION(type, lane_type, lane_bits, lane_count)      \
   RUNTIME_FUNCTION(Runtime_##type##ShiftRightByScalar) {               \
     static const int kLaneCount = lane_count;                          \
     HandleScope scope(isolate);                                        \
-    DCHECK(args.length() == 2);                                        \
+    DCHECK_EQ(2, args.length());                                       \
     CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 0);                         \
     CONVERT_SHIFT_ARG_CHECKED(shift, 1);                               \
     shift &= lane_bits - 1;                                            \
     lane_type lanes[kLaneCount];                                       \
     for (int i = 0; i < kLaneCount; i++) {                             \
       int64_t shifted = static_cast<int64_t>(a->get_lane(i)) >> shift; \
       lanes[i] = static_cast<lane_type>(shifted);                      \
     }                                                                  \
     Handle<type> result = isolate->factory()->New##type(lanes);        \
     return *result;                                                    \
   }
 
 SIMD_INT_TYPES(SIMD_LSL_FUNCTION)
 SIMD_UINT_TYPES(SIMD_LSL_FUNCTION)
 SIMD_INT_TYPES(SIMD_ASR_FUNCTION)
 SIMD_UINT_TYPES(SIMD_LSR_FUNCTION)
 
 //-------------------------------------------------------------------
 
 // Bool-only functions.
 
 #define SIMD_BOOL_TYPES(FUNCTION) \
   FUNCTION(Bool32x4, 4)           \
   FUNCTION(Bool16x8, 8)           \
   FUNCTION(Bool8x16, 16)
 
 #define SIMD_ANY_FUNCTION(type, lane_count)    \
   RUNTIME_FUNCTION(Runtime_##type##AnyTrue) {  \
     HandleScope scope(isolate);                \
-    DCHECK(args.length() == 1);                \
+    DCHECK_EQ(1, args.length());               \
     CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 0); \
     bool result = false;                       \
     for (int i = 0; i < lane_count; i++) {     \
       if (a->get_lane(i)) {                    \
         result = true;                         \
         break;                                 \
       }                                        \
     }                                          \
     return isolate->heap()->ToBoolean(result); \
   }
 
 #define SIMD_ALL_FUNCTION(type, lane_count)    \
   RUNTIME_FUNCTION(Runtime_##type##AllTrue) {  \
     HandleScope scope(isolate);                \
-    DCHECK(args.length() == 1);                \
+    DCHECK_EQ(1, args.length());               \
     CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 0); \
     bool result = true;                        \
     for (int i = 0; i < lane_count; i++) {     \
       if (!a->get_lane(i)) {                   \
         result = false;                        \
         break;                                 \
       }                                        \
     }                                          \
     return isolate->heap()->ToBoolean(result); \
   }
@@ skipping 221 matching lines @@
   FUNCTION(Uint32x4, uint32_t, Bool32x4, 4) \
   FUNCTION(Int16x8, int16_t, Bool16x8, 8)   \
   FUNCTION(Uint16x8, uint16_t, Bool16x8, 8) \
   FUNCTION(Int8x16, int8_t, Bool8x16, 16)   \
   FUNCTION(Uint8x16, uint8_t, Bool8x16, 16)
 
 #define SIMD_SELECT_FUNCTION(type, lane_type, bool_type, lane_count)  \
   RUNTIME_FUNCTION(Runtime_##type##Select) {                          \
     static const int kLaneCount = lane_count;                         \
     HandleScope scope(isolate);                                       \
-    DCHECK(args.length() == 3);                                       \
+    DCHECK_EQ(3, args.length());                                      \
     CONVERT_SIMD_ARG_HANDLE_THROW(bool_type, mask, 0);                \
     CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 1);                        \
     CONVERT_SIMD_ARG_HANDLE_THROW(type, b, 2);                        \
     lane_type lanes[kLaneCount];                                      \
     for (int i = 0; i < kLaneCount; i++) {                            \
       lanes[i] = mask->get_lane(i) ? a->get_lane(i) : b->get_lane(i); \
     }                                                                 \
     Handle<type> result = isolate->factory()->New##type(lanes);       \
     return *result;                                                   \
   }
@@ skipping 32 matching lines @@
   FUNCTION(Uint32x4, uint32_t, 4, Int32x4, int32_t) \
   FUNCTION(Int16x8, int16_t, 8, Uint16x8, uint16_t) \
   FUNCTION(Uint16x8, uint16_t, 8, Int16x8, int16_t) \
   FUNCTION(Int8x16, int8_t, 16, Uint8x16, uint8_t)  \
   FUNCTION(Uint8x16, uint8_t, 16, Int8x16, int8_t)
 
 #define SIMD_FROM_FUNCTION(type, lane_type, lane_count, from_type, from_ctype) \
   RUNTIME_FUNCTION(Runtime_##type##From##from_type) {                          \
     static const int kLaneCount = lane_count;                                  \
     HandleScope scope(isolate);                                                \
-    DCHECK(args.length() == 1);                                                \
+    DCHECK_EQ(1, args.length());                                               \
     CONVERT_SIMD_ARG_HANDLE_THROW(from_type, a, 0);                            \
     lane_type lanes[kLaneCount];                                               \
     for (int i = 0; i < kLaneCount; i++) {                                     \
       from_ctype a_value = a->get_lane(i);                                     \
       if (a_value != a_value || !CanCast<lane_type>(a_value)) {                \
         THROW_NEW_ERROR_RETURN_FAILURE(                                        \
             isolate, NewRangeError(MessageTemplate::kInvalidSimdLaneValue));   \
       }                                                                        \
       lanes[i] = static_cast<lane_type>(a_value);                              \
     }                                                                          \
@@ skipping 44 matching lines @@
   FUNCTION(Uint8x16, uint8_t, 16, Int32x4)   \
   FUNCTION(Uint8x16, uint8_t, 16, Uint32x4)  \
   FUNCTION(Uint8x16, uint8_t, 16, Int16x8)   \
   FUNCTION(Uint8x16, uint8_t, 16, Uint16x8)  \
   FUNCTION(Uint8x16, uint8_t, 16, Int8x16)
 
 #define SIMD_FROM_BITS_FUNCTION(type, lane_type, lane_count, from_type) \
   RUNTIME_FUNCTION(Runtime_##type##From##from_type##Bits) {             \
     static const int kLaneCount = lane_count;                           \
     HandleScope scope(isolate);                                         \
-    DCHECK(args.length() == 1);                                         \
+    DCHECK_EQ(1, args.length());                                        \
     CONVERT_SIMD_ARG_HANDLE_THROW(from_type, a, 0);                     \
     lane_type lanes[kLaneCount];                                        \
     a->CopyBits(lanes);                                                 \
     Handle<type> result = isolate->factory()->New##type(lanes);         \
     return *result;                                                     \
   }
 
 SIMD_FROM_BITS_TYPES(SIMD_FROM_BITS_FUNCTION)
 
 
@@ skipping 15 matching lines @@
   if (number_object->Number() != length_object->Number()) {                  \
     THROW_NEW_ERROR_RETURN_FAILURE(                                          \
         isolate, NewTypeError(MessageTemplate::kInvalidSimdIndex));          \
   }                                                                          \
   int32_t name = number_object->Number();
 
 // Common Load and Store Functions
 
 #define SIMD_LOAD(type, lane_type, lane_count, count, result)        \
   static const int kLaneCount = lane_count;                          \
-  DCHECK(args.length() == 2);                                        \
+  DCHECK_EQ(2, args.length());                                       \
   CONVERT_SIMD_ARG_HANDLE_THROW(JSTypedArray, tarray, 0);            \
   SIMD_COERCE_INDEX(index, 1);                                       \
   size_t bpe = tarray->element_size();                               \
   uint32_t bytes = count * sizeof(lane_type);                        \
   size_t byte_length = NumberToSize(tarray->byte_length());          \
   if (index < 0 || index * bpe + bytes > byte_length) {              \
     THROW_NEW_ERROR_RETURN_FAILURE(                                  \
         isolate, NewRangeError(MessageTemplate::kInvalidSimdIndex)); \
   }                                                                  \
   size_t tarray_offset = NumberToSize(tarray->byte_offset());        \
   uint8_t* tarray_base =                                             \
       static_cast<uint8_t*>(tarray->GetBuffer()->backing_store()) +  \
       tarray_offset;                                                 \
   lane_type lanes[kLaneCount] = {0};                                 \
   memcpy(lanes, tarray_base + index * bpe, bytes);                   \
   Handle<type> result = isolate->factory()->New##type(lanes);
 
 #define SIMD_STORE(type, lane_type, lane_count, count, a)            \
   static const int kLaneCount = lane_count;                          \
-  DCHECK(args.length() == 3);                                        \
+  DCHECK_EQ(3, args.length());                                       \
   CONVERT_SIMD_ARG_HANDLE_THROW(JSTypedArray, tarray, 0);            \
   CONVERT_SIMD_ARG_HANDLE_THROW(type, a, 2);                         \
   SIMD_COERCE_INDEX(index, 1);                                       \
   size_t bpe = tarray->element_size();                               \
   uint32_t bytes = count * sizeof(lane_type);                        \
   size_t byte_length = NumberToSize(tarray->byte_length());          \
   if (index < 0 || byte_length < index * bpe + bytes) {              \
     THROW_NEW_ERROR_RETURN_FAILURE(                                  \
         isolate, NewRangeError(MessageTemplate::kInvalidSimdIndex)); \
   }                                                                  \
@@ skipping 77 matching lines @@
 SIMD_LOADN_STOREN_TYPES(SIMD_LOAD3_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_STORE_FUNCTION)
 SIMD_LOADN_STOREN_TYPES(SIMD_STORE1_FUNCTION)
 SIMD_LOADN_STOREN_TYPES(SIMD_STORE2_FUNCTION)
 SIMD_LOADN_STOREN_TYPES(SIMD_STORE3_FUNCTION)
 
 //-------------------------------------------------------------------
 
 }  // namespace internal
 }  // namespace v8