Better breakpoint placement

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 "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 803 matching lines @@
   event.type = kExceptionThrown;
   event.exception = &exc;
   ASSERT(event_handler_ != NULL);
   (*event_handler_)(&event);
   stack_trace_ = NULL;
   obj_cache_ = NULL;  // Remote object cache is zone allocated.
 }
 
 
 CodeBreakpoint* Debugger::MakeCodeBreakpoint(const Function& func,
-                                             intptr_t token_pos) {
+                                             intptr_t first_token_pos,
+                                             intptr_t last_token_pos) {
   ASSERT(func.HasCode());
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
+  // We attempt to find the PC descriptor that is closest to the
+  // beginning of the token range, in terms of native code address. If we
+  // don't find a PC descriptor within the given range, we pick the
+  // neares one to the beginning of the range, in terms of token position.

[siva, 2012/06/27 02:00:31]

nearest

[hausner, 2012/06/27 17:09:18]

Done.

   intptr_t best_fit_index = -1;
   intptr_t best_fit = INT_MAX;
+  uword lowest_pc = UINTPTR_MAX;
+  intptr_t lowest_pc_index = -1;
   for (int i = 0; i < desc.Length(); i++) {
     intptr_t desc_token_pos = desc.TokenIndex(i);
-    if (desc_token_pos < token_pos) {
+    if (desc_token_pos < first_token_pos) {
       continue;
     }
     PcDescriptors::Kind kind = desc.DescriptorKind(i);
     if ((kind == PcDescriptors::kIcCall) ||
         (kind == PcDescriptors::kFuncCall) ||
         (kind == PcDescriptors::kReturn)) {
-      if ((desc_token_pos - token_pos) < best_fit) {
-        best_fit = desc_token_pos - token_pos;
+      if ((desc_token_pos - first_token_pos) < best_fit) {
+        best_fit = desc_token_pos - first_token_pos;
         ASSERT(best_fit >= 0);
         best_fit_index = i;
       }
+      if ((first_token_pos <= desc_token_pos) &&
+          (desc_token_pos <= last_token_pos) &&
+          (desc.PC(i) < lowest_pc)) {
+        lowest_pc = desc.PC(i);
+        lowest_pc_index = i;
+      }
     }
   }
+  if (lowest_pc_index >= 0) {
+    // We found the the pc descriptor within the given token range that
+    // has the lowest execution address. This is the first possible
+    // breakpoint on the line. We use this instead of the nearest
+    // PC descriptor measured in token index distance.
+    best_fit_index = lowest_pc_index;
+  }
   if (best_fit_index >= 0) {
     CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(best_fit_index));
     // We should only ever have one code breakpoint at the same address.
     // If we find an existing breakpoint, it must be an internal one which
     // is used for stepping.
     if (bpt != NULL) {
       ASSERT(bpt->src_bpt() == NULL);
       return bpt;
     }
 
     bpt = new CodeBreakpoint(func, best_fit_index);
     if (verbose) {
       OS::Print("Setting breakpoint in function '%s' (%s:%d) (PC %p)\n",
                 String::Handle(func.name()).ToCString(),
                 String::Handle(bpt->SourceUrl()).ToCString(),
                 bpt->LineNumber(),
                 bpt->pc());
     }
     RegisterCodeBreakpoint(bpt);
     return bpt;
   }
   return NULL;
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpoint(const Function& target_function,
-                                          intptr_t token_pos) {
-  if ((token_pos < target_function.token_pos()) ||
-      (target_function.end_token_pos() <= token_pos)) {
+                                          intptr_t first_token_pos,
+                                          intptr_t last_token_pos) {
+  if ((last_token_pos < target_function.token_pos()) ||
+      (target_function.end_token_pos() < first_token_pos)) {
     // The given token position is not within the target function.
     return NULL;
   }
   EnsureFunctionIsDeoptimized(target_function);
-  SourceBreakpoint* bpt = GetSourceBreakpoint(target_function, token_pos);
+  SourceBreakpoint* bpt = GetSourceBreakpoint(target_function, first_token_pos);
   if (bpt != NULL) {
     // A breakpoint for this location already exists, return it.
     return bpt;
   }
-  bpt = new SourceBreakpoint(nextId(), target_function, token_pos);
+  bpt = new SourceBreakpoint(nextId(), target_function, first_token_pos);
   RegisterSourceBreakpoint(bpt);
   if (verbose && !target_function.HasCode()) {
     OS::Print("Registering breakpoint for "
               "uncompiled function '%s' at line %d\n",
               target_function.ToFullyQualifiedCString(),
               bpt->LineNumber());
   }
 
   if (target_function.HasCode()) {
-    CodeBreakpoint* cbpt = MakeCodeBreakpoint(target_function, token_pos);
+    CodeBreakpoint* cbpt =
+        MakeCodeBreakpoint(target_function, first_token_pos, last_token_pos);
     if (cbpt != NULL) {
       ASSERT(cbpt->src_bpt() == NULL);
       cbpt->set_src_bpt(bpt);
       SignalBpResolved(bpt);
     } else {
       if (verbose) {
         OS::Print("Failed to set breakpoint at '%s' line %d\n",
                   String::Handle(bpt->SourceUrl()).ToCString(),
                   bpt->LineNumber());
       }
@@ skipping 17 matching lines @@
       }
     }
     cbpt = cbpt->next();
   }
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpointAtEntry(
       const Function& target_function) {
   ASSERT(!target_function.IsNull());
-  return SetBreakpoint(target_function, target_function.token_pos());
+  return SetBreakpoint(target_function,
+                       target_function.token_pos(),
+                       target_function.end_token_pos());
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpointAtLine(const String& script_url,
                                           intptr_t line_number) {
   Library& lib = Library::Handle();
   Script& script = Script::Handle();
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate_->object_store()->libraries());
   for (int i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     script = lib.LookupScript(script_url);
     if (!script.IsNull()) {
       break;
     }
   }
   if (script.IsNull()) {
     if (verbose) {
       OS::Print("Failed to find script with url '%s'\n",
                 script_url.ToCString());
     }
     return NULL;
   }
-  intptr_t token_pos_at_line = script.TokenIndexAtLine(line_number);
-  if (token_pos_at_line < 0) {
+  intptr_t first_token_idx, last_token_idx;
+  script.TokenRangeAtLine(line_number, &first_token_idx, &last_token_idx);
+  if (first_token_idx < 0) {
     // Script does not contain the given line number.
     if (verbose) {
       OS::Print("Script '%s' does not contain line number %d\n",
                 script_url.ToCString(), line_number);
     }
     return NULL;
   }
   const Function& func =
-      Function::Handle(lib.LookupFunctionInScript(script, token_pos_at_line));
+      Function::Handle(lib.LookupFunctionInScript(script, first_token_idx));
   if (func.IsNull()) {
     if (verbose) {
       OS::Print("No executable code at line %d in '%s'\n",
                 line_number, script_url.ToCString());
     }
     return NULL;
   }
-  return SetBreakpoint(func, token_pos_at_line);
+  if (last_token_idx < 0) {
+    // The token at first_token_index is past the requested source line.
+    // Set the breakpoint at the closest position after that line.
+    last_token_idx = func.end_token_pos();
+  }
+  return SetBreakpoint(func, first_token_idx, last_token_idx);
 }
 
 
 intptr_t Debugger::CacheObject(const Object& obj) {
   ASSERT(obj_cache_ != NULL);
   return obj_cache_->AddObject(obj);
 }
 
 
 bool Debugger::IsValidObjectId(intptr_t obj_id) {
@@ skipping 398 matching lines @@
           OS::Print("Resetting pending breakpoint to function %s\n",
                     closure.ToFullyQualifiedCString());
         }
         bpt->set_function(closure);
       } else {
         if (verbose) {
           OS::Print("Enable pending breakpoint for function '%s'\n",
                     String::Handle(lookup_function.name()).ToCString());
         }
         // Set breakpoint in newly compiled code of function func.
-        CodeBreakpoint* cbpt = MakeCodeBreakpoint(func, bpt->token_pos());
+        CodeBreakpoint* cbpt =
+            MakeCodeBreakpoint(func, bpt->token_pos(), func.end_token_pos());
         if (cbpt != NULL) {
           cbpt->set_src_bpt(bpt);
           SignalBpResolved(bpt);
         }
       }
       bpt->Enable();  // Enables the code breakpoint as well.
     }
     bpt = bpt->next();
   }
 }
@@ skipping 111 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart