Debugger: refactor reloc info.

src/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/v8.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 58 matching lines @@
       original_rmode_(original_rinfo->rmode()),
       data_(rinfo->data()),
       original_data_(original_rinfo->data()),
       position_(position),
       statement_position_(statement_position) {}
 
 
 BreakLocation::Iterator::Iterator(Handle<DebugInfo> debug_info,
                                   BreakLocatorType type)
     : debug_info_(debug_info),
-      type_(type),
-      reloc_iterator_(debug_info->code(),
-                      ~RelocInfo::ModeMask(RelocInfo::CODE_AGE_SEQUENCE)),
-      reloc_iterator_original_(
-          debug_info->original_code(),
-          ~RelocInfo::ModeMask(RelocInfo::CODE_AGE_SEQUENCE)),
+      reloc_iterator_(debug_info->code(), GetModeMask(type)),
+      reloc_iterator_original_(debug_info->original_code(), GetModeMask(type)),
       break_index_(-1),
       position_(1),
       statement_position_(1) {
-  Next();
+  if (!RinfoDone()) Next();
 }
 
 
+int BreakLocation::Iterator::GetModeMask(BreakLocatorType type) {
+  int mask = 0;
+  mask |= RelocInfo::ModeMask(RelocInfo::POSITION);
+  mask |= RelocInfo::ModeMask(RelocInfo::STATEMENT_POSITION);
+  mask |= RelocInfo::ModeMask(RelocInfo::JS_RETURN);
+  mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_CALL);
+  mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_CONSTRUCT_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::Iterator::Next() {
   DisallowHeapAllocation no_gc;
   DCHECK(!RinfoDone());
 
   // Iterate through reloc info for code and original code stopping at each
   // breakable code target.
   bool first = break_index_ == -1;
   while (!RinfoDone()) {
     if (!first) RinfoNext();
     first = false;
@@ skipping 20 matching lines @@
       if (debug_info_->shared()->HasSourceCode()) {
         position_ = debug_info_->shared()->end_position() -
                     debug_info_->shared()->start_position() - 1;
       } else {
         position_ = 0;
       }
       statement_position_ = position_;
       break;
     }
 
-    if (RelocInfo::IsDebugBreakSlot(rmode()) &&
-        (type_ == ALL_BREAK_LOCATIONS ||
-         RelocInfo::DebugBreakIsCall(rinfo()->data()))) {
-      break;
-    }
-
-    if (RelocInfo::IsDebuggerStatement(rmode()) &&
-        type_ == ALL_BREAK_LOCATIONS) {
-      break;
-    }
+    DCHECK(RelocInfo::IsDebugBreakSlot(rmode()) ||
+           RelocInfo::IsDebuggerStatement(rmode()));
+    break;
   }
   break_index_++;
 }
 
 
 // Find the break point at the supplied address, or the closest one before
 // the address.
 BreakLocation BreakLocation::FromAddress(Handle<DebugInfo> debug_info,
                                          BreakLocatorType type, Address pc) {
   Iterator it(debug_info, type);
@@ skipping 1118 matching lines @@
 
   // No step next action - don't continue.
   return false;
 }
 
 
 // Check whether the code object at the specified address is a debug break code
 // object.
 bool Debug::IsDebugBreak(Address addr) {
   Code* code = Code::GetCodeFromTargetAddress(addr);
-  return code->is_debug_stub() && code->extra_ic_state() == DEBUG_BREAK;
+  return code->is_debug_stub();
 }
 
 
 // Simple function for returning the source positions for active break points.
 Handle<Object> Debug::GetSourceBreakLocations(
     Handle<SharedFunctionInfo> shared,
     BreakPositionAlignment position_alignment) {
   Isolate* isolate = shared->GetIsolate();
   Heap* heap = isolate->heap();
   if (!HasDebugInfo(shared)) {
@@ skipping 164 matching lines @@
   }
 
   return code_offset;
 }
 
 
 // The inverse of ComputeCodeOffsetFromPcOffset.
 static int ComputePcOffsetFromCodeOffset(Code *code, int code_offset) {
   DCHECK_EQ(code->kind(), Code::FUNCTION);
 
-  int mask = RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT) |
+  int mask = RelocInfo::kDebugBreakSlotMask |
              RelocInfo::ModeMask(RelocInfo::CONST_POOL) |
              RelocInfo::ModeMask(RelocInfo::VENEER_POOL);
   int reloc = 0;
   for (RelocIterator it(code, mask); !it.done(); it.next()) {
     RelocInfo* info = it.rinfo();
     if (info->pc() - code->instruction_start() - reloc >= code_offset) break;
     if (RelocInfo::IsDebugBreakSlot(info->rmode())) {
       reloc += Assembler::kDebugBreakSlotLength;
     } else {
       DCHECK(RelocInfo::IsConstPool(info->rmode()));
@@ skipping 1713 matching lines @@
       masm->RecordDebugBreakSlotForCall(call_argc);
       return;
     case DEBUG_BREAK_AT_CONSTRUCT_CALL:
       masm->RecordDebugBreakSlotForConstructCall();
       return;
   }
 }
 
 }  // namespace internal
 }  // namespace v8