[simd.js] Set --harmony-simd flag in test config.

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;
+}
+
+}  // namespace
+
 template <typename T>
 static T ConvertNumber(double number);
 
 
 template <>
 float ConvertNumber<float>(double number) {
   return DoubleToFloat32(number);
 }
 
 
@@ skipping 70 matching lines @@
 }
 
 
 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 618 matching lines @@
 
 #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));                                        \
+      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)   \
@@ skipping 39 matching lines @@
 
 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