[wasm] Implement stepping in wasm code

src/debug/debug.cc

 // Copyright 2012 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/debug/debug.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 967 matching lines @@
   DCHECK(in_debug_scope());
 
   // Get the frame where the execution has stopped and skip the debug frame if
   // any. The debug frame will only be present if execution was stopped due to
   // hitting a break point. In other situations (e.g. unhandled exception) the
   // debug frame is not present.
   StackFrame::Id frame_id = break_frame_id();
   // If there is no JavaScript stack don't do anything.
   if (frame_id == StackFrame::NO_ID) return;
 
-  JavaScriptFrameIterator frames_it(isolate_, frame_id);
-  JavaScriptFrame* frame = frames_it.frame();
+  StackTraceFrameIterator frames_it(isolate_, frame_id);
+  StandardFrame* frame = frames_it.frame();
 
   feature_tracker()->Track(DebugFeatureTracker::kStepping);
 
   thread_local_.last_step_action_ = step_action;
   UpdateHookOnFunctionCall();
 
+  // Handle stepping in wasm functions via the wasm interpreter.
+  if (frame->is_wasm()) {

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

How do we know that this is a WasmInterpreterEntryFrame? Could it also be a
WasmCompiledFrame?

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

Not in stepping or when paused at a breakpoint, but I think it could actually
happen if we pause on a thrown exception.
I added an if there, and we just do nothing if it's compiled.

+    WasmInterpreterEntryFrame* wasm_frame =
+        WasmInterpreterEntryFrame::cast(frame);
+    wasm_frame->wasm_instance()->debug_info()->PrepareStep(step_action);
+    return;
+  }
+
+  JavaScriptFrame* js_frame = JavaScriptFrame::cast(frame);
+
   // If the function on the top frame is unresolved perform step out. This will
   // be the case when calling unknown function and having the debugger stopped
   // in an unhandled exception.
-  if (!frame->function()->IsJSFunction()) {
+  if (!js_frame->function()->IsJSFunction()) {
     // Step out: Find the calling JavaScript frame and flood it with
     // breakpoints.
     frames_it.Advance();
     // Fill the function to return to with one-shot break points.
-    JSFunction* function = frames_it.frame()->function();
-    FloodWithOneShot(Handle<JSFunction>(function));
+    JSFunction* function = JavaScriptFrame::cast(frames_it.frame())->function();
+    FloodWithOneShot(handle(function, isolate_));
     return;
   }
 
   // Get the debug info (create it if it does not exist).
   auto summary = FrameSummary::GetTop(frame).AsJavaScript();
   Handle<JSFunction> function(summary.function());
   Handle<SharedFunctionInfo> shared(function->shared());
   if (!EnsureDebugInfo(shared, function)) {
     // Return if ensuring debug info failed.
     return;
   }
 
   Handle<DebugInfo> debug_info(shared->GetDebugInfo());
-  BreakLocation location = BreakLocation::FromFrame(debug_info, frame);
+  BreakLocation location = BreakLocation::FromFrame(debug_info, js_frame);
 
   // Any step at a return is a step-out.
   if (location.IsReturn()) step_action = StepOut;
   // A step-next at a tail call is a step-out.
   if (location.IsTailCall() && step_action == StepNext) step_action = StepOut;
 
   thread_local_.last_statement_position_ =
       summary.abstract_code()->SourceStatementPosition(summary.code_offset());
   thread_local_.last_fp_ = frame->UnpaddedFP();
   // No longer perform the current async step.
   clear_suspended_generator();
 
   switch (step_action) {
     case StepNone:
       UNREACHABLE();
       break;
     case StepOut:
       // Advance to caller frame.
       frames_it.Advance();
       // Skip native and extension functions on the stack.
-      while (!frames_it.done() &&
-             !frames_it.frame()->function()->shared()->IsSubjectToDebugging()) {
+      while (!frames_it.done()) {
+        if (!frames_it.frame()->is_java_script()) break;
+        JavaScriptFrame* js_frame = JavaScriptFrame::cast(frames_it.frame());
+        if (js_frame->function()->shared()->IsSubjectToDebugging()) break;
         // Builtin functions are not subject to stepping, but need to be
         // deoptimized to include checks for step-in at call sites.
-        Deoptimizer::DeoptimizeFunction(frames_it.frame()->function());
+        Deoptimizer::DeoptimizeFunction(js_frame->function());
         frames_it.Advance();
       }
       if (!frames_it.done()) {

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

Does it make sense to move this condition into the loop?

AFAICT the only two ways to exit the loop are either to finish the frame
iterator, if the frame is not JS, or if the frame is not subject to debugging,
but it is hard to tell if I am missing something because of the structure. 

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

I agree that the loop is hard to read. It basically just deoptimizes everything
on the top which is not subject to debugging. It stops at the first frame this
is subject to debugging, i.e. unoptimized JS or Wasm.

-        // Fill the caller function to return to with one-shot break points.
-        Handle<JSFunction> caller_function(frames_it.frame()->function());
-        FloodWithOneShot(caller_function);
-        thread_local_.target_fp_ = frames_it.frame()->UnpaddedFP();
+        StandardFrame* caller_frame = frames_it.frame();
+        if (caller_frame->is_wasm()) {
+          // TODO(clemensh): Implement stepping out from JS to WASM.
+        } else {
+          JavaScriptFrame* js_caller_frame =
+              JavaScriptFrame::cast(caller_frame);
+          // Fill the caller function to return to with one-shot break points.
+          Handle<JSFunction> caller_function(js_caller_frame->function());
+          FloodWithOneShot(caller_function);
+          thread_local_.target_fp_ = frames_it.frame()->UnpaddedFP();
+        }
       }
       // Clear last position info. For stepping out it does not matter.
       thread_local_.last_statement_position_ = kNoSourcePosition;
       thread_local_.last_fp_ = 0;
       break;
     case StepNext:
       thread_local_.target_fp_ = frame->UnpaddedFP();
       FloodWithOneShot(function);
       break;
     case StepIn:
+      // TODO(clemensh): Implement stepping from JS into WASM.
       FloodWithOneShot(function);
       break;
     case StepFrame:
+      // TODO(clemensh): Implement stepping from JS into WASM or vice versa.
       // No point in setting one-shot breaks at places where we are not about
       // to leave the current frame.
       FloodWithOneShot(function, CALLS_AND_RETURNS);
       break;
   }
 }
 
 // Simple function for returning the source positions for active break points.
 Handle<Object> Debug::GetSourceBreakLocations(
     Handle<SharedFunctionInfo> shared,
@@ skipping 1590 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8