[WASM] Make F32x4 Tests pass on ARM hardware.

test/cctest/wasm/test-run-wasm-simd.cc

 // Copyright 2016 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/assembler-inl.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/wasm-run-utils.h"
 
@@ skipping 356 matching lines @@
 #define WASM_SIMD_I8x16_EXTRACT_LANE(lane, x) \
   x, WASM_SIMD_OP(kExprI8x16ExtractLane), TO_BYTE(lane)
 #define WASM_SIMD_I8x16_REPLACE_LANE(lane, x, y) \
   x, y, WASM_SIMD_OP(kExprI8x16ReplaceLane), TO_BYTE(lane)
 
 #define WASM_SIMD_F32x4_FROM_I32x4(x) x, WASM_SIMD_OP(kExprF32x4SConvertI32x4)
 #define WASM_SIMD_F32x4_FROM_U32x4(x) x, WASM_SIMD_OP(kExprF32x4UConvertI32x4)
 #define WASM_SIMD_I32x4_FROM_F32x4(x) x, WASM_SIMD_OP(kExprI32x4SConvertF32x4)
 #define WASM_SIMD_U32x4_FROM_F32x4(x) x, WASM_SIMD_OP(kExprI32x4UConvertF32x4)
 
-// Skip FP operations on NaNs or whose expected result is a NaN or so small
-// that denormalized numbers may flush to zero and cause exact FP comparisons
-// to fail.
-// TODO(bbudge) Switch FP comparisons in WASM code to WASM code that handles
-// NaNs and results with limited precision.
-bool SkipFPTestInput(float x) { return std::isnan(x); }
+// Skip FP operations on extremely large or extremely small values, which may
+// cause tests to fail due to non-IEEE-754 arithmetic on some platforms.
+bool SkipFPTestInput(float x) {

[Mircea Trofin, 2017/03/08 21:57:21]

We should think about what our portability story is here. Offline, we talked
about possibly having an interned API that tests the CPU capability. Then, the
test can be evaluated at JIT time and elided, together with the path that won't
be taken.

+  float abs_x = std::fabs(x);
+  const float kSmallFloatThreshold = 1.0e-32f;
+  const float kLargeFloatThreshold = 1.0e32f;
+  return abs_x != 0.0f &&  // 0 or -0 are fine.
+         (abs_x < kSmallFloatThreshold || abs_x > kLargeFloatThreshold);
+}
 
-bool SkipFPTestResult(float x) {
-  if (std::isnan(x)) return true;
-  // Constant empirically determined so existing tests pass on ARM hardware.
-  const float kSmallFloatThreshold = 1.0e-32f;
-  float abs_x = std::fabs(x);
-  return abs_x != 0 && abs_x < kSmallFloatThreshold;
-}
+// Skip tests where the expected value is a NaN. Our WASM test code can't
+// deal with NaNs.
+bool SkipFPExpectedValue(float x) { return std::isnan(x); }
 
 #if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
 WASM_EXEC_COMPILED_TEST(F32x4Splat) {
   FLAG_wasm_simd_prototype = true;
 
   WasmRunner<int32_t, float> r(kExecuteCompiled);
   byte lane_val = 0;
   byte simd = r.AllocateLocal(kWasmS128);
   BUILD(r,
         WASM_SET_LOCAL(simd, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(lane_val))),
         WASM_SIMD_CHECK_SPLAT_F32x4(simd, lane_val), WASM_RETURN1(WASM_ONE));
 
   FOR_FLOAT32_INPUTS(i) {
-    if (SkipFPTestInput(*i)) continue;
+    if (SkipFPExpectedValue(*i)) continue;
     CHECK_EQ(1, r.Call(*i));
   }
 }
 
 WASM_EXEC_COMPILED_TEST(F32x4ReplaceLane) {
   FLAG_wasm_simd_prototype = true;
   WasmRunner<int32_t, float, float> r(kExecuteCompiled);
   byte old_val = 0;
   byte new_val = 1;
   byte simd = r.AllocateLocal(kWasmS128);
@@ skipping 51 matching lines @@
   byte high = 2;
   byte simd = r.AllocateLocal(kWasmS128);
   BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(a))),
         WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))),
         WASM_SIMD_CHECK_SPLAT_F32x4_ESTIMATE(simd, low, high),
         WASM_RETURN1(WASM_ONE));
 
   FOR_FLOAT32_INPUTS(i) {
     if (SkipFPTestInput(*i)) continue;
     float expected = expected_op(*i);
-    if (SkipFPTestResult(expected)) continue;
+    if (SkipFPExpectedValue(expected)) continue;
     float abs_error = std::abs(expected) * error;
     CHECK_EQ(1, r.Call(*i, expected - abs_error, expected + abs_error));
   }
 }
 
 WASM_EXEC_COMPILED_TEST(F32x4Abs) { RunF32x4UnOpTest(kExprF32x4Abs, std::abs); }
 WASM_EXEC_COMPILED_TEST(F32x4Neg) { RunF32x4UnOpTest(kExprF32x4Neg, Negate); }
 #endif  // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
 
 #if SIMD_LOWERING_TARGET
@@ skipping 25 matching lines @@
         WASM_SET_LOCAL(simd1, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(b))),
         WASM_SET_LOCAL(simd1, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0),
                                               WASM_GET_LOCAL(simd1))),
         WASM_SIMD_CHECK_SPLAT_F32x4(simd1, expected), WASM_RETURN1(WASM_ONE));
 
   FOR_FLOAT32_INPUTS(i) {
     if (SkipFPTestInput(*i)) continue;
     FOR_FLOAT32_INPUTS(j) {
       if (SkipFPTestInput(*j)) continue;
       float expected = expected_op(*i, *j);
-      if (SkipFPTestResult(expected)) continue;
+      if (SkipFPExpectedValue(expected)) continue;
       CHECK_EQ(1, r.Call(*i, *j, expected));
     }
   }
 }
 
 WASM_EXEC_COMPILED_TEST(F32x4Add) { RunF32x4BinOpTest(kExprF32x4Add, Add); }
 WASM_EXEC_COMPILED_TEST(F32x4Sub) { RunF32x4BinOpTest(kExprF32x4Sub, Sub); }
 WASM_EXEC_COMPILED_TEST(F32x4Mul) { RunF32x4BinOpTest(kExprF32x4Sub, Sub); }
 WASM_EXEC_COMPILED_TEST(F32x4_Min) {
   RunF32x4BinOpTest(kExprF32x4Min, Minimum);
@@ skipping 32 matching lines @@
                        WASM_SIMD_MATERIALIZE_BOOLS(
                            32x4, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0),
                                                  WASM_GET_LOCAL(simd1)))),
         WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected), WASM_ONE);
 
   FOR_FLOAT32_INPUTS(i) {
     if (SkipFPTestInput(*i)) continue;
     FOR_FLOAT32_INPUTS(j) {
       if (SkipFPTestInput(*j)) continue;
       float diff = *i - *j;
-      if (SkipFPTestResult(diff)) continue;
+      if (SkipFPExpectedValue(diff)) continue;
       CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j)));
     }
   }
 }
 
 WASM_EXEC_COMPILED_TEST(F32x4Eq) { RunF32x4CompareOpTest(kExprF32x4Eq, Equal); }
 
 WASM_EXEC_COMPILED_TEST(F32x4Ne) {
   RunF32x4CompareOpTest(kExprF32x4Ne, NotEqual);
 }
@@ skipping 1226 matching lines @@
         WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(3, WASM_GET_GLOBAL(0),
                                                         WASM_F32(65.0))),
         WASM_I32V(1));
   FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(0)); }
   CHECK_EQ(*global, 13.5);
   CHECK_EQ(*(global + 1), 45.5);
   CHECK_EQ(*(global + 2), 32.25);
   CHECK_EQ(*(global + 3), 65.0);
 }
 #endif  // SIMD_LOWERING_TARGET