[debugger] use source position to identify break points.

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 <memory>
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 303 matching lines @@
   return closest_break;
 }
 
 
 void BreakLocation::SetBreakPoint(Handle<Object> break_point_object) {
   // If there is not already a real break point here patch code with debug
   // break.
   if (!HasBreakPoint()) SetDebugBreak();
   DCHECK(IsDebugBreak() || IsDebuggerStatement());
   // Set the break point information.
-  DebugInfo::SetBreakPoint(debug_info_, code_offset_, position_,
-                           statement_position_, break_point_object);
+  DebugInfo::SetBreakPoint(debug_info_, position_, statement_position_,
+                           break_point_object);
 }
 
 
 void BreakLocation::ClearBreakPoint(Handle<Object> break_point_object) {
   // Clear the break point information.
-  DebugInfo::ClearBreakPoint(debug_info_, code_offset_, break_point_object);
+  DebugInfo::ClearBreakPoint(debug_info_, position_, break_point_object);
   // If there are no more break points here remove the debug break.
   if (!HasBreakPoint()) {
     ClearDebugBreak();
     DCHECK(!IsDebugBreak());
   }
 }
 
 
 void BreakLocation::SetOneShot() {
   // Debugger statement always calls debugger. No need to modify it.
   if (IsDebuggerStatement()) return;
 
-  // If there is a real break point here no more to do.
-  if (HasBreakPoint()) {
-    DCHECK(IsDebugBreak());
-    return;
-  }
-
   // Patch code with debug break.
   SetDebugBreak();
 }
 
 
 void BreakLocation::ClearOneShot() {
   // Debugger statement always calls debugger. No need to modify it.
   if (IsDebuggerStatement()) return;
 
   // If there is a real break point here no more to do.
@@ skipping 68 matching lines @@
     Address pc = code->instruction_start() + code_offset();
     return DebugCodegen::DebugBreakSlotIsPatched(pc);
   } 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 {
+  return debug_info_->GetBreakPointObjects(position_);
+}
 
-Handle<Object> BreakLocation::BreakPointObjects() const {
-  return debug_info_->GetBreakPointObjects(code_offset_);
+bool BreakLocation::HasBreakPoint() const {
+  // First check whether there is a break point with the same source position.
+  if (!debug_info_->HasBreakPoint(position_)) return false;
+  // Then check whether a break point at that source position would have
+  // the same code offset. Otherwise it's just a break location that we can
+  // step to, but not actually a location where we can put a break point.
+  BreakLocation break_point_location = BreakLocation::FromPosition(
+      debug_info_, position_, BREAK_POSITION_ALIGNED);
+  return break_point_location.code_offset() == code_offset_;
 }
 
 void DebugFeatureTracker::Track(DebugFeatureTracker::Feature feature) {
   uint32_t mask = 1 << feature;
   // Only count one sample per feature and isolate.
   if (bitfield_ & mask) return;
   isolate_->counters()->debug_feature_usage()->AddSample(feature);
   bitfield_ |= mask;
 }
 
@@ skipping 372 matching lines @@
   DebugInfoListNode* node = debug_info_list_;
   while (node != NULL) {
     Handle<Object> result =
         DebugInfo::FindBreakPointInfo(node->debug_info(), break_point_object);
     if (!result->IsUndefined(isolate_)) {
       // Get information in the break point.
       Handle<BreakPointInfo> break_point_info =
           Handle<BreakPointInfo>::cast(result);
       Handle<DebugInfo> debug_info = node->debug_info();
 
-      BreakLocation location = BreakLocation::FromCodeOffset(
-          debug_info, break_point_info->code_offset());
+      BreakLocation location = BreakLocation::FromPosition(
+          debug_info, break_point_info->source_position(),
+          BREAK_POSITION_ALIGNED);
       location.ClearBreakPoint(break_point_object);
 
       // If there are no more break points left remove the debug info for this
       // function.
       if (debug_info->GetBreakPointCount() == 0) {
         RemoveDebugInfoAndClearFromShared(debug_info);
       }
 
       return;
     }
@@ skipping 242 matching lines @@
   Handle<FixedArray> locations =
       isolate->factory()->NewFixedArray(debug_info->GetBreakPointCount());
   int count = 0;
   for (int i = 0; i < debug_info->break_points()->length(); ++i) {
     if (!debug_info->break_points()->get(i)->IsUndefined(isolate)) {
       BreakPointInfo* break_point_info =
           BreakPointInfo::cast(debug_info->break_points()->get(i));
       int break_points = break_point_info->GetBreakPointCount();
       if (break_points == 0) continue;
       Smi* position = NULL;
-      switch (position_alignment) {
-        case STATEMENT_ALIGNED:
-          position = Smi::FromInt(break_point_info->statement_position());
-          break;
-        case BREAK_POSITION_ALIGNED:
-          position = Smi::FromInt(break_point_info->source_position());
-          break;
+      if (position_alignment == STATEMENT_ALIGNED) {
+        BreakLocation break_point_location = BreakLocation::FromPosition(
+            debug_info, break_point_info->source_position(),
+            BREAK_POSITION_ALIGNED);
+        position = Smi::FromInt(break_point_location.statement_position());
+      } else {
+        DCHECK_EQ(BREAK_POSITION_ALIGNED, position_alignment);
+        position = Smi::FromInt(break_point_info->source_position());
       }
       for (int j = 0; j < break_points; ++j) locations->set(count++, position);
     }
   }
   return locations;
 }
 
 
 void Debug::ClearStepping() {
   // Clear the various stepping setup.
@@ skipping 1463 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8