[simdjs] Update Spec version to 0.9

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 92 matching lines @@
 inline T AddSaturate(T a, T b) {
   const T max = std::numeric_limits<T>::max();
   const T min = std::numeric_limits<T>::min();
   int32_t result = a + b;
   if (result > max) return max;
   if (result < min) return min;
   return result;
 }
 
 
-// Widening absolute difference for uint16_t and uint8_t.
-template <typename T>
-inline uint32_t AbsoluteDifference(T a, T b) {
-  uint32_t result = std::abs(a - b);
-  return result;
-}
-
-
 // Saturating subtraction for int16_t and int8_t.
 template <typename T>
 inline T SubSaturate(T a, T b) {
   const T max = std::numeric_limits<T>::max();
   const T min = std::numeric_limits<T>::min();
   int32_t result = a - b;
   if (result > max) return max;
   if (result < min) return min;
   return result;
 }
@@ skipping 354 matching lines @@
     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_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_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)           \
   FUNCTION(Bool8x16, 16)
 
@@ skipping 53 matching lines @@
     HandleScope scope(isolate);                                       \
     SIMD_BINARY_OP(type, lane_type, lane_count, SubSaturate, result); \
     return *result;                                                   \
   }
 
 SIMD_SMALL_INT_TYPES(SIMD_ADD_SATURATE_FUNCTION)
 SIMD_SMALL_INT_TYPES(SIMD_SUB_SATURATE_FUNCTION)
 
 //-------------------------------------------------------------------
 
-// Small Unsigned int-only functions.
-
-#define SIMD_SMALL_UINT_TYPES(FUNCTION)               \
-  FUNCTION(Uint16x8, uint16_t, 8, Uint32x4, uint32_t) \
-  FUNCTION(Uint8x16, uint8_t, 16, Uint16x8, uint16_t)
-
-#define SIMD_ABS_DIFF_FUNCTION(type, lane_type, lane_count, wide_type,       \
-                               wide_ctype)                                   \
-  RUNTIME_FUNCTION(Runtime_##type##AbsoluteDifference) {                     \
-    HandleScope scope(isolate);                                              \
-    SIMD_BINARY_OP(type, lane_type, lane_count, AbsoluteDifference, result); \
-    return *result;                                                          \
-  }
-
-#define SIMD_WIDE_ABS_DIFF_FUNCTION(type, lane_type, lane_count, wide_type, \
-                                    wide_ctype)                             \
-  RUNTIME_FUNCTION(Runtime_##type##WidenedAbsoluteDifference) {             \
-    HandleScope scope(isolate);                                             \
-    static const int kLaneCount = lane_count / 2;                           \
-    DCHECK(args.length() == 2);                                             \
-    CONVERT_ARG_HANDLE_CHECKED(type, a, 0);                                 \
-    CONVERT_ARG_HANDLE_CHECKED(type, b, 1);                                 \
-    wide_ctype lanes[kLaneCount];                                           \
-    for (int i = 0; i < kLaneCount; i++) {                                  \
-      lanes[i] = AbsoluteDifference(a->get_lane(i), b->get_lane(i));        \
-    }                                                                       \
-    Handle<wide_type> result = isolate->factory()->New##wide_type(lanes);   \
-    return *result;                                                         \
-  }
-
-SIMD_SMALL_UINT_TYPES(SIMD_ABS_DIFF_FUNCTION)
-SIMD_SMALL_UINT_TYPES(SIMD_WIDE_ABS_DIFF_FUNCTION)
-
-//-------------------------------------------------------------------
-
 // Numeric functions.
 
 #define SIMD_NUMERIC_TYPES(FUNCTION) \
   FUNCTION(Float32x4, float, 4)      \
   FUNCTION(Int32x4, int32_t, 4)      \
   FUNCTION(Uint32x4, uint32_t, 4)    \
   FUNCTION(Int16x8, int16_t, 8)      \
   FUNCTION(Uint16x8, uint16_t, 8)    \
   FUNCTION(Int8x16, int8_t, 16)      \
   FUNCTION(Uint8x16, uint8_t, 16)
@@ skipping 432 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