[wasm] Implement frame inspection for interpreted frames

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 58 matching lines @@
   }
 FOREACH_UNION_MEMBER(DECLARE_CAST)
 #undef DECLARE_CAST
 
 template <>
 inline void WasmVal::to() {
   CHECK_EQ(kWasmStmt, type);
 }
 
 // Representation of frames within the interpreter.
-class WasmFrame {
+class InterpretedFrame {
  public:
   const WasmFunction* function() const { return function_; }
   int pc() const { return pc_; }
 
+  //==========================================================================

[titzer, 2017/01/16 10:18:25]

These methods are not going to be possible to implement directly on the
InterpretedFrame class, unless it has a reference back to the interpreter. This
is why these methods were directly on the WasmInterpreter, so that each frame
didn't have to close over the interpreter.

[Clemens Hammacher, 2017/01/16 11:53:26]

Yes, I was aware of that. I planned to include a pointer to the WasmInterpreter
once that's needed. Otherwise, we need to store both the WasmInterpreter and the
InterpretedFrame in the FrameInspector (debug-frames.h).
Having the pointer in the InterpretedFrame also makes it impossible to pass a
frame from another interpreter, which would give odd results.

Do you want me to put those methods back to the interpreter?

+  // Stack frame inspection.
+  //==========================================================================
+  int GetParameterCount() const;
+  WasmVal GetLocalVal(int index) const;
+  WasmVal GetExprVal(int pc) const;
+  void SetLocalVal(int index, WasmVal val);
+  void SetExprVal(int pc, WasmVal val);
+
  private:
-  friend class WasmInterpreter;
+  friend class ThreadImpl;
 
-  WasmFrame(const WasmFunction* function, int pc, int fp, int sp)
+  InterpretedFrame(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 {
@@ 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 InterpretedFrame GetFrame(int index) = 0;
+    virtual InterpretedFrame GetMutableFrame(int index) = 0;
     virtual WasmVal GetReturnValue(int index = 0) = 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;
 
     // Thread-specific breakpoints.
     bool SetBreakpoint(const WasmFunction* function, int pc, bool enabled);
     bool GetBreakpoint(const WasmFunction* function, int pc);
   };
@@ skipping 17 matching lines @@
   // 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);
-
-  //==========================================================================
   // 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
@@ skipping 12 matching lines @@
  private:
   Zone zone_;
   WasmInterpreterInternals* internals_;
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_INTERPRETER_H_