[wasm] Track in the interpreter if a NaN could have been produced.

test/cctest/wasm/wasm-run-utils.h

 // 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 608 matching lines @@
   }
 
   WasmRunner(TestingModule* module, MachineType p0 = MachineType::None(),
              MachineType p1 = MachineType::None(),
              MachineType p2 = MachineType::None(),
              MachineType p3 = MachineType::None())
       : zone(&allocator_, ZONE_NAME),
         compiled_(false),
         signature_(MachineTypeForC<ReturnType>() == MachineType::None() ? 0 : 1,
                    GetParameterCount(p0, p1, p2, p3), storage_),
-        compiler_(&signature_, module) {
+        compiler_(&signature_, module),
+        possible_nondeterminism_(false) {
     DCHECK(module);
     InitSigStorage(p0, p1, p2, p3);
   }
 
   void InitSigStorage(MachineType p0, MachineType p1, MachineType p2,
                       MachineType p3) {
     int index = 0;
     MachineType ret = MachineTypeForC<ReturnType>();
     if (ret != MachineType::None()) {
       storage_[index++] = WasmOpcodes::LocalTypeFor(ret);
@@ skipping 89 matching lines @@
   }
 
   ReturnType CallInterpreter(Vector<WasmVal> args) {
     CHECK_EQ(args.length(),
              static_cast<int>(compiler_.function_->sig->parameter_count()));
     WasmInterpreter::Thread* thread = interpreter()->GetThread(0);
     thread->Reset();
     thread->PushFrame(compiler_.function_, args.start());
     if (thread->Run() == WasmInterpreter::FINISHED) {
       WasmVal val = thread->GetReturnValue();
+      possible_nondeterminism_ |= thread->PossibleNondeterminism();
       return val.to<ReturnType>();
     } else if (thread->state() == WasmInterpreter::TRAPPED) {
       // TODO(titzer): return the correct trap code
       int64_t result = 0xdeadbeefdeadbeef;
       return static_cast<ReturnType>(result);
     } else {
       // TODO(titzer): falling off end
       ReturnType val = 0;
       return val;
     }
   }
 
   byte AllocateLocal(LocalType type) { return compiler_.AllocateLocal(type); }
 
   WasmFunction* function() { return compiler_.function_; }
   WasmInterpreter* interpreter() { return compiler_.interpreter_; }
+  bool possible_nondeterminism() { return possible_nondeterminism_; }
 
  protected:
   v8::internal::AccountingAllocator allocator_;
   Zone zone;
   bool compiled_;
   LocalType storage_[WASM_RUNNER_MAX_NUM_PARAMETERS];
   FunctionSig signature_;
   WasmFunctionCompiler compiler_;
   WasmFunctionWrapper<ReturnType> wrapper_;
+  bool possible_nondeterminism_;
 
   bool interpret() { return compiler_.execution_mode_ == kExecuteInterpreted; }
 
   static size_t GetParameterCount(MachineType p0, MachineType p1,
                                   MachineType p2, MachineType p3) {
     if (p0 == MachineType::None()) return 0;
     if (p1 == MachineType::None()) return 1;
     if (p2 == MachineType::None()) return 2;
     if (p3 == MachineType::None()) return 3;
     return 4;
   }
 };
 
 // A macro to define tests that run in different engine configurations.
 // Currently only supports compiled tests, but a future
 // RunWasmInterpreted_##name version will allow each test to also run in the
 // interpreter.
 #define WASM_EXEC_TEST(name)                                               \
   void RunWasm_##name(WasmExecutionMode execution_mode);                   \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); }       \
   TEST(RunWasmInterpreted_##name) { RunWasm_##name(kExecuteInterpreted); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 }  // namespace
 
 #endif