Support breakpoints in deferred libraries

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 36 matching lines @@
     return obj_id < objs_->Length();
   }
 
  private:
   GrowableObjectArray* objs_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteObjectCache);
 };
 
 
+// Create an unresolved breakpoint in given token range and script.
 SourceBreakpoint::SourceBreakpoint(intptr_t id,
                                    const Script& script,
                                    intptr_t token_pos,
                                    intptr_t end_token_pos)
     : id_(id),
       script_(script.raw()),
+      url_(script.url()),
       token_pos_(token_pos),
       end_token_pos_(end_token_pos),
       is_resolved_(false),
       is_enabled_(false),
       is_one_shot_(false),
       next_(NULL),
       function_(Function::null()),
       line_number_(-1) {
   ASSERT(id_ > 0);
   ASSERT(!script.IsNull());
   ASSERT(token_pos_ >= 0);
 }
 
+// Create a latent breakpoint at given url and line number.
+SourceBreakpoint::SourceBreakpoint(intptr_t id,
+                                   const String& url,
+                                   intptr_t line_number)
+    : id_(id),
+      script_(Script::null()),
+      url_(url.raw()),
+      token_pos_(-1),
+      end_token_pos_(-1),
+      is_resolved_(false),
+      is_enabled_(false),
+      is_one_shot_(false),
+      next_(NULL),
+      function_(Function::null()),
+      line_number_(line_number) {
+  ASSERT(id >= 0);
+  ASSERT(line_number_ >= 0);
+}
 
 void SourceBreakpoint::Enable() {
   is_enabled_ = true;
   Isolate::Current()->debugger()->SyncBreakpoint(this);
 }
 
 
 void SourceBreakpoint::Disable() {
   is_enabled_ = false;
   Isolate::Current()->debugger()->SyncBreakpoint(this);
 }
 
 
 void SourceBreakpoint::SetResolved(const Function& func, intptr_t token_pos) {
+  ASSERT(!IsLatent());
   ASSERT(func.script() == script_);
   ASSERT((func.token_pos() <= token_pos) &&
          (token_pos <= func.end_token_pos()));
   function_ = func.raw();
   token_pos_ = token_pos;
   end_token_pos_ = token_pos;
   line_number_ = -1;  // Recalcualte lazily.
   is_resolved_ = true;
 }
 
 
 // TODO(hausner): Get rid of library parameter. A source breakpoint location
 // does not imply a library, since the same source code can be included
 // in more than one library, e.g. the text location of mixin functions.
 void SourceBreakpoint::GetCodeLocation(Library* lib,
                                        Script* script,
                                        intptr_t* pos) {
-  *script = this->script();
-  *pos = token_pos_;
-  if (IsResolved()) {
-    const Function& func = Function::Handle(function_);
-    ASSERT(!func.IsNull());
-    const Class& cls = Class::Handle(func.origin());
-    *lib = cls.library();
+  if (IsLatent()) {
+    *lib = Library::null();
+    *script = Script::null();
+    *pos = -1;
   } else {
-    *lib = Library::null();
+    *script = this->script();
+    *pos = token_pos_;
+    if (IsResolved()) {
+      const Function& func = Function::Handle(function_);
+      ASSERT(!func.IsNull());
+      const Class& cls = Class::Handle(func.origin());
+      *lib = cls.library();
+    } else {
+      *lib = Library::null();
+    }
   }
 }
 
 
-RawString* SourceBreakpoint::SourceUrl() {
-  return Script::Handle(script()).url();
-}
-
-
 intptr_t SourceBreakpoint::LineNumber() {
+  // Latent breakpoints must have a requested line number >= 0.
+  ASSERT(!IsLatent() || line_number_ >= 0);
   // Compute line number lazily since it causes scanning of the script.
   if (line_number_ < 0) {
     const Script& script = Script::Handle(this->script());
     script.GetTokenLocation(token_pos_, &line_number_, NULL);
   }
   return line_number_;
 }
 
 
 void SourceBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&script_));
+  visitor->VisitPointer(reinterpret_cast<RawObject**>(&url_));
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 }
 
 
 void SourceBreakpoint::PrintJSON(JSONStream* stream) {
   Isolate* isolate = Isolate::Current();
 
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "Breakpoint");
 
@@ skipping 843 matching lines @@
   ASSERT(IsValidId(obj_id));
   return objs_->At(obj_id);
 }
 
 
 Debugger::Debugger()
     : isolate_(NULL),
       isolate_id_(ILLEGAL_ISOLATE_ID),
       initialized_(false),
       next_id_(1),
+      latent_breakpoints_(NULL),
       src_breakpoints_(NULL),
       code_breakpoints_(NULL),
       resume_action_(kContinue),
       ignore_breakpoints_(false),
       pause_event_(NULL),
       obj_cache_(NULL),
       stack_trace_(NULL),
       stepping_fp_(0),
       exc_pause_info_(kNoPauseOnExceptions) {
 }
 
 
 Debugger::~Debugger() {
   isolate_id_ = ILLEGAL_ISOLATE_ID;
   ASSERT(!IsPaused());
+  ASSERT(latent_breakpoints_ == NULL);
   ASSERT(src_breakpoints_ == NULL);
   ASSERT(code_breakpoints_ == NULL);
   ASSERT(stack_trace_ == NULL);
   ASSERT(obj_cache_ == NULL);
 }
 
 
 void Debugger::Shutdown() {
   while (src_breakpoints_ != NULL) {
     SourceBreakpoint* bpt = src_breakpoints_;
     src_breakpoints_ = src_breakpoints_->next();
     delete bpt;
   }
+  while (latent_breakpoints_ != NULL) {
+    SourceBreakpoint* bpt = latent_breakpoints_;
+    latent_breakpoints_ = latent_breakpoints_->next();
+    delete bpt;
+  }
   while (code_breakpoints_ != NULL) {
     CodeBreakpoint* bpt = code_breakpoints_;
     code_breakpoints_ = code_breakpoints_->next();
     bpt->Disable();
     delete bpt;
   }
   // Signal isolate shutdown event.
   SignalIsolateEvent(DebuggerEvent::kIsolateShutdown);
 }
 
@@ skipping 469 matching lines @@
   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);
       // If the class is not finalized, e.g. if it hasn't been parsed
       // yet entirely, we can ignore it. If it contains a function with
-      // a latent breakpoint, we will detect it if and when the function
-      // gets compiled.
+      // an unresolved breakpoint, we will detect it if and when the
+      // function gets compiled.
       if (!cls.is_finalized()) {
         continue;
       }
       // Note: we need to check the functions of this class even if
       // the class is defined in a differenct 'script'. There could
       // be mixin functions from the given script in this class.
       functions = cls.functions();
       if (!functions.IsNull()) {
         const intptr_t num_functions = functions.Length();
         for (intptr_t pos = 0; pos < num_functions; pos++) {
@@ skipping 247 matching lines @@
   const GrowableObjectArray& scripts =
     GrowableObjectArray::Handle(isolate_, GrowableObjectArray::New());
   for (intptr_t i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     script = lib.LookupScript(script_url);
     if (!script.IsNull()) {
       scripts.Add(script);
     }
   }
   if (scripts.Length() == 0) {
+    // No script found with given url. Create a latent breakpoint which
+    // will be set if the url is loaded later.
+    SourceBreakpoint* latent_bpt = GetLatentBreakpoint(script_url, line_number);
     if (FLAG_verbose_debug) {
-      OS::Print("Failed to find script with url '%s'\n",
-                script_url.ToCString());
+      OS::Print("Set latent breakpoint in url '%s' at line %" Pd "\n",
+                script_url.ToCString(),
+                line_number);
     }
-    return NULL;
+    return latent_bpt;
   }
   if (scripts.Length() > 1) {
     if (FLAG_verbose_debug) {
       OS::Print("Multiple scripts match url '%s'\n", script_url.ToCString());
     }
     return NULL;
   }
   script ^= scripts.At(0);
   intptr_t first_token_idx, last_token_idx;
   script.TokenRangeAtLine(line_number, &first_token_idx, &last_token_idx);
@@ skipping 225 matching lines @@
 
 
 // static
 void Debugger::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   ASSERT(visitor != NULL);
   SourceBreakpoint* bpt = src_breakpoints_;
   while (bpt != NULL) {
     bpt->VisitObjectPointers(visitor);
     bpt = bpt->next();
   }
+  bpt = latent_breakpoints_;
+  while (bpt != NULL) {
+    bpt->VisitObjectPointers(visitor);
+    bpt = bpt->next();
+  }
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     cbpt->VisitObjectPointers(visitor);
     cbpt = cbpt->next();
   }
 }
 
 
 // static
 void Debugger::SetEventHandler(EventHandler* handler) {
@@ skipping 261 matching lines @@
         intptr_t bp_pos =
             ResolveBreakpointPos(func, bpt->token_pos(), bpt->end_token_pos());
         if (bp_pos < 0) {
           if (FLAG_verbose_debug) {
             OS::Print("Failed resolving breakpoint for function '%s'\n",
                       String::Handle(func.name()).ToCString());
           }
           continue;
         }
         intptr_t requested_pos = bpt->token_pos();
+        intptr_t requested_end_pos = bpt->end_token_pos();
         bpt->SetResolved(func, bp_pos);
         if (FLAG_verbose_debug) {
           OS::Print("Resolved BP %" Pd " to pos %" Pd ", line %" Pd ", "
-                    "function '%s' (requested pos %" Pd ")\n",
+                    "function '%s' (requested range %" Pd "-%" Pd ")\n",
                     bpt->id(),
                     bpt->token_pos(),
                     bpt->LineNumber(),
                     func.ToFullyQualifiedCString(),
-                    requested_pos);
+                    requested_pos,
+                    requested_end_pos);
         }
         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());
       }
       MakeCodeBreakpointAt(func, bpt);
     }
   }
 }
 
 
+void Debugger::NotifyDoneLoading() {
+  if (latent_breakpoints_ == NULL) {
+    // Common, fast path.
+    return;
+  }
+  Library& lib = Library::Handle(isolate_);
+  Script& script = Script::Handle(isolate_);
+  String& url = String::Handle(isolate_);
+  SourceBreakpoint* bpt = latent_breakpoints_;
+  SourceBreakpoint* prev_bpt = NULL;
+  const GrowableObjectArray& libs =
+      GrowableObjectArray::Handle(isolate_->object_store()->libraries());
+  while (bpt != NULL) {
+    url = bpt->url();
+    for (intptr_t i = 0; i < libs.Length(); i++) {
+      lib ^= libs.At(i);
+      script = lib.LookupScript(url);
+      if (!script.IsNull()) {
+        // Found a script with matching url for this latent breakpoint.
+        // Unlink the latent breakpoint from the list.
+        SourceBreakpoint* matched_bpt = bpt;
+        bpt = bpt->next();
+        if (prev_bpt == NULL) {
+          latent_breakpoints_ = bpt;
+        } else {
+          prev_bpt->set_next(bpt);
+        }
+        // Now find the token range at the requested line and make a
+        // new unresolved source breakpoint.
+        intptr_t line_number = matched_bpt->LineNumber();
+        ASSERT(line_number >= 0);
+        intptr_t first_token_pos, last_token_pos;
+        script.TokenRangeAtLine(line_number, &first_token_pos, &last_token_pos);
+        if ((first_token_pos < 0) ||
+            (last_token_pos < 0)) {
+          // Script does not contain the given line number or there are no
+          // tokens on the line. Drop the breakpoint silently.
+          if (FLAG_verbose_debug) {
+            OS::Print("No code found at line %" Pd ": "
+                      "dropping latent breakpoint %" Pd " in '%s'\n",
+                      line_number,
+                      matched_bpt->id(),
+                      url.ToCString());
+          }
+          delete matched_bpt;
+        } else {
+          // We don't expect to already have a breakpoint for this location.
+          // If there is one, assert in debug build but silently drop
+          // the latent breakpoint in release build.
+          SourceBreakpoint* existing_bpt =
+              GetSourceBreakpoint(script, first_token_pos);
+          ASSERT(existing_bpt == NULL);
+          if (existing_bpt == NULL) {
+            // Create and register a new source breakpoint for the
+            // latent breakpoint.
+            SourceBreakpoint* unresolved_bpt =
+                new SourceBreakpoint(matched_bpt->id(),
+                                     script,
+                                     first_token_pos,
+                                     last_token_pos);
+            RegisterSourceBreakpoint(unresolved_bpt);
+            unresolved_bpt->Enable();
+            if (FLAG_verbose_debug) {
+              OS::Print("Converted latent breakpoint "
+                        "%" Pd " in '%s' at line %" Pd "\n",
+                        matched_bpt->id(),
+                        url.ToCString(),
+                        line_number);
+            }
+          }
+          delete matched_bpt;
+          // Break out of the iteration over loaded libraries. If the
+          // same url has been loaded into more than one library, we
+          // only set a breakpoint in the first one.
+          // TODO(hausner): There is one possible pitfall here.
+          // If the user sets a latent breakpoint using a partial url that
+          // ends up matching more than one script, the breakpoint might
+          // get set in the wrong script.
+          // It would be better if we could warn the user if multiple
+          // scripts are matching.
+          break;
+        }
+      }
+    }
+  }
+}
+
+
 // 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());
 }
 
 
 CodeBreakpoint* Debugger::GetCodeBreakpoint(uword breakpoint_address) {
   CodeBreakpoint* bpt = code_breakpoints_;
@@ skipping 110 matching lines @@
   while (bpt != NULL) {
     if (bpt->id() == id) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
 
+SourceBreakpoint* Debugger::GetLatentBreakpoint(const String& url,
+                                                intptr_t line) {
+  SourceBreakpoint* bpt = latent_breakpoints_;
+  String& bpt_url = String::Handle(isolate_);
+  while (bpt != NULL) {
+    bpt_url = bpt->url();
+    if (bpt_url.Equals(url) && (bpt->LineNumber() == line)) {
+      return bpt;
+    }
+    bpt = bpt->next();
+  }
+  // No breakpint for this url and line requested. Allocate new one.
+  bpt = new SourceBreakpoint(nextId(), url, line);
+  bpt->set_next(latent_breakpoints_);
+  latent_breakpoints_ = bpt;
+  return bpt;
+}
+
+
 void Debugger::RegisterSourceBreakpoint(SourceBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(src_breakpoints_);
   src_breakpoints_ = bpt;
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart