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

src/wasm/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 "src/wasm/wasm-interpreter.h"
 
 #include "src/utils.h"
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/wasm-external-refs.h"
@@ skipping 44 matching lines @@
   V(I64Ne, uint64_t, !=)        \
   V(I64LtU, uint64_t, <)        \
   V(I64LeU, uint64_t, <=)       \
   V(I64GtU, uint64_t, >)        \
   V(I64GeU, uint64_t, >=)       \
   V(I64LtS, int64_t, <)         \
   V(I64LeS, int64_t, <=)        \
   V(I64GtS, int64_t, >)         \
   V(I64GeS, int64_t, >=)        \
   V(F32Add, float, +)           \
-  V(F32Mul, float, *)           \
-  V(F32Div, float, /)           \
   V(F32Eq, float, ==)           \
   V(F32Ne, float, !=)           \
   V(F32Lt, float, <)            \
   V(F32Le, float, <=)           \
   V(F32Gt, float, >)            \
   V(F32Ge, float, >=)           \
   V(F64Add, double, +)          \
-  V(F64Mul, double, *)          \
-  V(F64Div, double, /)          \
   V(F64Eq, double, ==)          \
   V(F64Ne, double, !=)          \
   V(F64Lt, double, <)           \
   V(F64Le, double, <=)          \
   V(F64Gt, double, >)           \
   V(F64Ge, double, >=)
 
+#define FOREACH_SIMPLE_BINOP_NAN(V) \
+  V(F32Mul, float, *)               \
+  V(F64Mul, double, *)              \
+  V(F32Div, float, /)               \
+  V(F64Div, double, /)
+
 #define FOREACH_OTHER_BINOP(V) \
   V(I32DivS, int32_t)          \
   V(I32DivU, uint32_t)         \
   V(I32RemS, int32_t)          \
   V(I32RemU, uint32_t)         \
   V(I32Shl, uint32_t)          \
   V(I32ShrU, uint32_t)         \
   V(I32ShrS, int32_t)          \
   V(I64DivS, int64_t)          \
   V(I64DivU, uint64_t)         \
@@ skipping 27 matching lines @@
   V(I64Clz, uint64_t)            \
   V(I64Ctz, uint64_t)            \
   V(I64Popcnt, uint64_t)         \
   V(I64Eqz, uint64_t)            \
   V(F32Abs, float)               \
   V(F32Neg, float)               \
   V(F32Ceil, float)              \
   V(F32Floor, float)             \
   V(F32Trunc, float)             \
   V(F32NearestInt, float)        \
-  V(F32Sqrt, float)              \
   V(F64Abs, double)              \
   V(F64Neg, double)              \
   V(F64Ceil, double)             \
   V(F64Floor, double)            \
   V(F64Trunc, double)            \
   V(F64NearestInt, double)       \
-  V(F64Sqrt, double)             \
   V(I32SConvertF32, float)       \
   V(I32SConvertF64, double)      \
   V(I32UConvertF32, float)       \
   V(I32UConvertF64, double)      \
   V(I32ConvertI64, int64_t)      \
   V(I64SConvertF32, float)       \
   V(I64SConvertF64, double)      \
   V(I64UConvertF32, float)       \
   V(I64UConvertF64, double)      \
   V(I64SConvertI32, int32_t)     \
@@ skipping 10 matching lines @@
   V(F64UConvertI64, uint64_t)    \
   V(F64ConvertF32, float)        \
   V(F64ReinterpretI64, int64_t)  \
   V(I32ReinterpretF32, float)    \
   V(I64ReinterpretF64, double)   \
   V(I32AsmjsSConvertF32, float)  \
   V(I32AsmjsUConvertF32, float)  \
   V(I32AsmjsSConvertF64, double) \
   V(I32AsmjsUConvertF64, double)
 
+#define FOREACH_OTHER_UNOP_NAN(V) \
+  V(F32Sqrt, float)               \
+  V(F64Sqrt, double)
+
 static inline int32_t ExecuteI32DivS(int32_t a, int32_t b, TrapReason* trap) {
   if (b == 0) {
     *trap = kTrapDivByZero;
     return 0;
   }
   if (b == -1 && a == std::numeric_limits<int32_t>::min()) {
     *trap = kTrapDivUnrepresentable;
     return 0;
   }
   return a / b;
@@ skipping 275 matching lines @@
 
 static inline float ExecuteF32Trunc(float a, TrapReason* trap) {
   return truncf(a);
 }
 
 static inline float ExecuteF32NearestInt(float a, TrapReason* trap) {
   return nearbyintf(a);
 }
 
 static inline float ExecuteF32Sqrt(float a, TrapReason* trap) {
-  return sqrtf(a);
+  float result = sqrtf(a);
+  return result;
 }
 
 static inline double ExecuteF64Abs(double a, TrapReason* trap) {
   return bit_cast<double>(bit_cast<uint64_t>(a) & 0x7fffffffffffffff);
 }
 
 static inline double ExecuteF64Neg(double a, TrapReason* trap) {
   return bit_cast<double>(bit_cast<uint64_t>(a) ^ 0x8000000000000000);
 }
 
@@ skipping 494 matching lines @@
 class ThreadImpl : public WasmInterpreter::Thread {
  public:
   ThreadImpl(Zone* zone, CodeMap* codemap, WasmInstance* instance)
       : codemap_(codemap),
         instance_(instance),
         stack_(zone),
         frames_(zone),
         blocks_(zone),
         state_(WasmInterpreter::STOPPED),
         break_pc_(kInvalidPc),
-        trap_reason_(kTrapCount) {}
+        trap_reason_(kTrapCount),
+        possible_nondeterminism_(false) {}
 
   virtual ~ThreadImpl() {}
 
   //==========================================================================
   // Implementation of public interface for WasmInterpreter::Thread.
   //==========================================================================
 
   virtual WasmInterpreter::State state() { return state_; }
 
   virtual void PushFrame(const WasmFunction* function, WasmVal* args) {
@@ skipping 34 matching lines @@
   }
 
   virtual void Pause() { UNIMPLEMENTED(); }
 
   virtual void Reset() {
     TRACE("----- RESET -----\n");
     stack_.clear();
     frames_.clear();
     state_ = WasmInterpreter::STOPPED;
     trap_reason_ = kTrapCount;
+    possible_nondeterminism_ = false;
   }
 
   virtual int GetFrameCount() { return static_cast<int>(frames_.size()); }
 
   virtual const WasmFrame* GetFrame(int index) {
     UNIMPLEMENTED();
     return nullptr;
   }
 
   virtual WasmFrame* GetMutableFrame(int index) {
     UNIMPLEMENTED();
     return nullptr;
   }
 
   virtual WasmVal GetReturnValue(int index) {
     if (state_ == WasmInterpreter::TRAPPED) return WasmVal(0xdeadbeef);
     CHECK_EQ(WasmInterpreter::FINISHED, state_);
     CHECK_LT(static_cast<size_t>(index), stack_.size());
     return stack_[index];
   }
 
   virtual pc_t GetBreakpointPc() { return break_pc_; }
 
+  virtual bool PossibleNondeterminism() { return possible_nondeterminism_; }
+
   bool Terminated() {
     return state_ == WasmInterpreter::TRAPPED ||
            state_ == WasmInterpreter::FINISHED;
   }
 
  private:
   // Entries on the stack of functions being evaluated.
   struct Frame {
     InterpreterCode* code;
     pc_t call_pc;
@@ skipping 14 matching lines @@
   };
 
   CodeMap* codemap_;
   WasmInstance* instance_;
   ZoneVector<WasmVal> stack_;
   ZoneVector<Frame> frames_;
   ZoneVector<Block> blocks_;
   WasmInterpreter::State state_;
   pc_t break_pc_;
   TrapReason trap_reason_;
+  bool possible_nondeterminism_;
 
   CodeMap* codemap() { return codemap_; }
   WasmInstance* instance() { return instance_; }
   const WasmModule* module() { return instance_->module; }
 
   void DoTrap(TrapReason trap, pc_t pc) {
     state_ = WasmInterpreter::TRAPPED;
     trap_reason_ = trap;
     CommitPc(pc);
   }
@@ skipping 495 matching lines @@
   case kExpr##name: {                                     \
     WasmVal rval = Pop();                                 \
     WasmVal lval = Pop();                                 \
     WasmVal result(lval.to<ctype>() op rval.to<ctype>()); \
     Push(pc, result);                                     \
     break;                                                \
   }
           FOREACH_SIMPLE_BINOP(EXECUTE_SIMPLE_BINOP)
 #undef EXECUTE_SIMPLE_BINOP
 
+#define EXECUTE_SIMPLE_BINOP_NAN(name, ctype, op)        \
+  case kExpr##name: {                                    \
+    WasmVal rval = Pop();                                \
+    WasmVal lval = Pop();                                \
+    ctype result = lval.to<ctype>() op rval.to<ctype>(); \
+    possible_nondeterminism_ |= std::isnan(result);      \
+    WasmVal result_val(result);                          \
+    Push(pc, result_val);                                \
+    break;                                               \
+  }
+          FOREACH_SIMPLE_BINOP_NAN(EXECUTE_SIMPLE_BINOP_NAN)
+#undef EXECUTE_SIMPLE_BINOP_NAN
+
 #define EXECUTE_OTHER_BINOP(name, ctype)              \
   case kExpr##name: {                                 \
     TrapReason trap = kTrapCount;                     \
     volatile ctype rval = Pop().to<ctype>();          \
     volatile ctype lval = Pop().to<ctype>();          \
     WasmVal result(Execute##name(lval, rval, &trap)); \
     if (trap != kTrapCount) return DoTrap(trap, pc);  \
     Push(pc, result);                                 \
     break;                                            \
   }
           FOREACH_OTHER_BINOP(EXECUTE_OTHER_BINOP)
 #undef EXECUTE_OTHER_BINOP
 
 #define EXECUTE_OTHER_UNOP(name, ctype)              \
   case kExpr##name: {                                \
     TrapReason trap = kTrapCount;                    \
     volatile ctype val = Pop().to<ctype>();          \
     WasmVal result(Execute##name(val, &trap));       \
     if (trap != kTrapCount) return DoTrap(trap, pc); \
     Push(pc, result);                                \
     break;                                           \
   }
           FOREACH_OTHER_UNOP(EXECUTE_OTHER_UNOP)
 #undef EXECUTE_OTHER_UNOP
 
+#define EXECUTE_OTHER_UNOP_NAN(name, ctype)          \
+  case kExpr##name: {                                \
+    TrapReason trap = kTrapCount;                    \
+    volatile ctype val = Pop().to<ctype>();          \
+    ctype result = Execute##name(val, &trap);        \
+    possible_nondeterminism_ |= std::isnan(result);  \
+    WasmVal result_val(result);                      \
+    if (trap != kTrapCount) return DoTrap(trap, pc); \
+    Push(pc, result_val);                            \
+    break;                                           \
+  }
+          FOREACH_OTHER_UNOP_NAN(EXECUTE_OTHER_UNOP_NAN)
+#undef EXECUTE_OTHER_UNOP_NAN
+
         default:
           V8_Fatal(__FILE__, __LINE__, "Unknown or unimplemented opcode #%d:%s",
                    code->start[pc], OpcodeName(code->start[pc]));
           UNREACHABLE();
       }
 
       pc += len;
     }
     UNREACHABLE();  // above decoding loop should run forever.
   }
@@ skipping 204 matching lines @@
 
 ControlTransferMap WasmInterpreter::ComputeControlTransfersForTesting(
     Zone* zone, const byte* start, const byte* end) {
   ControlTransfers targets(zone, nullptr, nullptr, start, end);
   return targets.map_;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8