[interpreter, debugger] implement bytecode break location iterator.

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/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 33 matching lines @@
                              int code_offset, int position,
                              int statement_position)
     : 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->shared()->HasBytecodeArray()) {
-    UNIMPLEMENTED();
-    return nullptr;
+  if (debug_info->abstract_code()->IsBytecodeArray()) {
+    return new BytecodeArrayIterator(debug_info, type);
+  } else {
+    return new CodeIterator(debug_info, type);
   }
-  return new CodeIterator(debug_info, type);
 }
 
-BreakLocation::Iterator::Iterator(Handle<DebugInfo> debug_info,
-                                  BreakLocatorType type)
+BreakLocation::Iterator::Iterator(Handle<DebugInfo> debug_info)
     : debug_info_(debug_info),
       break_index_(-1),
       position_(1),
-      statement_position_(1) {
-}
+      statement_position_(1) {}
 
 BreakLocation::CodeIterator::CodeIterator(Handle<DebugInfo> debug_info,
                                           BreakLocatorType type)
-    : Iterator(debug_info, type),
+    : Iterator(debug_info),
       reloc_iterator_(debug_info->abstract_code()->GetCode(),
                       GetModeMask(type)) {
   if (!Done()) Next();
 }
 
 int BreakLocation::CodeIterator::GetModeMask(BreakLocatorType type) {
   int mask = 0;
   mask |= RelocInfo::ModeMask(RelocInfo::POSITION);
   mask |= RelocInfo::ModeMask(RelocInfo::STATEMENT_POSITION);
   mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_RETURN);
   mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_CALL);
   if (type == ALL_BREAK_LOCATIONS) {
     mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_POSITION);
     mask |= RelocInfo::ModeMask(RelocInfo::DEBUGGER_STATEMENT);
   }
   return mask;
 }
 
 void BreakLocation::CodeIterator::Next() {
   DisallowHeapAllocation no_gc;
   DCHECK(!Done());
 
-  // Iterate through reloc info for code and original code stopping at each
-  // breakable code target.
+  // Iterate through reloc info stopping at each breakable code target.
   bool first = break_index_ == -1;
   while (!Done()) {
     if (!first) reloc_iterator_.next();
     first = false;
     if (Done()) return;
 
     // Whenever a statement position or (plain) position is passed update the
     // current value of these.
     if (RelocInfo::IsPosition(rmode())) {
       if (RelocInfo::IsStatementPosition(rmode())) {
@@ skipping 38 matching lines @@
     type = DEBUGGER_STATEMENT;
   } else if (RelocInfo::IsDebugBreakSlot(rmode())) {
     type = DEBUG_BREAK_SLOT;
   } else {
     type = NOT_DEBUG_BREAK;
   }
   return BreakLocation(debug_info_, type, code_offset(), position(),
                        statement_position());
 }
 
+BreakLocation::BytecodeArrayIterator::BytecodeArrayIterator(
+    Handle<DebugInfo> debug_info, BreakLocatorType type)
+    : Iterator(debug_info),
+      source_position_iterator_(
+          debug_info->abstract_code()->GetBytecodeArray()),
+      break_locator_type_(type),
+      start_position_(debug_info->shared()->start_position()) {
+  if (!Done()) Next();
+}
+
+void BreakLocation::BytecodeArrayIterator::Next() {
+  DisallowHeapAllocation no_gc;
+  DCHECK(!Done());
+  bool first = break_index_ == -1;
+  while (!Done()) {
+    if (!first) source_position_iterator_.Advance();
+    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_++;
+
+    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();
+  interpreter::Bytecode bytecode =
+      static_cast<interpreter::Bytecode>(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.
@@ skipping 153 matching lines @@
   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 {
-    UNIMPLEMENTED();
+    // TODO(yangguo): implement this once we have a way to record break points.
   }
 }
 
 
 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 {
-    UNIMPLEMENTED();
+    // TODO(yangguo): implement this once we have a way to record break points.
   }
 }
 
 
 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 {
-    UNIMPLEMENTED();
+    // TODO(yangguo): implement this once we have a way to record break points.
     return false;
   }
 }
 
 
 Handle<Object> BreakLocation::BreakPointObjects() const {
   return debug_info_->GetBreakPointObjects(code_offset_);
 }
 
 void DebugFeatureTracker::Track(DebugFeatureTracker::Feature feature) {
@@ skipping 769 matching lines @@
  public:
   explicit RedirectActiveFunctions(SharedFunctionInfo* shared)
       : shared_(shared) {
     DCHECK(shared->HasDebugCode());
   }
 
   void VisitThread(Isolate* isolate, ThreadLocalTop* top) {
     for (JavaScriptFrameIterator it(isolate, top); !it.done(); it.Advance()) {
       JavaScriptFrame* frame = it.frame();
       JSFunction* function = frame->function();
+      if (frame->is_interpreted()) {
+        // TODO(yangguo): replace dispatch table for activated frames.
+        continue;
+      }
       if (frame->is_optimized()) continue;
       if (!function->Inlines(shared_)) continue;
 
       Code* frame_code = frame->LookupCode();
       DCHECK(frame_code->kind() == Code::FUNCTION);
       if (frame_code->has_debug_break_slots()) continue;
 
       Code* new_code = function->shared()->code();
       Address old_pc = frame->pc();
       Address new_pc = ComputeNewPcForRedirect(new_code, frame_code, old_pc);
@@ skipping 1329 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8