[wasm] prototype for breakpoint support.

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 "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 14 matching lines @@
 #include "src/wasm/wasm-debug.h"
 #include "src/wasm/wasm-module.h"
 
 #include "include/v8-debug.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
-inline int CallOffsetFromCodeOffset(int code_offset, bool is_interpreted) {
+inline int GetCodeOffset(StandardFrame* frame) {
+  // Frame summary is top-down, i.e. caller before callee.
+  // For whatever reason, javascript takes the lowest caller as the code offset
+  // for the frame, where for wasm we need the highest one.
+  return frame->is_java_script() ? FrameSummary::GetFirst(frame).code_offset()
+                                 : FrameSummary::GetLast(frame).code_offset();
+}
+
+inline int CallOffsetFromCodeOffset(int code_offset, StandardFrame* frame) {
   // Code offset points to the instruction after the call. Subtract 1 to
-  // exclude that instruction from the search. For bytecode, the code offset
-  // still points to the call.
-  return is_interpreted ? code_offset : code_offset - 1;
+  // exclude that instruction from the search. For interpreted frames, the code
+  // offset still points to the call.
+  bool interpreted = frame->is_interpreted() || frame->is_wasm_interpreted();
+  return interpreted ? code_offset : code_offset - 1;
+}
+
+std::pair<Handle<JSObject>, int> GetWasmObjectAndFunctionIndexFromCode(
+    Code* code) {
+  FixedArray* deopt_data = code->deoptimization_data();
+  DCHECK_EQ(2, deopt_data->length());
+  Handle<JSObject> wasm(JSObject::cast(deopt_data->get(0)));
+  int func_index = Smi::cast(deopt_data->get(1))->value();
+  return std::make_pair(wasm, func_index);
 }
 
 }  // namespace
 
 Debug::Debug(Isolate* isolate)
     : debug_context_(Handle<Context>()),
       event_listener_(Handle<Object>()),
       event_listener_data_(Handle<Object>()),
       message_handler_(NULL),
       command_received_(0),
@@ skipping 28 matching lines @@
     : debug_info_(debug_info),
       code_offset_(code_offset),
       type_(type),
       position_(position),
       statement_position_(statement_position) {}
 
 BreakLocation::Iterator* BreakLocation::GetIterator(
     Handle<DebugInfo> debug_info, BreakLocatorType type) {
   if (debug_info->abstract_code()->IsBytecodeArray()) {
     return new BytecodeArrayIterator(debug_info, type);
+  } else if (debug_info->abstract_code()->GetCode()->kind() ==
+             Code::WASM_FUNCTION) {
+    return new WasmBytecodeIterator(debug_info, type);
   } else {
     return new CodeIterator(debug_info, type);
   }
 }
 
 BreakLocation::Iterator::Iterator(Handle<DebugInfo> debug_info)
     : debug_info_(debug_info),
       break_index_(-1),
       position_(1),
       statement_position_(1) {}
@@ skipping 159 matching lines @@
   } else {
     return NOT_DEBUG_BREAK;
   }
 }
 
 BreakLocation BreakLocation::BytecodeArrayIterator::GetBreakLocation() {
   return BreakLocation(debug_info_, GetDebugBreakType(), code_offset(),
                        position(), statement_position());
 }
 
+namespace {
+
+wasm::WasmInstructionIterator GetWasmInsnIterator(
+    Handle<DebugInfo> debug_info) {
+  auto wasm_and_index = GetWasmObjectAndFunctionIndexFromCode(
+      debug_info->abstract_code()->GetCode());
+  Handle<wasm::WasmDebugInfo> wasm_debug_info(
+      wasm::GetDebugInfo(wasm_and_index.first));
+  return wasm::WasmDebugInfo::GetInstructionIterator(wasm_debug_info,
+                                                     wasm_and_index.second);
+}
+
+}  // namespace
+
+BreakLocation::WasmBytecodeIterator::WasmBytecodeIterator(
+    Handle<DebugInfo> debug_info, BreakLocatorType type)
+    : Iterator(debug_info),
+      wasm_insn_iterator(GetWasmInsnIterator(debug_info)),
+      break_locator_type_(type) {
+  // Get wasm object and function index from deopt data.
+  Code* code = debug_info->abstract_code()->GetCode();
+  Handle<JSObject> wasm;
+  std::tie(wasm, func_index) = GetWasmObjectAndFunctionIndexFromCode(code);
+  wasm_debug_info = handle(wasm::GetDebugInfo(wasm));
+  Next();
+}
+
+BreakLocation BreakLocation::WasmBytecodeIterator::GetBreakLocation() {
+  DebugBreakType type;
+  switch (wasm_debug_info->GetInstructionType(func_index,
+                                              wasm_insn_iterator.pc_offset())) {
+    case wasm::WasmDebugInfo::InstructionType::RETURN:
+      type = DEBUG_BREAK_SLOT_AT_RETURN;
+      break;
+    case wasm::WasmDebugInfo::InstructionType::CALL:
+      type = DEBUG_BREAK_SLOT_AT_CALL;
+      break;
+    default:
+      type = DEBUG_BREAK_SLOT;
+      break;
+  }
+  return BreakLocation(debug_info_, type, code_offset(), position(),
+                       statement_position());
+}
+
+void BreakLocation::WasmBytecodeIterator::Next() {
+  ++break_index_;
+  for (bool first = break_index_ == 0; !Done(); first = false) {
+    if (!first) wasm_insn_iterator.Next();
+    position_ = statement_position_ = wasm_insn_iterator.pc_offset();
+    if (break_locator_type_ == ALL_BREAK_LOCATIONS) break;
+    DCHECK_EQ(BreakLocatorType::CALLS_AND_RETURNS, break_locator_type_);
+    using InsnType = wasm::WasmDebugInfo::InstructionType;
+    InsnType type = wasm_debug_info->GetInstructionType(func_index, position_);
+    if (type == InsnType::RETURN || type == InsnType::CALL) break;
+  }
+}
+
 // Find the break point at the supplied address, or the closest one before
 // the address.
 BreakLocation BreakLocation::FromCodeOffset(Handle<DebugInfo> debug_info,
                                             int offset) {
   base::SmartPointer<Iterator> it(GetIterator(debug_info));
   it->SkipTo(BreakIndexFromCodeOffset(debug_info, offset));
   return it->GetBreakLocation();
 }
 
-BreakLocation BreakLocation::FromFrame(Handle<DebugInfo> debug_info,
-                                       JavaScriptFrame* frame) {
-  int code_offset = FrameSummary::GetFirst(frame).code_offset();
-  int call_offset =
-      CallOffsetFromCodeOffset(code_offset, frame->is_interpreted());
+BreakLocation BreakLocation::FromFrame(StandardFrame* frame) {
+  // Get the debug info (create it if it does not exist).
+  Handle<DebugInfo> debug_info(DebugInfo::cast(frame->debug_info(true)));
+
+  int code_offset = GetCodeOffset(frame);
+  int call_offset = CallOffsetFromCodeOffset(code_offset, frame);
   return FromCodeOffset(debug_info, call_offset);
 }
 
 void BreakLocation::AllForStatementPosition(Handle<DebugInfo> debug_info,
                                             int statement_position,
                                             List<BreakLocation>* result_out) {
   for (base::SmartPointer<Iterator> it(GetIterator(debug_info)); !it->Done();
        it->Next()) {
     if (it->statement_position() == statement_position) {
       result_out->Add(it->GetBreakLocation());
     }
   }
 }
 
 int BreakLocation::BreakIndexFromCodeOffset(Handle<DebugInfo> debug_info,
                                             int offset) {
   // Run through all break points to locate the one closest to the address.
   int closest_break = 0;
   int distance = kMaxInt;
-  DCHECK(0 <= offset && offset < debug_info->abstract_code()->Size());
+  DCHECK_LE(0, offset);
   for (base::SmartPointer<Iterator> it(GetIterator(debug_info)); !it->Done();
        it->Next()) {
     // Check if this break point is closer that what was previously found.
     if (it->code_offset() <= offset && offset - it->code_offset() < distance) {
       closest_break = it->break_index();
       distance = offset - it->code_offset();
       // Check whether we can't get any closer.
       if (distance == 0) break;
     }
   }
@@ skipping 88 matching lines @@
 
   // If there is already a break point here just return. This might happen if
   // the same code is flooded with break points twice. Flooding the same
   // function twice might happen when stepping in a function with an exception
   // handler as the handler and the function is the same.
   if (IsDebugBreak()) return;
 
   DCHECK(IsDebugBreakSlot());
   if (abstract_code()->IsCode()) {
     Code* code = abstract_code()->GetCode();
-    DCHECK(code->kind() == Code::FUNCTION);
-    Builtins* builtins = isolate()->builtins();
-    Handle<Code> target = IsReturn() ? builtins->Return_DebugBreak()
-                                     : builtins->Slot_DebugBreak();
-    Address pc = code->instruction_start() + code_offset();
-    DebugCodegen::PatchDebugBreakSlot(isolate(), pc, target);
+    if (code->kind() == Code::FUNCTION) {
+      Builtins* builtins = isolate()->builtins();
+      Handle<Code> target = IsReturn() ? builtins->Return_DebugBreak()
+                                       : builtins->Slot_DebugBreak();
+      Address pc = code->instruction_start() + code_offset();
+      DebugCodegen::PatchDebugBreakSlot(isolate(), pc, target);
+    } else {
+      DCHECK(code->kind() == Code::WASM_FUNCTION);
+      // Get wasm object and function index from deopt data.
+      Handle<JSObject> wasm;
+      int func_index;
+      std::tie(wasm, func_index) = GetWasmObjectAndFunctionIndexFromCode(code);
+      Handle<wasm::WasmDebugInfo> debug_info(wasm::GetDebugInfo(wasm));
+      wasm::WasmDebugInfo::SetBreakpoint(debug_info, func_index, position());
+    }
   } else {
     BytecodeArray* bytecode_array = abstract_code()->GetBytecodeArray();
     interpreter::Bytecode bytecode =
         interpreter::Bytecodes::FromByte(bytecode_array->get(code_offset()));
     interpreter::Bytecode debugbreak =
         interpreter::Bytecodes::GetDebugBreak(bytecode);
     bytecode_array->set(code_offset(),
                         interpreter::Bytecodes::ToByte(debugbreak));
   }
   DCHECK(IsDebugBreak());
@@ skipping 17 matching lines @@
   }
   DCHECK(!IsDebugBreak());
 }
 
 
 bool BreakLocation::IsDebugBreak() const {
   if (IsDebuggerStatement()) return false;
   DCHECK(IsDebugBreakSlot());
   if (abstract_code()->IsCode()) {
     Code* code = abstract_code()->GetCode();
-    DCHECK(code->kind() == Code::FUNCTION);
-    Address pc = code->instruction_start() + code_offset();
-    return DebugCodegen::DebugBreakSlotIsPatched(pc);
+    if (code->kind() == Code::FUNCTION) {
+      Address pc = code->instruction_start() + code_offset();
+      return DebugCodegen::DebugBreakSlotIsPatched(pc);
+    }
+    DCHECK(code->kind() == Code::WASM_FUNCTION);
+    Handle<JSObject> wasm;
+    int func_index;
+    std::tie(wasm, func_index) = GetWasmObjectAndFunctionIndexFromCode(code);
+    Handle<wasm::WasmDebugInfo> wasm_debug_info(wasm::GetDebugInfo(wasm));
+    return wasm_debug_info->HasBreakpoint(func_index, position());
   } else {
     BytecodeArray* bytecode_array = abstract_code()->GetBytecodeArray();
     interpreter::Bytecode bytecode =
         interpreter::Bytecodes::FromByte(bytecode_array->get(code_offset()));
     return interpreter::Bytecodes::IsDebugBreak(bytecode);
   }
 }
 
 
 Handle<Object> BreakLocation::BreakPointObjects() const {
@@ skipping 102 matching lines @@
   ClearStepping();
 
   // Return debugger is not loaded.
   if (!is_loaded()) return;
 
   // Clear debugger context global handle.
   GlobalHandles::Destroy(Handle<Object>::cast(debug_context_).location());
   debug_context_ = Handle<Context>();
 }
 
-void Debug::Break(JavaScriptFrame* frame) {
+void Debug::Break(StandardFrame* frame) {
   HandleScope scope(isolate_);
 
   // Initialize LiveEdit.
   LiveEdit::InitializeThreadLocal(this);
 
   // Just continue if breaks are disabled or debugger cannot be loaded.
   if (break_disabled()) return;
 
   // Enter the debugger.
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return;
 
   // Postpone interrupt during breakpoint processing.
   PostponeInterruptsScope postpone(isolate_);
 
-  // Get the debug info (create it if it does not exist).
-  Handle<JSFunction> function(frame->function());
-  Handle<SharedFunctionInfo> shared(function->shared());
-  if (!EnsureDebugInfo(shared, function)) {
-    // Return if we failed to retrieve the debug info.
-    return;
-  }
-  Handle<DebugInfo> debug_info(shared->GetDebugInfo(), isolate_);
-
   // Find the break location where execution has stopped.
-  BreakLocation location = BreakLocation::FromFrame(debug_info, frame);
+  BreakLocation location = BreakLocation::FromFrame(frame);
 
   // Find actual break points, if any, and trigger debug break event.
   Handle<Object> break_points_hit = CheckBreakPoints(&location);
   if (!break_points_hit->IsUndefined(isolate_)) {
     // Clear all current stepping setup.
     ClearStepping();
     // Notify the debug event listeners.
     OnDebugBreak(break_points_hit, false);
     return;
   }
@@ skipping 13 matching lines @@
       if (current_fp < target_fp) return;
       step_break = true;
       break;
     case StepNext:
       // Step next should not break in a deeper frame.
       if (current_fp < target_fp) return;
       // For step-next, a tail call is like a return and should break.
       step_break = location.IsTailCall();
     // Fall through.
     case StepIn: {
-      FrameSummary summary = FrameSummary::GetFirst(frame);
-      int offset = summary.code_offset();
+      int offset = GetCodeOffset(frame);
       step_break = step_break || location.IsReturn() ||
                    (current_fp != last_fp) ||
                    (thread_local_.last_statement_position_ !=
                     location.abstract_code()->SourceStatementPosition(offset));
       break;
     }
     case StepFrame:
       step_break = current_fp != last_fp;
       break;
   }
@@ skipping 57 matching lines @@
   // an exception event on exception at this location.
   Object* fun = frame->function();
   if (!fun->IsJSFunction()) return false;
   JSFunction* function = JSFunction::cast(fun);
   if (!function->shared()->HasDebugInfo()) return false;
   HandleScope scope(isolate_);
   Handle<DebugInfo> debug_info(function->shared()->GetDebugInfo());
   // Enter the debugger.
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return false;
-  BreakLocation current_position = BreakLocation::FromFrame(debug_info, frame);
+  BreakLocation current_position = BreakLocation::FromFrame(frame);
   List<BreakLocation> break_locations;
   BreakLocation::AllForStatementPosition(
       debug_info, current_position.statement_position(), &break_locations);
   bool has_break_points_at_all = false;
   for (int i = 0; i < break_locations.length(); i++) {
     bool has_break_points;
     Handle<Object> check_result =
         CheckBreakPoints(&break_locations[i], &has_break_points);
     has_break_points_at_all |= has_break_points;
     if (has_break_points && !check_result->IsUndefined(isolate_)) return false;
@@ skipping 65 matching lines @@
 
   // At least one active break point now.
   return debug_info->GetBreakPointCount() > 0;
 }
 
 
 bool Debug::SetBreakPointForScript(Handle<Script> script,
                                    Handle<Object> break_point_object,
                                    int* source_position,
                                    BreakPositionAlignment alignment) {
-  if (script->type() == Script::TYPE_WASM) {
-    // TODO(clemensh): set breakpoint for wasm.
-    return false;
-  }
   HandleScope scope(isolate_);
 
-  // Obtain shared function info for the function.
-  Handle<Object> result =
-      FindSharedFunctionInfoInScript(script, *source_position);
-  if (result->IsUndefined(isolate_)) return false;
+  Handle<DebugInfo> debug_info;
+  int start_position = 0;
+  if (script->type() == Script::TYPE_WASM) {
+    Handle<wasm::WasmDebugInfo> wasm_debug(
+        wasm::GetDebugInfo(handle(script->wasm_object(), isolate_)), isolate_);
+    uint32_t func_index = script->wasm_function_index();
+    debug_info = handle(
+        wasm::WasmDebugInfo::GetDebugInfo(wasm_debug, func_index), isolate_);
+  } else {
+    // Obtain shared function info for the function.
+    Handle<Object> result =
+        FindSharedFunctionInfoInScript(script, *source_position);
+    if (result->IsUndefined(isolate_)) return false;
 
-  // Make sure the function has set up the debug info.
-  Handle<SharedFunctionInfo> shared = Handle<SharedFunctionInfo>::cast(result);
-  if (!EnsureDebugInfo(shared, Handle<JSFunction>::null())) {
-    // Return if retrieving debug info failed.
-    return false;
+    // Get debug info, create it if necessary.
+    Handle<SharedFunctionInfo> shared =
+        Handle<SharedFunctionInfo>::cast(result);
+    if (!EnsureDebugInfo(shared, Handle<JSFunction>::null())) {
+      // Return if retrieving debug info failed.
+      return false;
+    }
+    debug_info = handle(shared->GetDebugInfo(), isolate_);
+    start_position = shared->start_position();
   }
 
   // Find position within function. The script position might be before the
   // source position of the first function.
-  int position;
-  if (shared->start_position() > *source_position) {
-    position = 0;
-  } else {
-    position = *source_position - shared->start_position();
-  }
+  int position =
+      start_position > *source_position ? 0 : *source_position - start_position;
 
-  Handle<DebugInfo> debug_info(shared->GetDebugInfo());
   // Source positions starts with zero.
-  DCHECK(position >= 0);
+  DCHECK_LE(0, position);
 
   // Find the break point and change it.
   BreakLocation location =
       BreakLocation::FromPosition(debug_info, position, alignment);
   location.SetBreakPoint(break_point_object);
 
   feature_tracker()->Track(DebugFeatureTracker::kBreakPoint);
 
   position = (alignment == STATEMENT_ALIGNED) ? location.statement_position()
                                               : location.position();
 
-  *source_position = position + shared->start_position();
+  *source_position = position + start_position;
 
   // At least one active break point now.
   DCHECK(debug_info->GetBreakPointCount() > 0);
   return true;
 }
 
 
 void Debug::ClearBreakPoint(Handle<Object> break_point_object) {
   HandleScope scope(isolate_);
 
@@ skipping 184 matching lines @@
     // Return if ensuring debug info failed.
     return;
   }
 
   Handle<DebugInfo> debug_info(shared->GetDebugInfo());
   // Refresh frame summary if the code has been recompiled for debugging.
   if (AbstractCode::cast(shared->code()) != *summary.abstract_code()) {
     summary = FrameSummary::GetFirst(frame);
   }
 
-  int call_offset =
-      CallOffsetFromCodeOffset(summary.code_offset(), frame->is_interpreted());
+  int call_offset = CallOffsetFromCodeOffset(summary.code_offset(), frame);
   BreakLocation location =
       BreakLocation::FromCodeOffset(debug_info, call_offset);
 
   // 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_ =
       debug_info->abstract_code()->SourceStatementPosition(
@@ skipping 536 matching lines @@
       return;
     }
     // Move to next in list.
     prev = current;
     current = current->next();
   }
 
   UNREACHABLE();
 }
 
-void Debug::SetAfterBreakTarget(JavaScriptFrame* frame) {
+void Debug::SetAfterBreakTarget(StandardFrame* frame) {
   after_break_target_ = NULL;
   if (!LiveEdit::SetAfterBreakTarget(this)) {
     // Continue just after the slot.
     after_break_target_ = frame->pc();
   }
 }
 
 bool Debug::IsBreakAtReturn(JavaScriptFrame* frame) {
   HandleScope scope(isolate_);
 
@@ skipping 691 matching lines @@
   // Store the previous break id, frame id and return value.
   break_id_ = debug_->break_id();
   break_frame_id_ = debug_->break_frame_id();
   return_value_ = debug_->return_value();
 
   // Create the new break info. If there is no proper frames there is no break
   // frame id.
   StackTraceFrameIterator it(isolate());
   bool has_frames = !it.done();
   // We don't currently support breaking inside wasm framess.
-  DCHECK(!has_frames || !it.is_wasm());
   debug_->thread_local_.break_frame_id_ =
       has_frames ? it.frame()->id() : StackFrame::NO_ID;
   debug_->SetNextBreakId();
 
   debug_->UpdateState();
   // Make sure that debugger is loaded and enter the debugger context.
   // The previous context is kept in save_.
   failed_ = !debug_->is_loaded();
   if (!failed_) isolate()->set_context(*debug->debug_context());
 }
@@ skipping 276 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8