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

test/cctest/wasm/test-run-wasm-interpreter.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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <memory>
 
@@ skipping 325 matching lines @@
     // Grow memory by an invalid amount without initial memory.
     WasmRunner<int32_t, uint32_t> r(kExecuteInterpreted);
     r.module().AddMemory(WasmModule::kPageSize);
     BUILD(r, WASM_GROW_MEMORY(WASM_GET_LOCAL(0)));
     CHECK_EQ(-1, r.Call(1048575));
   }
 }
 
 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);
+    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(std::numeric_limits<float>::infinity(), 0.0f);
+    r.Call(std::numeric_limits<float>::quiet_NaN());
     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);
+    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(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);
-    CHECK(!r.possible_nondeterminism());
-    r.Call(-1048575.5);
-    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);
-    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());
   }
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8