[simd.js] Update to spec version 0.8.2.

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"
 #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 {
 
 namespace {
 
 // Functions to convert Numbers to SIMD component types.
 
+template <typename T, typename F>
+static bool CanCast(F from) {
+  // A float can't represent 2^31 - 1 or 2^32 - 1 exactly, so promote the limits
+  // to double. Otherwise, the limit is truncated and numbers like 2^31 or 2^32
+  // get through, causing any static_cast to be undefined.
+  return from >= static_cast<double>(std::numeric_limits<T>::min()) &&
+         from <= static_cast<double>(std::numeric_limits<T>::max());
+}
+
+
+// Explicitly specialize for conversions to float, which always succeed.
+template <>
+bool CanCast<float>(int32_t from) {
+  return true;
+}
+
+
+template <>
+bool CanCast<float>(uint32_t from) {
+  return true;
+}
+
+
 template <typename T>
 static T ConvertNumber(double number);
 
 
 template <>
 float ConvertNumber<float>(double number) {
   return DoubleToFloat32(number);
 }
 
 
 template <>
 int32_t ConvertNumber<int32_t>(double number) {
   return DoubleToInt32(number);
 }
 
 
 template <>
+uint32_t ConvertNumber<uint32_t>(double number) {
+  return DoubleToUint32(number);
+}
+
+
+template <>
 int16_t ConvertNumber<int16_t>(double number) {
   return static_cast<int16_t>(DoubleToInt32(number));
 }
 
 
 template <>
+uint16_t ConvertNumber<uint16_t>(double number) {
+  return static_cast<uint16_t>(DoubleToUint32(number));
+}
+
+
+template <>
 int8_t ConvertNumber<int8_t>(double number) {
   return static_cast<int8_t>(DoubleToInt32(number));
 }
 
 
+template <>
+uint8_t ConvertNumber<uint8_t>(double number) {
+  return static_cast<uint8_t>(DoubleToUint32(number));
+}
+
+
 // TODO(bbudge): Make this consistent with SIMD instruction results.
 inline float RecipApprox(float a) { return 1.0f / a; }
 
 
 // TODO(bbudge): Make this consistent with SIMD instruction results.
 inline float RecipSqrtApprox(float a) { return 1.0f / std::sqrt(a); }
 
 
 // Saturating addition for int16_t and int8_t.
 template <typename T>
 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 21 matching lines @@
   return Min(a, b);
 }
 
 
 inline float MaxNumber(float a, float b) {
   if (std::isnan(a)) return b;
   if (std::isnan(b)) return a;
   return Max(a, b);
 }
 
-
-inline bool CanCast(int32_t a) { return true; }
-
-
-inline bool CanCast(float a) {
-  return a > std::numeric_limits<int32_t>::min() &&
-         a < std::numeric_limits<int32_t>::max();
-}
-
 }  // namespace
 
 //-------------------------------------------------------------------
 
 // SIMD helper functions.
 
 RUNTIME_FUNCTION(Runtime_IsSimdValue) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 1);
   return isolate->heap()->ToBoolean(args[0]->IsSimd128Value());
@@ skipping 101 matching lines @@
 
 // Common functions.
 
 #define GET_NUMERIC_ARG(lane_type, name, index) \
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(a, index);  \
   name = ConvertNumber<lane_type>(a->Number());
 
 #define GET_BOOLEAN_ARG(lane_type, name, index) \
   name = args[index]->BooleanValue();
 
-#define SIMD_ALL_TYPES(FUNCTION)                            \
-  FUNCTION(Float32x4, float, 4, NewNumber, GET_NUMERIC_ARG) \
-  FUNCTION(Int32x4, int32_t, 4, NewNumber, GET_NUMERIC_ARG) \
-  FUNCTION(Bool32x4, bool, 4, ToBoolean, GET_BOOLEAN_ARG)   \
-  FUNCTION(Int16x8, int16_t, 8, NewNumber, GET_NUMERIC_ARG) \
-  FUNCTION(Bool16x8, bool, 8, ToBoolean, GET_BOOLEAN_ARG)   \
-  FUNCTION(Int8x16, int8_t, 16, NewNumber, GET_NUMERIC_ARG) \
+#define SIMD_ALL_TYPES(FUNCTION)                              \
+  FUNCTION(Float32x4, float, 4, NewNumber, GET_NUMERIC_ARG)   \
+  FUNCTION(Int32x4, int32_t, 4, NewNumber, GET_NUMERIC_ARG)   \
+  FUNCTION(Uint32x4, uint32_t, 4, NewNumber, GET_NUMERIC_ARG) \
+  FUNCTION(Bool32x4, bool, 4, ToBoolean, GET_BOOLEAN_ARG)     \
+  FUNCTION(Int16x8, int16_t, 8, NewNumber, GET_NUMERIC_ARG)   \
+  FUNCTION(Uint16x8, uint16_t, 8, NewNumber, GET_NUMERIC_ARG) \
+  FUNCTION(Bool16x8, bool, 8, ToBoolean, GET_BOOLEAN_ARG)     \
+  FUNCTION(Int8x16, int8_t, 16, NewNumber, GET_NUMERIC_ARG)   \
+  FUNCTION(Uint8x16, uint8_t, 16, NewNumber, GET_NUMERIC_ARG) \
   FUNCTION(Bool8x16, bool, 16, ToBoolean, GET_BOOLEAN_ARG)
 
 #define SIMD_CREATE_FUNCTION(type, lane_type, lane_count, extract, replace) \
   RUNTIME_FUNCTION(Runtime_Create##type) {                                  \
     static const int kLaneCount = lane_count;                               \
     HandleScope scope(isolate);                                             \
     DCHECK(args.length() == kLaneCount);                                    \
     lane_type lanes[kLaneCount];                                            \
     for (int i = 0; i < kLaneCount; i++) {                                  \
       replace(lane_type, lanes[i], i)                                       \
@@ skipping 136 matching lines @@
 
 //-------------------------------------------------------------------
 
 // Int-only functions.
 
 #define SIMD_INT_TYPES(FUNCTION)    \
   FUNCTION(Int32x4, int32_t, 32, 4) \
   FUNCTION(Int16x8, int16_t, 16, 8) \
   FUNCTION(Int8x16, int8_t, 8, 16)
 
+#define SIMD_UINT_TYPES(FUNCTION)     \
+  FUNCTION(Uint32x4, uint32_t, 32, 4) \
+  FUNCTION(Uint16x8, uint16_t, 16, 8) \
+  FUNCTION(Uint8x16, uint8_t, 8, 16)
+
 #define CONVERT_SHIFT_ARG_CHECKED(name, index)         \
   RUNTIME_ASSERT(args[index]->IsNumber());             \
   int32_t signed_shift = 0;                            \
   RUNTIME_ASSERT(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);                                   \
@@ skipping 14 matching lines @@
   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<u##lane_type>(a->get_lane(i)) >> shift);     \
+            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_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_INT_TYPES(SIMD_LSR_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 29 matching lines @@
 
 SIMD_BOOL_TYPES(SIMD_ANY_FUNCTION)
 SIMD_BOOL_TYPES(SIMD_ALL_FUNCTION)
 
 //-------------------------------------------------------------------
 
 // Small Int-only functions.
 
 #define SIMD_SMALL_INT_TYPES(FUNCTION) \
   FUNCTION(Int16x8, int16_t, 8)        \
-  FUNCTION(Int8x16, int8_t, 16)
+  FUNCTION(Uint16x8, uint16_t, 8)      \
+  FUNCTION(Int8x16, int8_t, 16)        \
+  FUNCTION(Uint8x16, uint8_t, 16)
 
 #define SIMD_ADD_SATURATE_FUNCTION(type, lane_type, lane_count)       \
   RUNTIME_FUNCTION(Runtime_##type##AddSaturate) {                     \
     HandleScope scope(isolate);                                       \
     SIMD_BINARY_OP(type, lane_type, lane_count, AddSaturate, result); \
     return *result;                                                   \
   }
 
 #define BINARY_SUB(a, b) (a) - (b)
 #define SIMD_SUB_SATURATE_FUNCTION(type, lane_type, lane_count)       \
   RUNTIME_FUNCTION(Runtime_##type##SubSaturate) {                     \
     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(Int8x16, int8_t, 16)
-
-#define SIMD_NEG_FUNCTION(type, lane_type, lane_count)     \
-  RUNTIME_FUNCTION(Runtime_##type##Neg) {                  \
-    HandleScope scope(isolate);                            \
-    SIMD_UNARY_OP(type, lane_type, lane_count, -, result); \
-    return *result;                                        \
-  }
+  FUNCTION(Uint16x8, uint16_t, 8)    \
+  FUNCTION(Int8x16, int8_t, 16)      \
+  FUNCTION(Uint8x16, uint8_t, 16)
 
 #define BINARY_ADD(a, b) (a) + (b)
 #define SIMD_ADD_FUNCTION(type, lane_type, lane_count)               \
   RUNTIME_FUNCTION(Runtime_##type##Add) {                            \
     HandleScope scope(isolate);                                      \
     SIMD_BINARY_OP(type, lane_type, lane_count, BINARY_ADD, result); \
     return *result;                                                  \
   }
 
 #define BINARY_SUB(a, b) (a) - (b)
@@ skipping 19 matching lines @@
     return *result;                                           \
   }
 
 #define SIMD_MAX_FUNCTION(type, lane_type, lane_count)        \
   RUNTIME_FUNCTION(Runtime_##type##Max) {                     \
     HandleScope scope(isolate);                               \
     SIMD_BINARY_OP(type, lane_type, lane_count, Max, result); \
     return *result;                                           \
   }
 
-SIMD_NUMERIC_TYPES(SIMD_NEG_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_ADD_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_SUB_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_MUL_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_MIN_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_MAX_FUNCTION)
 
 //-------------------------------------------------------------------
 
 // Relational functions.
 
 #define SIMD_RELATIONAL_TYPES(FUNCTION) \
   FUNCTION(Float32x4, Bool32x4, 4)      \
   FUNCTION(Int32x4, Bool32x4, 4)        \
+  FUNCTION(Uint32x4, Bool32x4, 4)       \
   FUNCTION(Int16x8, Bool16x8, 8)        \
-  FUNCTION(Int8x16, Bool8x16, 16)
+  FUNCTION(Uint16x8, Bool16x8, 8)       \
+  FUNCTION(Int8x16, Bool8x16, 16)       \
+  FUNCTION(Uint8x16, Bool8x16, 16)
 
 #define SIMD_EQUALITY_TYPES(FUNCTION) \
   SIMD_RELATIONAL_TYPES(FUNCTION)     \
   FUNCTION(Bool32x4, Bool32x4, 4)     \
   FUNCTION(Bool16x8, Bool16x8, 8)     \
   FUNCTION(Bool8x16, Bool8x16, 16)
 
 #define SIMD_EQUAL_FUNCTION(type, bool_type, lane_count)               \
   RUNTIME_FUNCTION(Runtime_##type##Equal) {                            \
     HandleScope scope(isolate);                                        \
@@ skipping 41 matching lines @@
 
 SIMD_RELATIONAL_TYPES(SIMD_LESS_THAN_FUNCTION)
 SIMD_RELATIONAL_TYPES(SIMD_LESS_THAN_OR_EQUAL_FUNCTION)
 SIMD_RELATIONAL_TYPES(SIMD_GREATER_THAN_FUNCTION)
 SIMD_RELATIONAL_TYPES(SIMD_GREATER_THAN_OR_EQUAL_FUNCTION)
 
 //-------------------------------------------------------------------
 
 // Logical functions.
 
-#define SIMD_LOGICAL_TYPES(FUNCTION)  \
-  FUNCTION(Int32x4, int32_t, 4, _INT) \
-  FUNCTION(Int16x8, int16_t, 8, _INT) \
-  FUNCTION(Int8x16, int8_t, 16, _INT) \
-  FUNCTION(Bool32x4, bool, 4, _BOOL)  \
-  FUNCTION(Bool16x8, bool, 8, _BOOL)  \
+#define SIMD_LOGICAL_TYPES(FUNCTION)    \
+  FUNCTION(Int32x4, int32_t, 4, _INT)   \
+  FUNCTION(Uint32x4, uint32_t, 4, _INT) \
+  FUNCTION(Int16x8, int16_t, 8, _INT)   \
+  FUNCTION(Uint16x8, uint16_t, 8, _INT) \
+  FUNCTION(Int8x16, int8_t, 16, _INT)   \
+  FUNCTION(Uint8x16, uint8_t, 16, _INT) \
+  FUNCTION(Bool32x4, bool, 4, _BOOL)    \
+  FUNCTION(Bool16x8, bool, 8, _BOOL)    \
   FUNCTION(Bool8x16, bool, 16, _BOOL)
 
 #define BINARY_AND_INT(a, b) (a) & (b)
 #define BINARY_AND_BOOL(a, b) (a) && (b)
 #define SIMD_AND_FUNCTION(type, lane_type, lane_count, op)               \
   RUNTIME_FUNCTION(Runtime_##type##And) {                                \
     HandleScope scope(isolate);                                          \
     SIMD_BINARY_OP(type, lane_type, lane_count, BINARY_AND##op, result); \
     return *result;                                                      \
   }
@@ skipping 27 matching lines @@
 
 SIMD_LOGICAL_TYPES(SIMD_AND_FUNCTION)
 SIMD_LOGICAL_TYPES(SIMD_OR_FUNCTION)
 SIMD_LOGICAL_TYPES(SIMD_XOR_FUNCTION)
 SIMD_LOGICAL_TYPES(SIMD_NOT_FUNCTION)
 
 //-------------------------------------------------------------------
 
 // Select functions.
 
-#define SIMD_SELECT_TYPES(FUNCTION)       \
-  FUNCTION(Float32x4, float, Bool32x4, 4) \
-  FUNCTION(Int32x4, int32_t, Bool32x4, 4) \
-  FUNCTION(Int16x8, int16_t, Bool16x8, 8) \
-  FUNCTION(Int8x16, int8_t, Bool8x16, 16)
+#define SIMD_SELECT_TYPES(FUNCTION)         \
+  FUNCTION(Float32x4, float, Bool32x4, 4)   \
+  FUNCTION(Int32x4, int32_t, Bool32x4, 4)   \
+  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);                                       \
     CONVERT_ARG_HANDLE_CHECKED(bool_type, mask, 0);                   \
     CONVERT_ARG_HANDLE_CHECKED(type, a, 1);                           \
     CONVERT_ARG_HANDLE_CHECKED(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;                                                   \
   }
 
 SIMD_SELECT_TYPES(SIMD_SELECT_FUNCTION)
 
 //-------------------------------------------------------------------
 
+// Signed / unsigned functions.
+
+#define SIMD_SIGNED_TYPES(FUNCTION) \
+  FUNCTION(Float32x4, float, 4)     \
+  FUNCTION(Int32x4, int32_t, 4)     \
+  FUNCTION(Int16x8, int16_t, 8)     \
+  FUNCTION(Int8x16, int8_t, 16)
+
+#define SIMD_NEG_FUNCTION(type, lane_type, lane_count)     \
+  RUNTIME_FUNCTION(Runtime_##type##Neg) {                  \
+    HandleScope scope(isolate);                            \
+    SIMD_UNARY_OP(type, lane_type, lane_count, -, result); \
+    return *result;                                        \
+  }
+
+SIMD_SIGNED_TYPES(SIMD_NEG_FUNCTION)
+
+//-------------------------------------------------------------------
+
 // Casting functions.
 
-#define SIMD_FROM_TYPES(FUNCTION)                 \
-  FUNCTION(Float32x4, float, 4, Int32x4, int32_t) \
-  FUNCTION(Int32x4, int32_t, 4, Float32x4, float)
+#define SIMD_FROM_TYPES(FUNCTION)                   \
+  FUNCTION(Float32x4, float, 4, Int32x4, int32_t)   \
+  FUNCTION(Float32x4, float, 4, Uint32x4, uint32_t) \
+  FUNCTION(Int32x4, int32_t, 4, Float32x4, float)   \
+  FUNCTION(Int32x4, int32_t, 4, Uint32x4, uint32_t) \
+  FUNCTION(Uint32x4, uint32_t, 4, Float32x4, float) \
+  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);                                                \
     CONVERT_ARG_HANDLE_CHECKED(from_type, a, 0);                               \
     lane_type lanes[kLaneCount];                                               \
     for (int i = 0; i < kLaneCount; i++) {                                     \
       from_ctype a_value = a->get_lane(i);                                     \
-      RUNTIME_ASSERT(CanCast(a_value));                                        \
+      if (a_value != a_value) a_value = 0;                                     \
+      RUNTIME_ASSERT(CanCast<lane_type>(a_value));                             \
       lanes[i] = static_cast<lane_type>(a_value);                              \
     }                                                                          \
     Handle<type> result = isolate->factory()->New##type(lanes);                \
     return *result;                                                            \
   }
 
 SIMD_FROM_TYPES(SIMD_FROM_FUNCTION)
 
-#define SIMD_FROM_BITS_TYPES(FUNCTION)     \
-  FUNCTION(Float32x4, float, 4, Int32x4)   \
-  FUNCTION(Float32x4, float, 4, Int16x8)   \
-  FUNCTION(Float32x4, float, 4, Int8x16)   \
-  FUNCTION(Int32x4, int32_t, 4, Float32x4) \
-  FUNCTION(Int32x4, int32_t, 4, Int16x8)   \
-  FUNCTION(Int32x4, int32_t, 4, Int8x16)   \
-  FUNCTION(Int16x8, int16_t, 8, Float32x4) \
-  FUNCTION(Int16x8, int16_t, 8, Int32x4)   \
-  FUNCTION(Int16x8, int16_t, 8, Int8x16)   \
-  FUNCTION(Int8x16, int8_t, 16, Float32x4) \
-  FUNCTION(Int8x16, int8_t, 16, Int32x4)   \
-  FUNCTION(Int8x16, int8_t, 16, Int16x8)
+#define SIMD_FROM_BITS_TYPES(FUNCTION)       \
+  FUNCTION(Float32x4, float, 4, Int32x4)     \
+  FUNCTION(Float32x4, float, 4, Uint32x4)    \
+  FUNCTION(Float32x4, float, 4, Int16x8)     \
+  FUNCTION(Float32x4, float, 4, Uint16x8)    \
+  FUNCTION(Float32x4, float, 4, Int8x16)     \
+  FUNCTION(Float32x4, float, 4, Uint8x16)    \
+  FUNCTION(Int32x4, int32_t, 4, Float32x4)   \
+  FUNCTION(Int32x4, int32_t, 4, Uint32x4)    \
+  FUNCTION(Int32x4, int32_t, 4, Int16x8)     \
+  FUNCTION(Int32x4, int32_t, 4, Uint16x8)    \
+  FUNCTION(Int32x4, int32_t, 4, Int8x16)     \
+  FUNCTION(Int32x4, int32_t, 4, Uint8x16)    \
+  FUNCTION(Uint32x4, uint32_t, 4, Float32x4) \
+  FUNCTION(Uint32x4, uint32_t, 4, Int32x4)   \
+  FUNCTION(Uint32x4, uint32_t, 4, Int16x8)   \
+  FUNCTION(Uint32x4, uint32_t, 4, Uint16x8)  \
+  FUNCTION(Uint32x4, uint32_t, 4, Int8x16)   \
+  FUNCTION(Uint32x4, uint32_t, 4, Uint8x16)  \
+  FUNCTION(Int16x8, int16_t, 8, Float32x4)   \
+  FUNCTION(Int16x8, int16_t, 8, Int32x4)     \
+  FUNCTION(Int16x8, int16_t, 8, Uint32x4)    \
+  FUNCTION(Int16x8, int16_t, 8, Uint16x8)    \
+  FUNCTION(Int16x8, int16_t, 8, Int8x16)     \
+  FUNCTION(Int16x8, int16_t, 8, Uint8x16)    \
+  FUNCTION(Uint16x8, uint16_t, 8, Float32x4) \
+  FUNCTION(Uint16x8, uint16_t, 8, Int32x4)   \
+  FUNCTION(Uint16x8, uint16_t, 8, Uint32x4)  \
+  FUNCTION(Uint16x8, uint16_t, 8, Int16x8)   \
+  FUNCTION(Uint16x8, uint16_t, 8, Int8x16)   \
+  FUNCTION(Uint16x8, uint16_t, 8, Uint8x16)  \
+  FUNCTION(Int8x16, int8_t, 16, Float32x4)   \
+  FUNCTION(Int8x16, int8_t, 16, Int32x4)     \
+  FUNCTION(Int8x16, int8_t, 16, Uint32x4)    \
+  FUNCTION(Int8x16, int8_t, 16, Int16x8)     \
+  FUNCTION(Int8x16, int8_t, 16, Uint16x8)    \
+  FUNCTION(Int8x16, int8_t, 16, Uint8x16)    \
+  FUNCTION(Uint8x16, uint8_t, 16, Float32x4) \
+  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);                                         \
     CONVERT_ARG_HANDLE_CHECKED(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)
 
-//-------------------------------------------------------------------
-
-// Unsigned extract functions.
-// TODO(bbudge): remove when spec changes to include unsigned int types.
-
-RUNTIME_FUNCTION(Runtime_Int16x8UnsignedExtractLane) {
-  HandleScope scope(isolate);
-  DCHECK(args.length() == 2);
-  CONVERT_ARG_HANDLE_CHECKED(Int16x8, a, 0);
-  CONVERT_SIMD_LANE_ARG_CHECKED(lane, 1, 8);
-  return *isolate->factory()->NewNumber(bit_cast<uint16_t>(a->get_lane(lane)));
-}
-
-
-RUNTIME_FUNCTION(Runtime_Int8x16UnsignedExtractLane) {
-  HandleScope scope(isolate);
-  DCHECK(args.length() == 2);
-  CONVERT_ARG_HANDLE_CHECKED(Int8x16, a, 0);
-  CONVERT_SIMD_LANE_ARG_CHECKED(lane, 1, 16);
-  return *isolate->factory()->NewNumber(bit_cast<uint8_t>(a->get_lane(lane)));
-}
 }  // namespace internal
 }  // namespace v8