[wasm] Implement frame inspection for interpreted frames

src/wasm/wasm-debug.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/assembler-inl.h"
 #include "src/assert-scope.h"
 #include "src/compiler/wasm-compiler.h"
 #include "src/debug/debug.h"
 #include "src/factory.h"
 #include "src/frames-inl.h"
 #include "src/isolate.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-interpreter.h"
 #include "src/wasm/wasm-limits.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-objects.h"
 #include "src/zone/accounting-allocator.h"
 
 using namespace v8::internal;
 using namespace v8::internal::wasm;
 
 namespace {
 
 class InterpreterHandle {
   AccountingAllocator allocator_;
   WasmInstance instance_;
   WasmInterpreter interpreter_;
+  Isolate *isolate_;
 
  public:
   // Initialize in the right order, using helper methods to make this possible.
   // WasmInterpreter has to be allocated in place, since it is not movable.
   InterpreterHandle(Isolate *isolate, WasmDebugInfo *debug_info)
       : instance_(debug_info->wasm_instance()->compiled_module()->module()),
-        interpreter_(GetBytesEnv(&instance_, debug_info), &allocator_) {
+        interpreter_(GetBytesEnv(&instance_, debug_info), &allocator_),
+        isolate_(isolate) {
     Handle<JSArrayBuffer> mem_buffer =
         handle(debug_info->wasm_instance()->memory_buffer(), isolate);
     if (mem_buffer->IsUndefined(isolate)) {
       DCHECK_EQ(0, instance_.module->min_mem_pages);
       instance_.mem_start = nullptr;
       instance_.mem_size = 0;
     } else {
       instance_.mem_start =
           reinterpret_cast<byte *>(mem_buffer->backing_store());
       CHECK(mem_buffer->byte_length()->ToUint32(&instance_.mem_size));
@@ skipping 45 matching lines @@
     DCHECK(thread->state() == WasmInterpreter::STOPPED ||
            thread->state() == WasmInterpreter::FINISHED);
     thread->Reset();
     thread->PushFrame(&module()->functions[func_index], wasm_args.start());
     WasmInterpreter::State state;
     do {
       state = thread->Run();
       switch (state) {
         case WasmInterpreter::State::PAUSED: {
           // We hit a breakpoint.
-          // TODO(clemensh): Handle this.
+          StackTraceFrameIterator frame_it(isolate_);
+          isolate_->debug()->Break(frame_it.frame());
         } break;
         case WasmInterpreter::State::FINISHED:
           // Perfect, just break the switch and exit the loop.
           break;
         case WasmInterpreter::State::TRAPPED:
           // TODO(clemensh): Generate appropriate JS exception.
           UNIMPLEMENTED();
           break;
         // STOPPED and RUNNING should never occur here.
         case WasmInterpreter::State::STOPPED:
@@ skipping 18 matching lines @@
         CASE_RET_TYPE(kWasmI32, uint32_t)
         CASE_RET_TYPE(kWasmI64, uint64_t)
         CASE_RET_TYPE(kWasmF32, float)
         CASE_RET_TYPE(kWasmF64, double)
 #undef CASE_RET_TYPE
         default:
           UNREACHABLE();
       }
     }
   }
+
+  std::vector<std::pair<uint32_t, int>> GetInterpretedStack(
+      Address frame_pointer) {
+    // TODO(clemensh): Use frame_pointer.
+    USE(frame_pointer);
+
+    DCHECK_EQ(1, interpreter()->GetThreadCount());
+    WasmInterpreter::Thread *thread = interpreter()->GetThread(0);
+    std::vector<std::pair<uint32_t, int>> stack;
+    for (int i = thread->GetFrameCount() - 1; i >= 0; --i) {
+      wasm::InterpretedFrame frame = thread->GetFrame(0);
+      stack.push_back({frame.function()->func_index, frame.pc()});
+    }
+    return stack;
+  }
+
+  wasm::InterpretedFrame GetInterpretedFrame(Address frame_pointer, int idx) {
+    // TODO(clemensh): Use frame_pointer.
+    USE(frame_pointer);
+
+    DCHECK_EQ(1, interpreter()->GetThreadCount());
+    WasmInterpreter::Thread *thread = interpreter()->GetThread(0);
+    return thread->GetMutableFrame(idx);
+  }
 };
 
 InterpreterHandle *GetOrCreateInterpreterHandle(
     Isolate *isolate, Handle<WasmDebugInfo> debug_info) {
   Handle<Object> handle(debug_info->get(WasmDebugInfo::kInterpreterHandle),
                         isolate);
   if (handle->IsUndefined(isolate)) {
     InterpreterHandle *cpp_handle = new InterpreterHandle(isolate, *debug_info);
     handle = Managed<InterpreterHandle>::New(isolate, cpp_handle);
     debug_info->set(WasmDebugInfo::kInterpreterHandle, *handle);
@@ skipping 116 matching lines @@
   EnsureRedirectToInterpreter(isolate, debug_info, func_index);
 }
 
 void WasmDebugInfo::RunInterpreter(Handle<WasmDebugInfo> debug_info,
                                    int func_index, uint8_t *arg_buffer) {
   DCHECK_LE(0, func_index);
   InterpreterHandle *interp_handle =
       GetOrCreateInterpreterHandle(debug_info->GetIsolate(), debug_info);
   interp_handle->Execute(static_cast<uint32_t>(func_index), arg_buffer);
 }
+
+std::vector<std::pair<uint32_t, int>> WasmDebugInfo::GetInterpretedStack(
+    Handle<WasmDebugInfo> debug_info, Address frame_pointer) {
+  InterpreterHandle *interp_handle =
+      GetOrCreateInterpreterHandle(debug_info->GetIsolate(), debug_info);
+  return interp_handle->GetInterpretedStack(frame_pointer);
+}
+
+std::unique_ptr<wasm::InterpretedFrame> WasmDebugInfo::GetInterpretedFrame(
+    Handle<WasmDebugInfo> debug_info, Address frame_pointer, int idx) {
+  InterpreterHandle *interp_handle =
+      GetOrCreateInterpreterHandle(debug_info->GetIsolate(), debug_info);
+  return std::unique_ptr<wasm::InterpretedFrame>(new wasm::InterpretedFrame(
+      interp_handle->GetInterpretedFrame(frame_pointer, idx)));
+}