[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 156 matching lines @@
     first = false;
     if (Done()) return;
     position_ = source_position_iterator_.source_position() - start_position_;
     if (source_position_iterator_.is_statement()) {
       statement_position_ = position_;
     }
     DCHECK(position_ >= 0);
     DCHECK(statement_position_ >= 0);
     break_index_++;
 
+    enum DebugBreakType type = GetDebugBreakType();
+    if (type == NOT_DEBUG_BREAK) continue;
+
     if (break_locator_type_ == ALL_BREAK_LOCATIONS) break;
 
     DCHECK_EQ(CALLS_AND_RETURNS, break_locator_type_);
-    enum DebugBreakType type = GetDebugBreakType();
     if (type == DEBUG_BREAK_SLOT_AT_CALL ||
         type == DEBUG_BREAK_SLOT_AT_RETURN) {
       break;
     }
   }
 }
 
 BreakLocation::DebugBreakType
 BreakLocation::BytecodeArrayIterator::GetDebugBreakType() {
-  BytecodeArray* bytecode_array =
-      debug_info_->abstract_code()->GetBytecodeArray();
+  BytecodeArray* bytecode_array = debug_info_->original_bytecode_array();
   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();
 }
 
+int CallOffsetFromCodeOffset(int code_offset, bool is_interpreted) {
+  // 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;
+}
+
 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.
   FrameSummary summary = GetFirstFrameSummary(frame);
-  return FromCodeOffset(debug_info, summary.code_offset() - 1);
+  int call_offset =
+      CallOffsetFromCodeOffset(summary.code_offset(), frame->is_interpreted());
+  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();
+    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_->original_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.
+  int call_offset =
+      CallOffsetFromCodeOffset(summary.code_offset(), frame->is_interpreted());
   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()->GetBytecodeHandler(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;
+  int call_offset =
+      CallOffsetFromCodeOffset(summary.code_offset(), frame->is_interpreted());
   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