[wasm] prototype for breakpoint support.

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-containers.h"
 
@@ skipping 66 matching lines @@
   }
 FOREACH_UNION_MEMBER(DECLARE_CAST)
 #undef DECLARE_CAST
 
 template <>
 inline void WasmVal::to() {
   CHECK_EQ(kAstStmt, type);
 }
 
 // Representation of frames within the interpreter.
-class WasmFrame {
+class WasmInterpreterFrame {
  public:
   const WasmFunction* function() const { return function_; }
   int pc() const { return pc_; }
 
  private:
   friend class WasmInterpreter;
+  friend class ThreadImpl;
 
-  WasmFrame(const WasmFunction* function, int pc, int fp, int sp)
+  WasmInterpreterFrame(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 WasmInterpreter {
@@ skipping 17 matching lines @@
     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() {}
 
     // 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 const WasmInterpreterFrame* GetFrame(int index) = 0;
+    virtual WasmInterpreterFrame* GetMutableFrame(int index) = 0;
     virtual WasmVal GetReturnValue() = 0;
 
     // Thread-specific breakpoints.
-    bool SetBreakpoint(const WasmFunction* function, int pc, bool enabled);
-    bool GetBreakpoint(const WasmFunction* function, int pc);
+    bool SetBreakpoint(uint32_t function_index, int pc, bool enabled);
+    bool GetBreakpoint(uint32_t function_index, int pc);
   };
 
-  WasmInterpreter(WasmModuleInstance* instance,
-                  base::AccountingAllocator* allocator);
+  WasmInterpreter(WasmModuleInstance* instance, Zone* zone);
   ~WasmInterpreter();
 
   //==========================================================================
   // Execution controls.
   //==========================================================================
   void Run();
   void Pause();
 
-  // Set a breakpoint at {pc} in {function} to be {enabled}. Returns the
+  // Set a breakpoint at {pc} in {function_index} to be {enabled}. Returns the
   // previous state of the breakpoint at {pc}.
-  bool SetBreakpoint(const WasmFunction* function, pc_t pc, bool enabled);
+  bool SetBreakpoint(uint32_t function_index, pc_t pc, bool enabled);
 
-  // Gets the current state of the breakpoint at {function}.
-  bool GetBreakpoint(const WasmFunction* function, pc_t pc);
+  // Gets the current state of the breakpoint at {function_index}.
+  bool GetBreakpoint(uint32_t function_index, pc_t pc);
 
   // Enable or disable tracing for {function}. Return the previous state.
   bool SetTracing(const WasmFunction* function, bool enabled);
 
   //==========================================================================
   // Thread iteration and inspection.
   //==========================================================================
   int GetThreadCount();
   Thread* GetThread(int id);
 
   //==========================================================================
   // Stack frame inspection.
   //==========================================================================
-  WasmVal GetLocalVal(const WasmFrame* frame, int index);
-  WasmVal GetExprVal(const WasmFrame* frame, int pc);
-  void SetLocalVal(WasmFrame* frame, int index, WasmVal val);
-  void SetExprVal(WasmFrame* frame, int pc, WasmVal val);
+  WasmVal GetLocalVal(const WasmInterpreterFrame* frame, int index);
+  WasmVal GetExprVal(const WasmInterpreterFrame* frame, int pc);
+  void SetLocalVal(WasmInterpreterFrame* frame, int index, WasmVal val);
+  void SetExprVal(WasmInterpreterFrame* frame, int pc, WasmVal val);
 
   //==========================================================================
   // Memory access.
   //==========================================================================
   size_t GetMemorySize();
   WasmVal ReadMemory(size_t offset);
   void WriteMemory(size_t offset, WasmVal val);
 
   //==========================================================================
   // Testing functionality.
   //==========================================================================
   // Manually adds a function to this interpreter, returning the index of the
   // function.
   int AddFunctionForTesting(const WasmFunction* function);
   // Manually adds code to the interpreter for the given function.
   bool SetFunctionCodeForTesting(const WasmFunction* function,
                                  const byte* start, const byte* end);
 
   // Computes the control targets for the given bytecode as {pc offset, sp
   // offset}
   // pairs. Used internally in the interpreter, but exposed for testing.
   static ControlTransferMap ComputeControlTransfersForTesting(Zone* zone,
                                                               const byte* start,
                                                               const byte* end);
 
  private:
-  Zone zone_;
+  Zone* zone_;
   WasmInterpreterInternals* internals_;
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_INTERPRETER_H_