[wasm] Implement stepping in wasm code

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"
@@ skipping 12 matching lines @@
 
 // Forward declaration.
 class InterpreterHandle;
 InterpreterHandle* GetInterpreterHandle(WasmDebugInfo* debug_info);
 
 class InterpreterHandle {
   AccountingAllocator allocator_;
   WasmInstance instance_;
   WasmInterpreter interpreter_;
   Isolate* isolate_;
+  StepAction next_step_action_ = StepNone;
+  int last_step_stack_depth_ = 0;
 
  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_),
         isolate_(isolate) {
     if (debug_info->wasm_instance()->has_memory_buffer()) {
       JSArrayBuffer* mem_buffer = debug_info->wasm_instance()->memory_buffer();
@@ skipping 13 matching lines @@
     // of this data anyway, and there is no heap allocation in-between.
     SeqOneByteString* bytes_str =
         debug_info->wasm_instance()->compiled_module()->module_bytes();
     Vector<const byte> bytes(bytes_str->GetChars(), bytes_str->length());
     return ModuleBytesEnv(instance->module, instance, bytes);
   }
 
   WasmInterpreter* interpreter() { return &interpreter_; }
   const WasmModule* module() { return instance_.module; }
 
+  void PrepareStep(StepAction step_action) {
+    next_step_action_ = step_action;
+    last_step_stack_depth_ = CurrentStackDepth();
+  }
+
+  void ClearStepping() { next_step_action_ = StepNone; }
+
+  int CurrentStackDepth() {
+    DCHECK_EQ(1, interpreter()->GetThreadCount());
+    return interpreter()->GetThread(0)->GetFrameCount();
+  }
+
   void Execute(uint32_t func_index, uint8_t* arg_buffer) {
     DCHECK_GE(module()->functions.size(), func_index);
     FunctionSig* sig = module()->functions[func_index].sig;
     DCHECK_GE(kMaxInt, sig->parameter_count());
     int num_params = static_cast<int>(sig->parameter_count());
     ScopedVector<WasmVal> wasm_args(num_params);
     uint8_t* arg_buf_ptr = arg_buffer;
     for (int i = 0; i < num_params; ++i) {
       uint32_t param_size = 1 << ElementSizeLog2Of(sig->GetParam(i));
 #define CASE_ARG_TYPE(type, ctype)                                  \
@@ skipping 13 matching lines @@
       arg_buf_ptr += param_size;
     }
 
     WasmInterpreter::Thread* thread = interpreter_.GetThread(0);
     // We do not support reentering an already running interpreter at the moment
     // (like INTERPRETER -> JS -> WASM -> INTERPRETER).
     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();
+    bool finished = false;

[titzer, 2017/01/23 10:10:10]

Can you drop in a TODO here that the interpreter returns after so many
instructions are executed, and that this would probably be the place to
implement stack checks (i.e. checks for interruption)?

[Clemens Hammacher, 2017/01/23 12:25:34]

Done.

+    while (!finished) {
+      WasmInterpreter::State state = ContinueExecution(thread);
       switch (state) {
         case WasmInterpreter::State::PAUSED:
-          NotifyDebugEventListeners();
+          NotifyDebugEventListeners(thread);
           break;
         case WasmInterpreter::State::FINISHED:
           // Perfect, just break the switch and exit the loop.
+          finished = true;
           break;
         case WasmInterpreter::State::TRAPPED:
           // TODO(clemensh): Generate appropriate JS exception.
           UNIMPLEMENTED();
           break;
         // STOPPED and RUNNING should never occur here.
         case WasmInterpreter::State::STOPPED:
         case WasmInterpreter::State::RUNNING:
         default:
           UNREACHABLE();
       }
-    } while (state != WasmInterpreter::State::FINISHED);
+    }
 
     // Copy back the return value
     DCHECK_GE(kV8MaxWasmFunctionReturns, sig->return_count());
     // TODO(wasm): Handle multi-value returns.
     DCHECK_EQ(1, kV8MaxWasmFunctionReturns);
     if (sig->return_count()) {
       WasmVal ret_val = thread->GetReturnValue(0);
 #define CASE_RET_TYPE(type, ctype)                                       \
   case type:                                                             \
     DCHECK_EQ(1 << ElementSizeLog2Of(sig->GetReturn(0)), sizeof(ctype)); \
     *reinterpret_cast<ctype*>(arg_buffer) = ret_val.to<ctype>();         \
     break;
       switch (sig->GetReturn(0)) {
         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();
       }
     }
   }
 
+  WasmInterpreter::State ContinueExecution(WasmInterpreter::Thread* thread) {
+    switch (next_step_action_) {
+      case StepNone:
+        return thread->Run();
+      case StepIn:
+        return thread->Step();
+      case StepOut:
+        thread->AddBreakFlags(WasmInterpreter::BreakFlag::AfterReturn);
+        return thread->Step();
+      case StepNext: {
+        int stack_depth = thread->GetFrameCount();
+        if (stack_depth == last_step_stack_depth_) return thread->Step();
+        thread->AddBreakFlags(stack_depth > last_step_stack_depth_
+                                  ? WasmInterpreter::BreakFlag::AfterReturn
+                                  : WasmInterpreter::BreakFlag::AfterCall);
+        return thread->Run();
+      }
+      case StepFrame:
+        thread->AddBreakFlags(WasmInterpreter::BreakFlag::AfterCall |
+                              WasmInterpreter::BreakFlag::AfterReturn);
+        return thread->Run();
+      default:
+        UNREACHABLE();
+        return WasmInterpreter::STOPPED;
+    }
+  }
+
   Handle<WasmInstanceObject> GetInstanceObject() {
     StackTraceFrameIterator it(isolate_);
     WasmInterpreterEntryFrame* frame =
         WasmInterpreterEntryFrame::cast(it.frame());
     Handle<WasmInstanceObject> instance_obj(frame->wasm_instance(), isolate_);
     DCHECK_EQ(this, GetInterpreterHandle(instance_obj->debug_info()));
     return instance_obj;
   }
 
-  void NotifyDebugEventListeners() {
+  void NotifyDebugEventListeners(WasmInterpreter::Thread* thread) {
     // Enter the debugger.
     DebugScope debug_scope(isolate_->debug());
     if (debug_scope.failed()) return;
 
     // Postpone interrupt during breakpoint processing.
     PostponeInterruptsScope postpone(isolate_);
 
-    // If we are paused on a breakpoint, clear all stepping and notify the
-    // listeners.
-    Handle<WasmCompiledModule> compiled_module(
-        GetInstanceObject()->compiled_module(), isolate_);
-    int position = GetTopPosition(compiled_module);
-    MaybeHandle<FixedArray> hit_breakpoints;
+    // Check whether we hit a breakpoint.
     if (isolate_->debug()->break_points_active()) {
-      hit_breakpoints = compiled_module->CheckBreakPoints(position);
+      Handle<WasmCompiledModule> compiled_module(

[titzer, 2017/01/23 10:10:10]

Should probably discuss more about how this works, because I don't fully
understand how breakpoints are stored in general. E.g. to what extend breakpoint
state might better live in the WasmInterpreter.

[Clemens Hammacher, 2017/01/23 12:25:34]

Breakpoints are currently still created from JS, and contain information like an
"active" flag, and a "condition" which we might also want to evaluate for wasm
at some point (e.g. by creating an artificial context which binds local
variables).
I think it currently makes sense to reuse that part of the breakpoint logic.

+          GetInstanceObject()->compiled_module(), isolate_);
+      int position = GetTopPosition(compiled_module);
+      Handle<FixedArray> breakpoints;
+      if (compiled_module->CheckBreakPoints(position).ToHandle(&breakpoints)) {
+        // We hit one or several breakpoints. Clear stepping, notify the
+        // listeners and return.
+        ClearStepping();
+        Handle<Object> hit_breakpoints_js =
+            isolate_->factory()->NewJSArrayWithElements(breakpoints);
+        isolate_->debug()->OnDebugBreak(hit_breakpoints_js, false);
+        return;
+      }
     }
 
-    // If we hit a breakpoint, pass a JSArray with all breakpoints, otherwise
-    // pass undefined.
-    Handle<Object> hit_breakpoints_js;
-    if (hit_breakpoints.is_null()) {
-      hit_breakpoints_js = isolate_->factory()->undefined_value();
-    } else {
-      hit_breakpoints_js = isolate_->factory()->NewJSArrayWithElements(
-          hit_breakpoints.ToHandleChecked());
+    // We did not hit a breakpoint, so maybe this pause is related to stepping.
+    bool hit_step = false;
+    switch (next_step_action_) {
+      case StepNone:
+        break;
+      case StepIn:
+        hit_step = true;
+        break;
+      case StepOut:
+        hit_step = thread->GetFrameCount() < last_step_stack_depth_;
+        break;
+      case StepNext: {
+        hit_step = thread->GetFrameCount() == last_step_stack_depth_;
+        break;
+      }
+      case StepFrame:
+        hit_step = thread->GetFrameCount() != last_step_stack_depth_;
+        break;
+      default:
+        UNREACHABLE();
     }
-
-    isolate_->debug()->OnDebugBreak(hit_breakpoints_js, false);
+    if (!hit_step) return;
+    ClearStepping();
+    isolate_->debug()->OnDebugBreak(isolate_->factory()->undefined_value(),
+                                    false);
   }
 
   int GetTopPosition(Handle<WasmCompiledModule> compiled_module) {
     DCHECK_EQ(1, interpreter()->GetThreadCount());
     WasmInterpreter::Thread* thread = interpreter()->GetThread(0);
     DCHECK_LT(0, thread->GetFrameCount());
 
     wasm::InterpretedFrame frame =
         thread->GetFrame(thread->GetFrameCount() - 1);
     return compiled_module->GetFunctionOffset(frame.function()->func_index) +
@@ skipping 153 matching lines @@
   Isolate* isolate = debug_info->GetIsolate();
   InterpreterHandle* handle = GetOrCreateInterpreterHandle(isolate, debug_info);
   WasmInterpreter* interpreter = handle->interpreter();
   DCHECK_LE(0, func_index);
   DCHECK_GT(handle->module()->functions.size(), func_index);
   const WasmFunction* func = &handle->module()->functions[func_index];
   interpreter->SetBreakpoint(func, offset, true);
   EnsureRedirectToInterpreter(isolate, debug_info, func_index);
 }
 
+void WasmDebugInfo::PrepareStep(StepAction step_action) {
+  GetInterpreterHandle(this)->PrepareStep(step_action);
+}
+
 void WasmDebugInfo::RunInterpreter(int func_index, uint8_t* arg_buffer) {
   DCHECK_LE(0, func_index);
   GetInterpreterHandle(this)->Execute(static_cast<uint32_t>(func_index),
                                       arg_buffer);
 }
 
 std::vector<std::pair<uint32_t, int>> WasmDebugInfo::GetInterpretedStack(
     Address frame_pointer) {
   return GetInterpreterHandle(this)->GetInterpretedStack(frame_pointer);
 }
 
 std::unique_ptr<wasm::InterpretedFrame> WasmDebugInfo::GetInterpretedFrame(
     Address frame_pointer, int idx) {
   return GetInterpreterHandle(this)->GetInterpretedFrame(frame_pointer, idx);
 }