[wasm] Refactor the non-determinism detection in the interpreter.

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

Index: test/cctest/wasm/test-run-wasm-interpreter.cc
diff --git a/test/cctest/wasm/test-run-wasm-interpreter.cc b/test/cctest/wasm/test-run-wasm-interpreter.cc
index 71744ae69d87044a49c3487af92011f01b88c576..21de034f43690d02160477fd5c1b46424484bf7f 100644
--- a/test/cctest/wasm/test-run-wasm-interpreter.cc
+++ b/test/cctest/wasm/test-run-wasm-interpreter.cc
@@ -343,57 +343,43 @@ TEST(GrowMemoryInvalidSize) {
 
 TEST(TestPossibleNondeterminism) {
   {
-    // F32Div may produced NaN
-    WasmRunner<float, float, float> r(kExecuteInterpreted);
-    BUILD(r, WASM_F32_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
-    r.Call(1048575.5f, 2.5f);
+    WasmRunner<int32_t, float> r(kExecuteInterpreted);
+    BUILD(r, WASM_I32_REINTERPRET_F32(WASM_GET_LOCAL(0)));

[Eric Holk, 2017/02/03 03:11:26]

Can't we still have nondeterminism if the function returns a float? Or will it
just not matter because it will still be a NaN?

[ahaas, 2017/02/03 09:16:06]

Non-determinism by itself does not hurt us as long as it does not change the
result of the function. The fuzzer can deal easily with different NaNs.

+    r.Call(1048575.5f);
     CHECK(!r.possible_nondeterminism());
-    r.Call(0.0f, 0.0f);
+    r.Call(std::numeric_limits<float>::quiet_NaN());
     CHECK(r.possible_nondeterminism());
   }
   {
-    // F32Sqrt may produced NaN
-    WasmRunner<float, float> r(kExecuteInterpreted);
-    BUILD(r, WASM_F32_SQRT(WASM_GET_LOCAL(0)));
-    r.Call(16.0f);
+    WasmRunner<int64_t, double> r(kExecuteInterpreted);
+    BUILD(r, WASM_I64_REINTERPRET_F64(WASM_GET_LOCAL(0)));
+    r.Call(16.0);
     CHECK(!r.possible_nondeterminism());
-    r.Call(-1048575.5f);
+    r.Call(std::numeric_limits<double>::quiet_NaN());
     CHECK(r.possible_nondeterminism());
   }
   {
-    // F32Mul may produced NaN
-    WasmRunner<float, float, float> r(kExecuteInterpreted);
-    BUILD(r, WASM_F32_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
-    r.Call(1048575.5f, 2.5f);
-    CHECK(!r.possible_nondeterminism());
-    r.Call(std::numeric_limits<float>::infinity(), 0.0f);
-    CHECK(r.possible_nondeterminism());
-  }
-  {
-    // F64Div may produced NaN
-    WasmRunner<double, double, double> r(kExecuteInterpreted);
-    BUILD(r, WASM_F64_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
-    r.Call(1048575.5, 2.5);
-    CHECK(!r.possible_nondeterminism());
-    r.Call(0.0, 0.0);
-    CHECK(r.possible_nondeterminism());
-  }
-  {
-    // F64Sqrt may produced NaN
-    WasmRunner<double, double> r(kExecuteInterpreted);
-    BUILD(r, WASM_F64_SQRT(WASM_GET_LOCAL(0)));

[Eric Holk, 2017/02/03 03:11:26]

Wouldn't there still be some value in testing sqrt and the other ways of getting
NaN to make sure we're detecting all of it?

[ahaas, 2017/02/03 09:16:06]

The possible_nondeterminism flag causes us to not compare the result of the
interpreter with the result of the compiled code in the fuzzer. Therefore we
should only set the flag when it is really necessary. If you can still think of
a value which is worth more than better correctness fuzzing, then we can
definitely extend the use of the possible_nondeterminism flag again.

[titzer, 2017/02/03 09:48:05]

I think Andreas is saying that we do actually test NaN-producing inputs, it's
just that we don't test non-deterministic programs, and programs can only be
non-deterministic if they somehow _observe_ the NaN bit pattern itself.

-    r.Call(1048575.5);
+    int32_t index = 16;
+    WasmRunner<int32_t, float> r(kExecuteInterpreted);
+    r.module().AddMemory(WasmModule::kPageSize);
+    BUILD(r, WASM_STORE_MEM(MachineType::Float32(), WASM_I32V(index),
+                            WASM_GET_LOCAL(0)),
+          WASM_I32V(index));
+    r.Call(1345.3456f);
     CHECK(!r.possible_nondeterminism());
-    r.Call(-1048575.5);
+    r.Call(std::numeric_limits<float>::quiet_NaN());
     CHECK(r.possible_nondeterminism());
   }
   {
-    // F64Mul may produced NaN
-    WasmRunner<double, double, double> r(kExecuteInterpreted);
-    BUILD(r, WASM_F64_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
-    r.Call(1048575.5, 2.5);
+    int32_t index = 16;
+    WasmRunner<int32_t, double> r(kExecuteInterpreted);
+    r.module().AddMemory(WasmModule::kPageSize);
+    BUILD(r, WASM_STORE_MEM(MachineType::Float64(), WASM_I32V(index),
+                            WASM_GET_LOCAL(0)),
+          WASM_I32V(index));
+    r.Call(1345.3456);
     CHECK(!r.possible_nondeterminism());
-    r.Call(std::numeric_limits<double>::infinity(), 0.0);
+    r.Call(std::numeric_limits<double>::quiet_NaN());
     CHECK(r.possible_nondeterminism());
   }
 }