[simdjs] Update spec version to 0.8.4

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/base/safe_math.h"
 #include "src/conversions.h"
 #include "src/factory.h"
 #include "src/objects-inl.h"
 
 // Implement Single Instruction Multiple Data (SIMD) operations as defined in
 // the SIMD.js draft spec:
 // http://littledan.github.io/simd.html
 
 namespace v8 {
 namespace internal {
@@ skipping 431 matching lines @@
     lane_type lanes[kLaneCount] = {0};                            \
     if (shift < lane_bits) {                                      \
       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##ShiftRightLogicalByScalar) {   \
-    static const int kLaneCount = lane_count;                     \
-    HandleScope scope(isolate);                                   \
-    DCHECK(args.length() == 2);                                   \
-    CONVERT_ARG_HANDLE_CHECKED(type, a, 0);                       \
-    CONVERT_SHIFT_ARG_CHECKED(shift, 1);                          \
-    lane_type lanes[kLaneCount] = {0};                            \
-    if (shift < lane_bits) {                                      \
-      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##ShiftRightArithmeticByScalar) {     \
-    static const int kLaneCount = lane_count;                          \
-    HandleScope scope(isolate);                                        \
-    DCHECK(args.length() == 2);                                        \
-    CONVERT_ARG_HANDLE_CHECKED(type, a, 0);                            \
-    CONVERT_SHIFT_ARG_CHECKED(shift, 1);                               \
-    if (shift >= lane_bits) 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;                                                    \
+#define SIMD_LSR_FUNCTION(type, lane_type, lane_bits, lane_count)        \

[bbudge, 2015/09/16 20:25:36]

It's a little misleading to have the logical and arithmetic shifts in one macro.
I think it would be better to define separate LSR and ASR macros, but give them
the same name:

Runtime_##type##ShiftRightByScalar

[gdeepti1, 2015/09/16 20:42:08]

Done.

+  RUNTIME_FUNCTION(Runtime_##type##ShiftRightByScalar) {                 \
+    static const int kLaneCount = lane_count;                            \
+    HandleScope scope(isolate);                                          \
+    DCHECK(args.length() == 2);                                          \
+    CONVERT_ARG_HANDLE_CHECKED(type, a, 0);                              \
+    CONVERT_SHIFT_ARG_CHECKED(shift, 1);                                 \
+    lane_type lanes[kLaneCount] = {0};                                   \
+    if (base::internal::is_same<lane_type, uint32_t>::value ||           \
+        base::internal::is_same<lane_type, uint16_t>::value ||           \
+        base::internal::is_same<lane_type, uint8_t>::value) {            \
+      if (shift < lane_bits) {                                           \
+        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;                                                    \
+    } else {                                                             \
+      if (shift >= lane_bits) shift = lane_bits - 1;                     \
+      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;                                                    \
+    }                                                                    \
   }
 
 #define SIMD_HORIZONTAL_SUM_FUNCTION(type, lane_type, lane_bits, lane_count) \
   RUNTIME_FUNCTION(Runtime_##type##HorizontalSum) {                          \
     HandleScope scope(isolate);                                              \
     DCHECK(args.length() == 1);                                              \
     CONVERT_ARG_HANDLE_CHECKED(type, a, 0);                                  \
     double sum = 0;                                                          \
     for (int i = 0; i < lane_count; i++) {                                   \
       sum += a->get_lane(i);                                                 \
     }                                                                        \
     return *isolate->factory()->NewNumber(sum);                              \
   }
 
 SIMD_INT_TYPES(SIMD_LSL_FUNCTION)
 SIMD_UINT_TYPES(SIMD_LSL_FUNCTION)
-SIMD_INT_TYPES(SIMD_ASR_FUNCTION)
+SIMD_INT_TYPES(SIMD_LSR_FUNCTION)
 SIMD_UINT_TYPES(SIMD_LSR_FUNCTION)
 SIMD_UINT_TYPES(SIMD_HORIZONTAL_SUM_FUNCTION)
 
 //-------------------------------------------------------------------
 
 // Bool-only functions.
 
 #define SIMD_BOOL_TYPES(FUNCTION) \
   FUNCTION(Bool32x4, 4)           \
   FUNCTION(Bool16x8, 8)           \
@@ skipping 542 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