Find all compiled copies of a function when setting breakpoint

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 1349 matching lines @@
       }
       code_bpt->set_src_bpt(bpt);
       if (bpt->IsEnabled()) {
         code_bpt->Enable();
       }
     }
   }
 }
 
 
-void Debugger::FindEquivalentFunctions(const Script& script,
-                                       intptr_t start_pos,
-                                       intptr_t end_pos,
-                                       GrowableObjectArray* function_list) {
+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_);
   Function& function = Function::Handle(isolate_);
 
   const ClassTable& class_table = *isolate_->class_table();
   const intptr_t num_classes = class_table.NumCids();
   for (intptr_t i = 1; i < num_classes; i++) {
     if (class_table.HasValidClassAt(i)) {
       cls = class_table.At(i);
@@ skipping 11 matching lines @@
       if (!functions.IsNull()) {
         const intptr_t num_functions = functions.Length();
         for (intptr_t pos = 0; pos < num_functions; pos++) {
           function ^= functions.At(pos);
           ASSERT(!function.IsNull());
           // Check token position first to avoid unnecessary calls
           // to script() which allocates handles.
           if ((function.token_pos() == start_pos)
               && (function.end_token_pos() == end_pos)
               && (function.script() == script.raw())) {
-            function_list->Add(function);
+            if (function.HasCode()) {
+              function_list->Add(function);
+            }
             if (function.HasImplicitClosureFunction()) {
               function = function.ImplicitClosureFunction();
-              function_list->Add(function);
+              if (function.HasCode()) {
+                function_list->Add(function);
+              }
             }
           }
         }
       }
       closures = cls.closures();
       if (!closures.IsNull()) {
         const intptr_t num_closures = closures.Length();
         for (intptr_t pos = 0; pos < num_closures; pos++) {
           function ^= closures.At(pos);
           ASSERT(!function.IsNull());
           if ((function.token_pos() == start_pos)
               && (function.end_token_pos() == end_pos)
               && (function.script() == script.raw())) {
-            function_list->Add(function);
+            if (function.HasCode()) {
+              function_list->Add(function);
+            }
             if (function.HasImplicitClosureFunction()) {
               function = function.ImplicitClosureFunction();
-              function_list->Add(function);
+              if (function.HasCode()) {
+                function_list->Add(function);
+              }
             }
           }
         }
       }
     }
   }
 }
 
 
 static void SelectBestFit(Function* best_fit, Function* func) {
   if (best_fit->IsNull()) {
     *best_fit = func->raw();
-  }
-  if (func->token_pos() > best_fit->token_pos()) {
-    if (func->end_token_pos() <= best_fit->end_token_pos()) {
-      // func is contained within best_fit. Select it even if it
-      // has not been compiled yet.
+  } else {
+    if ((func->token_pos() > best_fit->token_pos()) &&
+        ((func->end_token_pos() <= best_fit->end_token_pos()))) {
       *best_fit = func->raw();
-      if (func->HasImplicitClosureFunction()) {
-        *func = func->ImplicitClosureFunction();
-        if (func->HasCode()) {
-          *best_fit = func->raw();
-        }
-      }
     }
-  } else if ((func->token_pos() == best_fit->token_pos())
-      && (func->end_token_pos() == best_fit->end_token_pos())
-      && func->HasCode()) {
-    // If func covers the same range, it is considered a better fit if
-    // it has been compiled.
-    *best_fit = func->raw();
   }
 }
 
 
 RawFunction* Debugger::FindBestFit(const Script& script,
                                    intptr_t token_pos) {
   Class& cls = Class::Handle(isolate_);
   Array& functions = Array::Handle(isolate_);
   GrowableObjectArray& closures = GrowableObjectArray::Handle(isolate_);
   Function& function = Function::Handle(isolate_);
@@ skipping 44 matching lines @@
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpoint(const Script& script,
                                           intptr_t token_pos) {
   Function& func = Function::Handle(isolate_);
   func = FindBestFit(script, token_pos);
   if (func.IsNull()) {
     return NULL;
   }
-  if (!func.IsNull() && func.HasCode()) {
-    // A function containing this breakpoint location has already
-    // been compiled. We can resolve the breakpoint now.
+  // There may be more than one function object for a given function
+  // in source code. There may be implicit closure functions, and
+  // there may be copies of mixin functions. Collect all compiled
+  // functions whose source code range matches exactly the best fit
+  // function we found.
+  GrowableObjectArray& functions =
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
+  FindCompiledFunctions(script,
+                        func.token_pos(),
+                        func.end_token_pos(),
+                        &functions);
+
+  if (functions.Length() > 0) {
+    // One or more function object containing this breakpoint location
+    // have already been compiled. We can resolve the breakpoint now.
     DeoptimizeWorld();
+    func ^= functions.At(0);
     intptr_t breakpoint_pos = ResolveBreakpointPos(func, token_pos);
     if (breakpoint_pos >= 0) {
       SourceBreakpoint* bpt = GetSourceBreakpoint(script, breakpoint_pos);
       if (bpt != NULL) {
         // A source breakpoint for this location already exists.
         return bpt;
       }
       bpt = new SourceBreakpoint(nextId(), script, token_pos);
       bpt->SetResolved(func, breakpoint_pos);
       RegisterSourceBreakpoint(bpt);
-      // There may be more than one function object for a given function
-      // in source code. There may be implicit closure functions, and
-      // there may be copies of mixin functions. Collect all functions whose
-      // source code range matches exactly the best fit function we
-      // found.
-      GrowableObjectArray& functions =
-          GrowableObjectArray::Handle(GrowableObjectArray::New());
-      FindEquivalentFunctions(script,
-                              func.token_pos(),
-                              func.end_token_pos(),
-                              &functions);
+
+      // Create code breakpoints for all compiled functions we found.
       const intptr_t num_functions = functions.Length();
-      // We must have found at least one function: func.
-      ASSERT(num_functions > 0);
-      // Create code breakpoints for all compiled functions we found.
       for (intptr_t i = 0; i < num_functions; i++) {
         func ^= functions.At(i);
-        if (func.HasCode()) {
-          MakeCodeBreakpointsAt(func, bpt);
-        }
+        ASSERT(func.HasCode());
+        MakeCodeBreakpointsAt(func, bpt);
       }
       bpt->Enable();
       SignalBpResolved(bpt);
       return bpt;
     }
   }
   // There is no compiled function at this token position.
   // Register an unresolved breakpoint.
   if (FLAG_verbose_debug && !func.IsNull()) {
     intptr_t line_number;
@@ skipping 530 matching lines @@
 
 void Debugger::NotifyCompilation(const Function& func) {
   if (src_breakpoints_ == NULL) {
     // Return with minimal overhead if there are no breakpoints.
     return;
   }
   // Iterate over all source breakpoints to check whether breakpoints
   // need to be set in the newly compiled function.
   Script& script = Script::Handle(isolate_);
   for (SourceBreakpoint* bpt = src_breakpoints_;
-       bpt != NULL;
-       bpt = bpt->next()) {
-       script = bpt->script();
+      bpt != NULL;
+      bpt = bpt->next()) {
+    script = bpt->script();
     if (FunctionContains(func, script, bpt->token_pos())) {
       Function& inner_function = Function::Handle(isolate_);
       inner_function = FindInnermostClosure(func, bpt->token_pos());
       if (!inner_function.IsNull()) {
         // The local function of a function we just compiled cannot
         // be compiled already.
         ASSERT(!inner_function.HasCode());
         if (FLAG_verbose_debug) {
           OS::Print("Pending BP remains unresolved in inner function '%s'\n",
                     inner_function.ToFullyQualifiedCString());
@@ skipping 174 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart