Don’t set more than one code breakpoint per token position

runtime/vm/debugger.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 1529 matching lines @@
     // measured in token index distance.
     best_fit_index = lowest_pc_index;
   }
   if (best_fit_index >= 0) {
     return desc.TokenPos(best_fit_index);
   }
   return -1;
 }
 
 
-void Debugger::MakeCodeBreakpointsAt(const Function& func,
-                                     SourceBreakpoint* bpt) {
+void Debugger::MakeCodeBreakpointAt(const Function& func,
+                                    SourceBreakpoint* bpt) {
   ASSERT((bpt != NULL) && bpt->IsResolved());
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
+  uword lowest_pc = kUwordMax;
+  intptr_t lowest_pc_index = -1;
+  // Find the safe point with the lowest compiled code address
+  // that maps to the token position of the source breakpoint.
   for (intptr_t i = 0; i < desc.Length(); i++) {
     intptr_t desc_token_pos = desc.TokenPos(i);
     if ((desc_token_pos == bpt->token_pos_) && IsSafePoint(desc, i)) {
-      CodeBreakpoint* code_bpt = GetCodeBreakpoint(desc.PC(i));
-      if (code_bpt == NULL) {
-        // No code breakpoint for this code exists; create one.
-        code_bpt = new CodeBreakpoint(code, i);
-        RegisterCodeBreakpoint(code_bpt);
-      }
-      code_bpt->set_src_bpt(bpt);
-      if (bpt->IsEnabled()) {
-        code_bpt->Enable();
+      if (desc.PC(i) < lowest_pc) {
+        // This descriptor so far has the lowest code address.
+        lowest_pc = desc.PC(i);
+        lowest_pc_index = i;
       }
     }
   }
+  if (lowest_pc_index < 0) {
+    return;
+  }
+  CodeBreakpoint* code_bpt = GetCodeBreakpoint(desc.PC(lowest_pc_index));
+  if (code_bpt == NULL) {
+    // No code breakpoint for this code exists; create one.
+    code_bpt = new CodeBreakpoint(code, lowest_pc_index);
+    RegisterCodeBreakpoint(code_bpt);
+  }
+  code_bpt->set_src_bpt(bpt);
+  if (bpt->IsEnabled()) {
+    code_bpt->Enable();
+  }
 }
 
 
 void Debugger::FindCompiledFunctions(const Script& script,
                                      intptr_t start_pos,
                                      intptr_t end_pos,
                                      GrowableObjectArray* function_list) {
   Class& cls = Class::Handle(isolate_);
   Array& functions = Array::Handle(isolate_);
   GrowableObjectArray& closures = GrowableObjectArray::Handle(isolate_);
@@ skipping 181 matching lines @@
       }
       bpt = new SourceBreakpoint(nextId(), script, token_pos, last_token_pos);
       bpt->SetResolved(func, breakpoint_pos);
       RegisterSourceBreakpoint(bpt);
 
       // Create code breakpoints for all compiled functions we found.
       const intptr_t num_functions = functions.Length();
       for (intptr_t i = 0; i < num_functions; i++) {
         func ^= functions.At(i);
         ASSERT(func.HasCode());
-        MakeCodeBreakpointsAt(func, bpt);
+        MakeCodeBreakpointAt(func, bpt);
       }
       bpt->Enable();
       if (FLAG_verbose_debug) {
         intptr_t line_number;
         script.GetTokenLocation(breakpoint_pos, &line_number, NULL);
         OS::Print("Resolved breakpoint for "
                   "function '%s' at line %" Pd "\n",
                   func.ToFullyQualifiedCString(),
                   line_number);
       }
@@ skipping 588 matching lines @@
         SignalBpResolved(bpt);
       }
       ASSERT(bpt->IsResolved());
       if (FLAG_verbose_debug) {
         OS::Print("Setting breakpoint %" Pd " at line %" Pd " for %s '%s'\n",
                   bpt->id(),
                   bpt->LineNumber(),
                   func.IsClosureFunction() ? "closure" : "function",
                   String::Handle(func.name()).ToCString());
       }
-      MakeCodeBreakpointsAt(func, bpt);
+      MakeCodeBreakpointAt(func, bpt);
     }
   }
 }
 
 
 // TODO(hausner): Could potentially make this faster by checking
 // whether the call target at pc is a debugger stub.
 bool Debugger::HasActiveBreakpoint(uword pc) {
   CodeBreakpoint* bpt = GetCodeBreakpoint(pc);
   return (bpt != NULL) && (bpt->IsEnabled());
@@ skipping 121 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart