[wasm] Implement frame inspection for interpreted frames

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/decoder.h"
 #include "src/wasm/function-body-decoder.h"
 #include "src/wasm/wasm-external-refs.h"
@@ skipping 1016 matching lines @@
 
   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 int GetFrameCount() {
+    DCHECK_GE(kMaxInt, frames_.size());
+    return static_cast<int>(frames_.size());
   }
 
-  virtual WasmFrame* GetMutableFrame(int index) {
-    UNIMPLEMENTED();
-    return nullptr;
+  virtual const InterpretedFrame GetFrame(int index) {
+    return GetMutableFrame(index);
+  }
+
+  virtual InterpretedFrame GetMutableFrame(int index) {
+    DCHECK_LE(0, index);
+    DCHECK_GT(frames_.size(), index);
+    Frame* fr = &frames_[index];

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

Might as well spell out {frame} or call it {f}.

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

Done. It's {frame} now.

+    DCHECK_GE(kMaxInt, fr->ret_pc);
+    DCHECK_GE(kMaxInt, fr->sp);
+    DCHECK_GE(kMaxInt, fr->llimit());
+    return InterpretedFrame(fr->code->function, static_cast<int>(fr->ret_pc),
+                            static_cast<int>(fr->sp),
+                            static_cast<int>(fr->llimit()));
   }
 
   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_; }
@@ skipping 773 matching lines @@
 
 int WasmInterpreter::GetThreadCount() {
   return 1;  // only one thread for now.
 }
 
 WasmInterpreter::Thread* WasmInterpreter::GetThread(int id) {
   CHECK_EQ(0, id);  // only one thread for now.
   return internals_->threads_[id];
 }
 
-WasmVal WasmInterpreter::GetLocalVal(const WasmFrame* frame, int index) {
-  CHECK_GE(index, 0);
-  UNIMPLEMENTED();
-  WasmVal none;
-  none.type = kWasmStmt;
-  return none;
-}
-
-WasmVal WasmInterpreter::GetExprVal(const WasmFrame* frame, int pc) {
-  UNIMPLEMENTED();
-  WasmVal none;
-  none.type = kWasmStmt;
-  return none;
-}
-
-void WasmInterpreter::SetLocalVal(WasmFrame* frame, int index, WasmVal val) {
-  UNIMPLEMENTED();
-}
-
-void WasmInterpreter::SetExprVal(WasmFrame* frame, int pc, WasmVal val) {
-  UNIMPLEMENTED();
-}
-
 size_t WasmInterpreter::GetMemorySize() {
   return internals_->instance_->mem_size;
 }
 
 WasmVal WasmInterpreter::ReadMemory(size_t offset) {
   UNIMPLEMENTED();
   return WasmVal();
 }
 
 void WasmInterpreter::WriteMemory(size_t offset, WasmVal val) {
   UNIMPLEMENTED();
 }
 
 int WasmInterpreter::AddFunctionForTesting(const WasmFunction* function) {
   return internals_->codemap_.AddFunction(function, nullptr, nullptr);
 }
 
 bool WasmInterpreter::SetFunctionCodeForTesting(const WasmFunction* function,
                                                 const byte* start,
                                                 const byte* end) {
   return internals_->codemap_.SetFunctionCode(function, start, end);
 }
 
 ControlTransferMap WasmInterpreter::ComputeControlTransfersForTesting(
     Zone* zone, const byte* start, const byte* end) {
   ControlTransfers targets(zone, nullptr, start, end);
   return targets.map_;
 }
 
+//============================================================================
+// Implementation of the frame inspection interface.
+//============================================================================
+int InterpretedFrame::GetParameterCount() const {
+  UNIMPLEMENTED();
+  return 0;
+}
+
+WasmVal InterpretedFrame::GetLocalVal(int index) const {
+  CHECK_GE(index, 0);
+  UNIMPLEMENTED();
+  WasmVal none;
+  none.type = kWasmStmt;
+  return none;
+}
+
+WasmVal InterpretedFrame::GetExprVal(int pc) const {
+  UNIMPLEMENTED();
+  WasmVal none;
+  none.type = kWasmStmt;
+  return none;
+}
+
+void InterpretedFrame::SetLocalVal(int index, WasmVal val) { UNIMPLEMENTED(); }
+
+void InterpretedFrame::SetExprVal(int pc, WasmVal val) { UNIMPLEMENTED(); }
+
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8