[interpreter, debugger] support debug breaks via bytecode array copy

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"
 #include "src/codegen.h"
 #include "src/compilation-cache.h"
 #include "src/compiler.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
 #include "src/frames-inl.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/global-handles.h"
 #include "src/interpreter/bytecodes.h"
+#include "src/interpreter/interpreter.h"
 #include "src/isolate-inl.h"
 #include "src/list.h"
 #include "src/log.h"
 #include "src/messages.h"
 #include "src/snapshot/natives.h"
 
 #include "include/v8-debug.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 172 matching lines @@
       break;
     }
   }
 }
 
 BreakLocation::DebugBreakType
 BreakLocation::BytecodeArrayIterator::GetDebugBreakType() {
   BytecodeArray* bytecode_array =
       debug_info_->abstract_code()->GetBytecodeArray();
   interpreter::Bytecode bytecode =
-      static_cast<interpreter::Bytecode>(bytecode_array->get(code_offset()));
+      interpreter::Bytecodes::FromByte(bytecode_array->get(code_offset()));
 
   if (bytecode == interpreter::Bytecode::kDebugger) {
     return DEBUGGER_STATEMENT;
   } else if (bytecode == interpreter::Bytecode::kReturn) {
     return DEBUG_BREAK_SLOT_AT_RETURN;
   } else if (interpreter::Bytecodes::IsCallOrNew(bytecode)) {
     return DEBUG_BREAK_SLOT_AT_CALL;
   } else if (source_position_iterator_.is_statement()) {
     return DEBUG_BREAK_SLOT;
   } else {
     return NOT_DEBUG_BREAK;
   }
 }
 
 BreakLocation BreakLocation::BytecodeArrayIterator::GetBreakLocation() {
   return BreakLocation(debug_info_, GetDebugBreakType(), code_offset(),
                        position(), statement_position());
 }
 
 // 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();
 }
 
-// Move GetFirstFrameSummary Definition to here as FromFrame use it.
 FrameSummary GetFirstFrameSummary(JavaScriptFrame* frame) {
   List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
   frame->Summarize(&frames);
   return frames.first();
 }
 
 BreakLocation BreakLocation::FromFrame(Handle<DebugInfo> debug_info,
                                        JavaScriptFrame* frame) {
-  // Code offset to the instruction after the current one, possibly a break
-  // location as well. So the "- 1" to exclude it from the search.
-  // Get code offset from the unoptimized code.
+  // 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.
   FrameSummary summary = GetFirstFrameSummary(frame);
-  return FromCodeOffset(debug_info, summary.code_offset() - 1);
+  int call_offset = summary.code_offset();
+  if (!frame->is_interpreted()) call_offset--;
+  return FromCodeOffset(debug_info, call_offset);
 }
 
 // Find the break point at the supplied address, or the closest one before
 // the address.
 void BreakLocation::FromCodeOffsetSameStatement(
     Handle<DebugInfo> debug_info, int offset, List<BreakLocation>* result_out) {
   int break_index = BreakIndexFromCodeOffset(debug_info, offset);
   base::SmartPointer<Iterator> it(GetIterator(debug_info));
   it->SkipTo(break_index);
   int statement_position = it->statement_position();
@@ skipping 128 matching lines @@
 
   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);
-    DCHECK(IsDebugBreak());
   } else {
-    // TODO(yangguo): implement this once we have a way to record break points.
+    BytecodeArray* bytecode_array = abstract_code()->GetBytecodeArray();

[Yang, 2016/02/16 09:22:20]

We may eventually want to move to a representation where the break points are
saved in a list of BreakPoint objects on the debug info, and changing break
points is just a matter of operating on that list and at the end applying those
break points to the bytecode array.

Patching the original bytecode array would then at the end require the debugger
to refresh the copy in the debug info and refresh the break points from
BreakPoint list.

But for now let's just mirror what we do for FCG. 

+    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());
 }
 
 
 void BreakLocation::ClearDebugBreak() {
   // Debugger statement always calls debugger. No need to modify it.
   if (IsDebuggerStatement()) return;
 
   DCHECK(IsDebugBreakSlot());
   if (abstract_code()->IsCode()) {
     Code* code = abstract_code()->GetCode();
     DCHECK(code->kind() == Code::FUNCTION);
     Address pc = code->instruction_start() + code_offset();
     DebugCodegen::ClearDebugBreakSlot(isolate(), pc);
-    DCHECK(!IsDebugBreak());
   } else {
-    // TODO(yangguo): implement this once we have a way to record break points.
+    BytecodeArray* bytecode_array = abstract_code()->GetBytecodeArray();
+    BytecodeArray* original = debug_info_->shared()->bytecode_array();
+    bytecode_array->set(code_offset(), original->get(code_offset()));
   }
+  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);
   } else {
-    // TODO(yangguo): implement this once we have a way to record break points.
-    return false;
+    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 {
   return debug_info_->GetBreakPointObjects(code_offset_);
 }
 
 void DebugFeatureTracker::Track(DebugFeatureTracker::Feature feature) {
   uint32_t mask = 1 << feature;
@@ skipping 544 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 = GetFirstFrameSummary(frame);
   }
 
-  // PC points to the instruction after the current one, possibly a break
-  // location as well. So the "- 1" to exclude it from the search.
+  // 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.
+  int call_offset = summary.code_offset();
+  if (!frame->is_interpreted()) call_offset--;

[rmcilroy, 2016/02/16 10:46:38]

Could you extract this code into a helper - it's repeated in a couple of places.

[Yang, 2016/02/19 13:09:17]

Done.

   BreakLocation location =
-      BreakLocation::FromCodeOffset(debug_info, summary.code_offset() - 1);
+      BreakLocation::FromCodeOffset(debug_info, call_offset);
 
   // At a return statement we will step out either way.
   if (location.IsReturn()) step_action = StepOut;
 
   thread_local_.last_statement_position_ =
       debug_info->abstract_code()->SourceStatementPosition(
           summary.code_offset());
   thread_local_.last_fp_ = frame->UnpaddedFP();
 
   switch (step_action) {
@@ skipping 500 matching lines @@
   DebugInfoListNode* current = debug_info_list_;
   while (current != NULL) {
     if (current->debug_info().is_identical_to(debug_info)) {
       // Unlink from list. If prev is NULL we are looking at the first element.
       if (prev == NULL) {
         debug_info_list_ = current->next();
       } else {
         prev->set_next(current->next());
       }
       delete current;
-      shared->set_debug_info(isolate_->heap()->undefined_value());
+      shared->set_debug_info(DebugInfo::uninitialized());
       return;
     }
     // Move to next in list.
     prev = current;
     current = current->next();
   }
 
   UNREACHABLE();
 }
 
-
-void Debug::SetAfterBreakTarget(JavaScriptFrame* frame) {
-  after_break_target_ = NULL;
-
-  if (LiveEdit::SetAfterBreakTarget(this)) return;  // LiveEdit did the job.
-
-  // Continue just after the slot.
-  after_break_target_ = frame->pc();
+Object* Debug::SetAfterBreakTarget(JavaScriptFrame* frame) {
+  if (frame->is_interpreted()) {
+    // Find the handler from the original bytecode array.
+    InterpretedFrame* interpreted_frame =
+        reinterpret_cast<InterpretedFrame*>(frame);
+    SharedFunctionInfo* shared = interpreted_frame->function()->shared();
+    BytecodeArray* bytecode_array = shared->bytecode_array();
+    int bytecode_offset = interpreted_frame->GetBytecodeOffset();
+    interpreter::Bytecode bytecode =
+        interpreter::Bytecodes::FromByte(bytecode_array->get(bytecode_offset));
+    return isolate_->interpreter()->GetHandler(bytecode);
+  } else {
+    after_break_target_ = NULL;
+    if (!LiveEdit::SetAfterBreakTarget(this)) {
+      // Continue just after the slot.
+      after_break_target_ = frame->pc();
+    }
+    return isolate_->heap()->undefined_value();
+  }
 }
 
 
 bool Debug::IsBreakAtReturn(JavaScriptFrame* frame) {
   HandleScope scope(isolate_);
 
   // Get the executing function in which the debug break occurred.
   Handle<JSFunction> function(JSFunction::cast(frame->function()));
   Handle<SharedFunctionInfo> shared(function->shared());
 
@@ skipping 61 matching lines @@
   Handle<SharedFunctionInfo> shared = Handle<SharedFunctionInfo>(fun->shared());
 
   if (!EnsureDebugInfo(shared, fun)) 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 = GetFirstFrameSummary(frame);
   }
 
-  // Find range of break points starting from the break point where execution
-  // has stopped. The code offset points to the instruction after the current
-  // possibly a break location, too. Subtract one to exclude it from the search.
-  int call_offset = summary.code_offset() - 1;
+  // 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.
+  int call_offset = summary.code_offset();
+  if (!frame->is_interpreted()) call_offset--;
   List<BreakLocation> locations;
   BreakLocation::FromCodeOffsetSameStatement(debug_info, call_offset,
                                              &locations);
 
   for (BreakLocation location : locations) {
     if (location.code_offset() <= summary.code_offset()) {
       // The break point is near our pc. Could be a step-in possibility,
       // that is currently taken by active debugger call.
       if (break_frame_id() == StackFrame::NO_ID) {
         continue;  // We are not stepping.
@@ skipping 929 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8