[wasm] Use pimpl idiom for interpreter thread implementation

src/wasm/wasm-interpreter.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 V8_WASM_INTERPRETER_H_
 #define V8_WASM_INTERPRETER_H_
 
 #include "src/wasm/wasm-opcodes.h"
 #include "src/zone/zone-containers.h"
 
@@ skipping 61 matching lines @@
 
 template <>
 inline void WasmVal::to() {
   CHECK_EQ(kWasmStmt, type);
 }
 
 // Representation of frames within the interpreter.
 class WasmFrame {
  public:
   const WasmFunction* function() const { return function_; }
-  int pc() const { return pc_; }
+  int pc() const {
+    // TODO(wasm): Remove USE once we actually use them.
+    USE(fp_);
+    USE(sp_);
+    return pc_;
+  }
 
  private:
   friend class WasmInterpreter;
 
   WasmFrame(const WasmFunction* function, int pc, int fp, int sp)
       : function_(function), pc_(pc), fp_(fp), sp_(sp) {}
 
   const WasmFunction* function_;
   int pc_;
   int fp_;
   int sp_;
 };
 
 // An interpreter capable of executing WASM.
 class V8_EXPORT_PRIVATE WasmInterpreter {
  public:
   // State machine for a Thread:
   //                       +---------------Run()-----------+
   //                       V                               |
   // STOPPED ---Run()-->  RUNNING  ------Pause()-----+-> PAUSED  <------+
   //                       | | |                    /      |            |
   //                       | | +---- Breakpoint ---+       +-- Step() --+
   //                       | |
   //                       | +------------ Trap --------------> TRAPPED
   //                       +------------- Finish -------------> FINISHED
   enum State { STOPPED, RUNNING, PAUSED, FINISHED, TRAPPED };
 
   // Representation of a thread in the interpreter.
-  class Thread {
+  class ThreadImpl;
+  class V8_EXPORT_PRIVATE Thread {
+    ThreadImpl* impl_;
+
    public:
+    explicit Thread(ThreadImpl*);
+
     // Execution control.
-    virtual State state() = 0;
-    virtual void PushFrame(const WasmFunction* function, WasmVal* args) = 0;
-    virtual State Run() = 0;
-    virtual State Step() = 0;
-    virtual void Pause() = 0;
-    virtual void Reset() = 0;
-    virtual ~Thread() {}
+    State state();
+    void PushFrame(const WasmFunction* function, WasmVal* args);
+    State Run();
+    State Step();
+    void Pause();
+    void Reset();
 
     // Stack inspection and modification.
-    virtual pc_t GetBreakpointPc() = 0;
-    virtual int GetFrameCount() = 0;
-    virtual const WasmFrame* GetFrame(int index) = 0;
-    virtual WasmFrame* GetMutableFrame(int index) = 0;
-    virtual WasmVal GetReturnValue(int index = 0) = 0;
+    pc_t GetBreakpointPc();
+    int GetFrameCount();
+    const WasmFrame* GetFrame(int index);
+    WasmFrame* GetMutableFrame(int index);
+    WasmVal GetReturnValue(int index = 0);
     // Returns true if the thread executed an instruction which may produce
     // nondeterministic results, e.g. float div, float sqrt, and float mul,
     // where the sign bit of a NaN is nondeterministic.
-    virtual bool PossibleNondeterminism() = 0;
+    bool PossibleNondeterminism();
 
     // Thread-specific breakpoints.
-    bool SetBreakpoint(const WasmFunction* function, int pc, bool enabled);
-    bool GetBreakpoint(const WasmFunction* function, int pc);
+    // TODO(wasm): Implement this once we support multiple threads.
+    // bool SetBreakpoint(const WasmFunction* function, int pc, bool enabled);
+    // bool GetBreakpoint(const WasmFunction* function, int pc);
   };
 
   WasmInterpreter(const ModuleBytesEnv& env, AccountingAllocator* allocator);
   ~WasmInterpreter();
 
   //==========================================================================
   // Execution controls.
   //==========================================================================
   void Run();
   void Pause();
@@ skipping 48 matching lines @@
  private:
   Zone zone_;
   WasmInterpreterInternals* internals_;
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_INTERPRETER_H_