Per-closure breakpoints; restructure breakpoint implementation to keep a list of conditions.

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 44 matching lines @@
   }
 
  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,
+SourceBreakpoint::SourceBreakpoint(const Script& script,
                                    intptr_t token_pos,
                                    intptr_t end_token_pos)
-    : id_(id),
-      script_(script.raw()),
+    : 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),
+      conditions_(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,
+SourceBreakpoint::SourceBreakpoint(const String& url,
                                    intptr_t line_number)
-    : id_(id),
-      script_(Script::null()),
+    : 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),
+      conditions_(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() {
@@ skipping 46 matching lines @@
   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 BreakpointCondition::set_src_bpt(SourceBreakpoint* new_src_bpt) {
+  ASSERT(src_bpt_->IsLatent());  // Only reason to move.
+  src_bpt_ = new_src_bpt;
+}
+
+
+void BreakpointCondition::VisitObjectPointers(ObjectPointerVisitor* visitor) {
+  visitor->VisitPointer(reinterpret_cast<RawObject**>(&closure_));
+}
+
+
 void SourceBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&script_));
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&url_));
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
+
+  BreakpointCondition* cond = conditions_;
+  while (cond != NULL) {
+    cond -> VisitObjectPointers(visitor);
+    cond = cond->next();
+  }
 }
 
 
-void SourceBreakpoint::PrintJSON(JSONStream* stream) {
+void BreakpointCondition::PrintJSON(JSONStream* stream) {
   Isolate* isolate = Isolate::Current();
 
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "Breakpoint");
 
   jsobj.AddPropertyF("id", "breakpoints/%" Pd "", id());
   jsobj.AddProperty("breakpointNumber", id());
-  jsobj.AddProperty("resolved", IsResolved());
+  jsobj.AddProperty("resolved", src_bpt_->IsResolved());
 
   Library& library = Library::Handle(isolate);
   Script& script = Script::Handle(isolate);
   intptr_t token_pos;
-  GetCodeLocation(&library, &script, &token_pos);
+  src_bpt_->GetCodeLocation(&library, &script, &token_pos);
   {
     JSONObject location(&jsobj, "location");
     location.AddProperty("type", "Location");
     location.AddProperty("script", script);
     location.AddProperty("tokenPos", token_pos);
   }
 }
 
 
 void CodeBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
@@ skipping 88 matching lines @@
     Debugger* debugger = Isolate::Current()->debugger();
     ASSERT(debugger != NULL);
     debugger->SignalIsolateEvent(DebuggerEvent::kIsolateInterrupted);
   }
 }
 
 
 // The vm service handles breakpoint notifications in a different way
 // than the regular debugger breakpoint notifications.
 static void SendServiceBreakpointEvent(ServiceEvent::EventType type,
-                                       SourceBreakpoint* bpt) {
+                                       BreakpointCondition* bpt) {
   if (Service::NeedsEvents()) {
     ServiceEvent service_event(Isolate::Current(), type);
     service_event.set_breakpoint(bpt);
     Service::HandleEvent(&service_event);
   }
 }
 
 
+BreakpointCondition* SourceBreakpoint::AddRepeated(Debugger* dbg) {
+  BreakpointCondition* cond = conditions();
+  while (cond != NULL) {
+    if (cond->IsRepeated()) break;
+    cond = cond->next();
+  }
+  if (cond == NULL) {
+    cond = new BreakpointCondition(dbg->nextId(), this);
+    cond->SetIsRepeated();
+    cond->set_next(conditions());
+    set_conditions(cond);
+
+    if (IsResolved()) {
+      dbg->SignalBpResolved(cond);
+    }
+    SendServiceBreakpointEvent(ServiceEvent::kBreakpointAdded, cond);
+  }
+  return cond;
+}
+
+
+BreakpointCondition* SourceBreakpoint::AddSingleShot(Debugger* dbg) {
+  BreakpointCondition* cond = conditions();
+  while (cond != NULL) {
+    if (cond->IsSingleShot()) break;
+    cond = cond->next();
+  }
+  if (cond == NULL) {
+    cond = new BreakpointCondition(dbg->nextId(), this);
+    cond->SetIsSingleShot();
+    cond->set_next(conditions());
+    set_conditions(cond);
+
+    if (IsResolved()) {
+      dbg->SignalBpResolved(cond);
+    }
+    SendServiceBreakpointEvent(ServiceEvent::kBreakpointAdded, cond);
+  }
+  return cond;
+}
+
+
+BreakpointCondition* SourceBreakpoint::AddPerClosure(Debugger* dbg,
+                                                     const Instance& closure) {
+  BreakpointCondition* cond = conditions();
+  while (cond != NULL) {
+    if (cond->IsPerClosure() && cond->closure() == closure.raw()) break;
+    cond = cond->next();
+  }
+  if (cond == NULL) {
+    cond = new BreakpointCondition(dbg->nextId(), this);
+    cond->SetIsPerClosure(closure);
+    cond->set_next(conditions());
+    set_conditions(cond);
+
+    if (IsResolved()) {
+      dbg->SignalBpResolved(cond);
+    }
+    SendServiceBreakpointEvent(ServiceEvent::kBreakpointAdded, cond);
+  }
+  return cond;
+}
+
+
 const char* Debugger::QualifiedFunctionName(const Function& func) {
   const String& func_name = String::Handle(func.name());
   Class& func_class = Class::Handle(func.Owner());
   String& class_name = String::Handle(func_class.Name());
 
   const char* kFormat = "%s%s%s";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat,
       func_class.IsTopLevel() ? "" : class_name.ToCString(),
       func_class.IsTopLevel() ? "" : ".",
       func_name.ToCString());
@@ skipping 56 matching lines @@
     }
     cbpt = cbpt->next_;
   }
   return false;
 }
 
 
 void Debugger::PrintBreakpointsToJSONArray(JSONArray* jsarr) const {
   SourceBreakpoint* sbpt = src_breakpoints_;
   while (sbpt != NULL) {
-    jsarr->AddValue(sbpt);
+    BreakpointCondition* cond = sbpt->conditions();
+    while (cond != NULL) {
+      jsarr->AddValue(cond);
+      cond = cond->next();
+    }
     sbpt = sbpt->next_;
   }
 }
 
 
 RawString* ActivationFrame::QualifiedFunctionName() {
   return String::New(Debugger::QualifiedFunctionName(function()));
 }
 
 
@@ skipping 276 matching lines @@
   vars_initialized_ = true;
 }
 
 
 intptr_t ActivationFrame::NumLocalVariables() {
   GetDescIndices();
   return desc_indices_.length();
 }
 
 
+RawObject* ActivationFrame::GetParameter(intptr_t index) {
+  intptr_t num_parameters = function().num_fixed_parameters();
+  ASSERT(0 <= index && index < num_parameters);
+  intptr_t reverse_index = num_parameters - index;
+
+  if (function().NumOptionalParameters() > 0) {
+    // If the function has optional parameters, the first positional parameter
+    // can be in a number of places in the caller's frame depending on how many
+    // were actually supplied at the call site, but they are copied to a fixed
+    // place in the callee's frame.
+    uword var_address = fp() + ((kFirstLocalSlotFromFp - index) * kWordSize);
+    return reinterpret_cast<RawObject*>(
+        *reinterpret_cast<uword*>(var_address));
+  } else {
+    uword var_address = fp() + (kParamEndSlotFromFp * kWordSize)
+                             + (reverse_index * kWordSize);
+    return reinterpret_cast<RawObject*>(
+        *reinterpret_cast<uword*>(var_address));
+  }
+}
+
+
+RawObject* ActivationFrame::GetClosure() {
+  ASSERT(function().IsClosureFunction());
+  return GetParameter(0);
+}
+
+
 RawObject* ActivationFrame::GetLocalVar(intptr_t slot_index) {
   if (deopt_frame_.IsNull()) {
     uword var_address = fp() + slot_index * kWordSize;
     return reinterpret_cast<RawObject*>(
         *reinterpret_cast<uword*>(var_address));
   } else {
     return deopt_frame_.At(deopt_frame_offset_ + slot_index);
   }
 }
 
@@ skipping 497 matching lines @@
           if (function.HasOptimizedCode()) {
             function.SwitchToUnoptimizedCode();
           }
         }
       }
     }
   }
 }
 
 
-void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
-  if (HasEventHandler() && !bpt->IsOneShot()) {
-    DebuggerEvent event(isolate_, DebuggerEvent::kBreakpointResolved);
-    event.set_breakpoint(bpt);
-    InvokeEventHandler(&event);
+void Debugger::SignalBpResolved(BreakpointCondition* cond) {
+  if (HasEventHandler()) {
+    if (!cond->IsSingleShot()) {
+      DebuggerEvent event(isolate_, DebuggerEvent::kBreakpointResolved);
+      event.set_breakpoint(cond);
+      InvokeEventHandler(&event);
+    }
   }
 }
 
 
 ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
                                             uword pc,
                                             StackFrame* frame,
                                             const Code& code,
                                             const Array& deopt_frame,
                                             intptr_t deopt_frame_offset) {
@@ skipping 511 matching lines @@
     DeoptimizeWorld();
     func ^= functions.At(0);
     intptr_t breakpoint_pos =
         ResolveBreakpointPos(func, token_pos, last_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, last_token_pos);
+      bpt = new SourceBreakpoint(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());
         MakeCodeBreakpointAt(func, bpt);
       }
       bpt->Enable();
       if (FLAG_verbose_debug) {
         intptr_t line_number;
         script.GetTokenLocation(breakpoint_pos, &line_number, NULL);
         OS::Print("Resolved BP for "
                   "function '%s' at line %" Pd "\n",
                   func.ToFullyQualifiedCString(),
                   line_number);
       }
-      SignalBpResolved(bpt);
-      SendServiceBreakpointEvent(ServiceEvent::kBreakpointAdded, 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;
     script.GetTokenLocation(token_pos, &line_number, NULL);
     OS::Print("Registering pending breakpoint for "
               "uncompiled function '%s' at line %" Pd "\n",
               func.ToFullyQualifiedCString(),
               line_number);
   }
   SourceBreakpoint* bpt = GetSourceBreakpoint(script, token_pos);
   if (bpt == NULL) {
-    bpt = new SourceBreakpoint(nextId(), script, token_pos, last_token_pos);
+    bpt = new SourceBreakpoint(script, token_pos, last_token_pos);
     RegisterSourceBreakpoint(bpt);
-    SendServiceBreakpointEvent(ServiceEvent::kBreakpointAdded, bpt);
   }
   bpt->Enable();
   return bpt;
 }
 
 
 // Synchronize the enabled/disabled state of all code breakpoints
 // associated with the source breakpoint bpt.
 void Debugger::SyncBreakpoint(SourceBreakpoint* bpt) {
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     if (bpt == cbpt->src_bpt()) {
       if (bpt->IsEnabled()) {
         cbpt->Enable();
       } else {
         cbpt->Disable();
       }
     }
     cbpt = cbpt->next();
   }
 }
 
 
 RawError* Debugger::OneTimeBreakAtEntry(const Function& target_function) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
-    SourceBreakpoint* bpt = SetBreakpointAtEntry(target_function);
-    if (bpt != NULL) {
-      bpt->SetIsOneShot();
-    }
+    SetBreakpointAtEntry(target_function, true);
     return Error::null();
   } else {
     return isolate_->object_store()->sticky_error();
   }
 }
 
 
-SourceBreakpoint* Debugger::SetBreakpointAtEntry(
-      const Function& target_function) {
+BreakpointCondition* Debugger::SetBreakpointAtEntry(
+    const Function& target_function,
+    bool single_shot) {
   ASSERT(!target_function.IsNull());
   if (!target_function.is_debuggable()) {
     return NULL;
   }
   const Script& script = Script::Handle(target_function.script());
-  return SetBreakpoint(script,
-                       target_function.token_pos(),
-                       target_function.end_token_pos());
+  SourceBreakpoint* src_bpt = SetBreakpoint(script,
+                                            target_function.token_pos(),
+                                            target_function.end_token_pos());
+  if (single_shot) {
+    return src_bpt->AddSingleShot(this);
+  } else {
+    return src_bpt->AddRepeated(this);
+  }
 }
 
 
-SourceBreakpoint* Debugger::SetBreakpointAtLine(const String& script_url,
-                                                intptr_t line_number) {
+BreakpointCondition* Debugger::SetBreakpointAtActivation(
+    const Instance& closure) {
+  if (!closure.IsClosure()) {
+    return NULL;
+  }
+  const Function& func = Function::Handle(Closure::function(closure));
+  const Script& script = Script::Handle(func.script());
+  SourceBreakpoint* bpt = SetBreakpoint(script,
+                                        func.token_pos(),
+                                        func.end_token_pos());
+  return bpt->AddPerClosure(this, closure);
+}
+
+
+BreakpointCondition* Debugger::SetBreakpointAtLine(const String& script_url,
+                                                   intptr_t line_number) {
+  SourceBreakpoint* bpt = SourceBreakpointAtLine(script_url, line_number);
+  return bpt->AddRepeated(this);
+}
+
+
+SourceBreakpoint* Debugger::SourceBreakpointAtLine(const String& script_url,
+                                                   intptr_t line_number) {
   Library& lib = Library::Handle(isolate_);
   Script& script = Script::Handle(isolate_);
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate_->object_store()->libraries());
   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()) {
@@ skipping 326 matching lines @@
   if (ServiceIsolate::IsRunning()) {
     return true;
   }
   const Class& cls = Class::Handle(func.Owner());
   const Library& lib = Library::Handle(cls.library());
   return lib.IsDebuggable();
 }
 
 
 void Debugger::SignalPausedEvent(ActivationFrame* top_frame,
-                                 SourceBreakpoint* bpt) {
+                                 BreakpointCondition* bpt) {
   resume_action_ = kContinue;
   stepping_fp_ = 0;
   isolate_->set_single_step(false);
   ASSERT(!IsPaused());
   ASSERT(obj_cache_ == NULL);
-  if ((bpt != NULL) && bpt->IsOneShot()) {
+  if ((bpt != NULL) && bpt->IsSingleShot())  {
     RemoveBreakpoint(bpt->id());
     bpt = NULL;
   }
   DebuggerEvent event(isolate_, DebuggerEvent::kBreakpointReached);
   event.set_top_frame(top_frame);
   event.set_breakpoint(bpt);
   Pause(&event);
 }
 
 
@@ skipping 64 matching lines @@
   if (ignore_breakpoints_ || IsPaused() || !HasEventHandler()) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   ASSERT(stack_trace->Length() > 0);
   ActivationFrame* top_frame = stack_trace->FrameAt(0);
   ASSERT(top_frame != NULL);
   CodeBreakpoint* bpt = GetCodeBreakpoint(top_frame->pc());
   ASSERT(bpt != NULL);
 
+  SourceBreakpoint* src_bpt = bpt->src_bpt_;
+  BreakpointCondition* condition_met = NULL;
+  if (src_bpt != NULL) {
+    BreakpointCondition* cond = src_bpt->conditions();
+    while (cond != NULL) {
+      if (cond->IsPerClosure()) {
+        Object& closure = Object::Handle(top_frame->GetClosure());
+        ASSERT(closure.IsInstance());
+        ASSERT(Instance::Cast(closure).IsClosure());
+        if (closure.raw() == cond->closure()) {
+          condition_met = cond;
+          break;
+        }
+      } else {
+        condition_met = cond;

[hausner, 2015/05/21 18:23:55]

This is subtly wrong. If you have a one-shot breakpoint at the same location but
it appears later in the list of BreakpointCondition, it does not get deleted
after the pause event has been signaled.

Another question to ponder: if there are several BreakpointCondition breakpoints
at the same location (SourceBreakpoint), should they all fire if their condition
is met?

[rmacnak, 2015/05/21 21:59:35]

As discussed, we should not send a series of breakpoint hit notifications
because the client may respond with a continue for each of them. We should
update the protocol to send all the breakpoint whose condition is satisfied
together. For now, only treating one as hit, with priority single shot > per
closure > general.

+        break;
+      }
+      cond = cond->next();
+    }
+  }
+  if (condition_met == NULL) {
+    return;
+  }
+
+
   if (FLAG_verbose_debug) {
     OS::Print(">>> hit %s breakpoint at %s:%" Pd " "
               "(token %" Pd ") (address %#" Px ")\n",
               bpt->IsInternal() ? "internal" : "user",
               String::Handle(bpt->SourceUrl()).ToCString(),
               bpt->LineNumber(),
               bpt->token_pos(),
               top_frame->pc());
   }
 
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
-  SignalPausedEvent(top_frame, bpt->src_bpt_);
+  SignalPausedEvent(top_frame, condition_met);
   HandleSteppingRequest(stack_trace_);
   stack_trace_ = NULL;
   if (bpt->IsInternal()) {
     RemoveInternalBreakpoints();
   }
 }
 
 
 void Debugger::BreakHere(const String& msg) {
   // We ignore this breakpoint when the VM is executing code invoked
@@ skipping 120 matching lines @@
         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 range %" Pd "-%" Pd ")\n",
-                    bpt->id(),
-                    bpt->token_pos(),
-                    bpt->LineNumber(),
-                    func.ToFullyQualifiedCString(),
-                    requested_pos,
-                    requested_end_pos);
+        BreakpointCondition* cond = bpt->conditions();
+        while (cond != NULL) {
+          if (FLAG_verbose_debug) {
+            OS::Print("Resolved BP %" Pd " to pos %" Pd ", line %" Pd ", "
+                      "function '%s' (requested range %" Pd "-%" Pd ")\n",
+                      cond->id(),
+                      bpt->token_pos(),
+                      bpt->LineNumber(),
+                      func.ToFullyQualifiedCString(),
+                      requested_pos,
+                      requested_end_pos);
+          }
+          SignalBpResolved(cond);
+          SendServiceBreakpointEvent(ServiceEvent::kBreakpointResolved, cond);
+          cond = cond->next();
         }
-        SignalBpResolved(bpt);
-        SendServiceBreakpointEvent(ServiceEvent::kBreakpointResolved, 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());
+        BreakpointCondition* cond = bpt->conditions();
+        while (cond != NULL) {
+          OS::Print("Setting breakpoint %" Pd " at line %" Pd " for %s '%s'\n",
+                    cond->id(),
+                    bpt->LineNumber(),
+                    func.IsClosureFunction() ? "closure" : "function",
+                    String::Handle(func.name()).ToCString());
+          cond = cond->next();
+        }
       }
       MakeCodeBreakpointAt(func, bpt);
     }
   }
 }
 
 
 void Debugger::NotifyDoneLoading() {
   if (latent_breakpoints_ == NULL) {
     // Common, fast path.
@@ skipping 26 matching lines @@
         // 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());
+          BreakpointCondition* cond = matched_bpt->conditions();
+          while (cond != NULL) {
+            if (FLAG_verbose_debug) {
+              OS::Print("No code found at line %" Pd ": "
+                        "dropping latent breakpoint %" Pd " in '%s'\n",
+                        line_number,
+                        cond->id(),
+                        url.ToCString());
+            }
+            BreakpointCondition* prev = cond;
+            cond = cond->next();
+            delete prev;
           }
           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,
+                new SourceBreakpoint(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);
+
+            // Move conditions over.
+            BreakpointCondition* cond = existing_bpt->conditions();
+            unresolved_bpt->set_conditions(cond);
+            existing_bpt->set_conditions(NULL);
+            while (cond != NULL) {
+              cond->set_src_bpt(unresolved_bpt);
+              if (FLAG_verbose_debug) {
+                OS::Print("Converted latent breakpoint "
+                          "%" Pd " in '%s' at line %" Pd "\n",
+                          cond->id(),
+                          url.ToCString(),
+                          line_number);
+              }
+              cond = cond->next();
             }
           }
           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;
         }
       }
     }
     if (!found_match) {
       // No matching url found in any of the libraries.
       if (FLAG_verbose_debug) {
-        OS::Print("No match found for latent breakpoint id "
-                  "%" Pd " with url '%s'\n",
-                  bpt->id(),
-                  url.ToCString());
+        BreakpointCondition* cond = bpt->conditions();
+        while (cond != NULL) {
+          OS::Print("No match found for latent breakpoint id "
+                    "%" Pd " with url '%s'\n",
+                    cond->id(),
+                    url.ToCString());
+          cond = cond->next();
+        }
       }
       bpt = bpt->next();
     }
   }
 }
 
 
 // TODO(hausner): Could potentially make this faster by checking
 // whether the call target at pc is a debugger stub.
 bool Debugger::HasActiveBreakpoint(uword pc) {
@@ skipping 23 matching lines @@
   return 0L;
 }
 
 
 // Remove and delete the source breakpoint bpt and its associated
 // code breakpoints.
 void Debugger::RemoveBreakpoint(intptr_t bp_id) {
   SourceBreakpoint* prev_bpt = NULL;
   SourceBreakpoint* curr_bpt = src_breakpoints_;
   while (curr_bpt != NULL) {
-    if (curr_bpt->id() == bp_id) {
+    BreakpointCondition* prev_cond = NULL;
+    BreakpointCondition* curr_cond = curr_bpt->conditions();
+    while (curr_cond != NULL) {
+      if (curr_cond->id() == bp_id) {
+        if (prev_cond == NULL) {
+          curr_bpt->set_conditions(curr_cond->next());
+        } else {
+          prev_cond->set_next(curr_cond->next());
+        }
+        SendServiceBreakpointEvent(ServiceEvent::kBreakpointRemoved, curr_cond);
+
+        // Remove references from the current debugger pause event.
+        if (pause_event_ != NULL &&
+            pause_event_->type() == DebuggerEvent::kBreakpointReached &&
+            pause_event_->breakpoint() == curr_cond) {
+          pause_event_->set_breakpoint(NULL);
+        }
+        return;
+      }
+
+      prev_cond = curr_cond;
+      curr_cond = curr_cond->next();
+    }
+
+    if (curr_bpt->conditions() == NULL) {
       if (prev_bpt == NULL) {
         src_breakpoints_ = src_breakpoints_->next();
       } else {
         prev_bpt->set_next(curr_bpt->next());
       }
-      SendServiceBreakpointEvent(ServiceEvent::kBreakpointRemoved, curr_bpt);
 
       // Remove references from code breakpoints to this source breakpoint,
       // and disable the code breakpoints.
       UnlinkCodeBreakpoints(curr_bpt);
       delete curr_bpt;
+    }
 
-      // Remove references from the current debugger pause event.
-      if (pause_event_ != NULL &&
-          pause_event_->type() == DebuggerEvent::kBreakpointReached &&
-          pause_event_->breakpoint() == curr_bpt) {
-        pause_event_->set_breakpoint(NULL);
-      }
-      return;
-    }
     prev_bpt = curr_bpt;
     curr_bpt = curr_bpt->next();
   }
   // bpt is not a registered breakpoint, nothing to do.
 }
 
 
 // Turn code breakpoints associated with the given source breakpoint into
 // internal breakpoints. They will later be deleted when control
 // returns from the user-defined breakpoint callback. Also, disable the
@@ skipping 42 matching lines @@
   while (bpt != NULL) {
     if ((bpt->script_ == script.raw()) && (bpt->token_pos_ == token_pos)) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
 
-SourceBreakpoint* Debugger::GetBreakpointById(intptr_t id) {
+BreakpointCondition* Debugger::GetBreakpointById(intptr_t id) {
   SourceBreakpoint* bpt = src_breakpoints_;
   while (bpt != NULL) {
-    if (bpt->id() == id) {
-      return bpt;
+    BreakpointCondition* cond = bpt->conditions();
+    while (cond != NULL) {
+      if (cond->id() == id) {
+        return cond;
+      }
+      cond = cond->next();
     }
     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 = new SourceBreakpoint(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