Debugger wire protocol: setting breakpoints

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"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 static const bool verbose = false;
 
 
-SourceBreakpoint::SourceBreakpoint(const Function& func, intptr_t token_index)
-    : function_(func.raw()),
+SourceBreakpoint::SourceBreakpoint(intptr_t id,
+                                   const Function& func,
+                                   intptr_t token_index)
+    : id_(id),
+      function_(func.raw()),
       token_index_(token_index),
       line_number_(-1),
       is_enabled_(false),
       next_(NULL) {
   ASSERT(!func.IsNull());
   ASSERT((func.token_index() <= token_index_) &&
          (token_index_ < func.end_token_index()));
 }
 
 
@@ skipping 381 matching lines @@
     RestoreCode();
   }
   ASSERT(!is_enabled_);
 }
 
 
 Debugger::Debugger()
     : isolate_(NULL),
       initialized_(false),
       bp_handler_(NULL),
+      event_handler_(NULL),
+      next_id_(1),
+      stack_trace_(NULL),
       src_breakpoints_(NULL),
       code_breakpoints_(NULL),
       resume_action_(kContinue),
       ignore_breakpoints_(false) {
 }
 
 
 Debugger::~Debugger() {
   ASSERT(src_breakpoints_ == NULL);
   ASSERT(code_breakpoints_ == NULL);
+  ASSERT(stack_trace_ == NULL);
 }
 
 
 void Debugger::Shutdown() {
   while (src_breakpoints_ != NULL) {
     SourceBreakpoint* bpt = src_breakpoints_;
     src_breakpoints_ = src_breakpoints_->next();
     delete bpt;
   }
   while (code_breakpoints_ != NULL) {
@@ skipping 91 matching lines @@
         (kind == PcDescriptors::kFuncCall) ||
         (kind == PcDescriptors::kReturn)) {
       bpt = new CodeBreakpoint(target_function, i);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
     }
   }
 }
 
 
+void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
+  if (event_handler_ != NULL) {
+    DebuggerEvent event;
+    event.type = kBreakpointResolved;
+    event.breakpoint = bpt;
+    (*event_handler_)(&event);
+  }
+}
+
+
 CodeBreakpoint* Debugger::MakeCodeBreakpoint(const Function& func,
                                              intptr_t token_index) {
   ASSERT(func.HasCode());
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   intptr_t best_fit_index = -1;
   intptr_t best_fit = INT_MAX;
   for (int i = 0; i < desc.Length(); i++) {
@@ skipping 43 matching lines @@
       (target_function.end_token_index() <= token_index)) {
     // The given token position is not within the target function.
     return NULL;
   }
   EnsureFunctionIsDeoptimized(target_function);
   SourceBreakpoint* bpt = GetSourceBreakpoint(target_function, token_index);
   if (bpt != NULL) {
     // A breakpoint for this location already exists, return it.
     return bpt;
   }
-  bpt = new SourceBreakpoint(target_function, token_index);
+  bpt = new SourceBreakpoint(nextId(), target_function, token_index);
   RegisterSourceBreakpoint(bpt);
   if (verbose && !target_function.HasCode()) {
     OS::Print("Registering breakpoint for uncompiled function '%s'"
               " (%s:%d)\n",
               String::Handle(target_function.name()).ToCString(),
               String::Handle(bpt->SourceUrl()).ToCString(),
               bpt->LineNumber());
   }
 
   if (target_function.HasCode()) {
     CodeBreakpoint* cbpt = MakeCodeBreakpoint(target_function, token_index);
     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());
       }
     }
   }
   bpt->Enable();
   return bpt;
@@ skipping 214 matching lines @@
 
 
 void Debugger::SetBreakpointHandler(BreakpointHandler* handler) {
   bp_handler_ = handler;
   if (bp_handler_ == NULL) {
     bp_handler_ = &DefaultBreakpointHandler;
   }
 }
 
 
+void Debugger::SetEventHandler(EventHandler* handler) {
+  event_handler_ = handler;
+}
+
+
 void Debugger::BreakpointCallback() {
   ASSERT(initialized_);
 
   if (ignore_breakpoints_) {
     return;
   }
   DartFrameIterator iterator;
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL && frame->IsDartFrame());
   CodeBreakpoint* bpt = GetCodeBreakpoint(frame->pc());
   ASSERT(bpt != NULL);
   if (verbose) {
     OS::Print(">>> %s breakpoint at %s:%d (Address %p)\n",
               bpt->IsInternal() ? "hit internal" : "hit user",
               bpt ? String::Handle(bpt->SourceUrl()).ToCString() : "?",
               bpt ? bpt->LineNumber() : 0,
               frame->pc());
   }
+
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   while (frame != NULL) {
     ASSERT(frame->IsValid());
     ASSERT(frame->IsDartFrame());
     ActivationFrame* activation =
         new ActivationFrame(frame->pc(), frame->fp(), frame->sp());
     stack_trace->AddActivation(activation);
     frame = iterator.NextFrame();
   }
 
   resume_action_ = kContinue;
   if (bp_handler_ != NULL) {
     SourceBreakpoint* src_bpt = bpt->src_bpt();
+    ASSERT(stack_trace_ == NULL);
+    stack_trace_ = stack_trace;
     (*bp_handler_)(src_bpt, stack_trace);
+    stack_trace_ = NULL;
   }
 
   if (resume_action_ == kContinue) {
     RemoveInternalBreakpoints();
   } else if (resume_action_ == kStepOver) {
     Function& func = Function::Handle(bpt->function());
     if (bpt->breakpoint_kind_ == PcDescriptors::kReturn) {
       // If we are at the function return, do a StepOut action.
       if (stack_trace->Length() > 1) {
         ActivationFrame* caller = stack_trace->ActivationFrameAt(1);
@@ skipping 86 matching lines @@
         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_index());
         if (cbpt != NULL) {
           cbpt->set_src_bpt(bpt);
+          SignalBpResolved(bpt);
         }
       }
       bpt->Enable();  // Enables the code breakpoint as well.
     }
     bpt = bpt->next();
   }
 }
 
 
 CodeBreakpoint* Debugger::GetCodeBreakpoint(uword breakpoint_address) {
   CodeBreakpoint* bpt = code_breakpoints_;
   while (bpt != NULL) {
     if (bpt->pc() == breakpoint_address) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
 
 // Remove and delete the source breakpoint bpt and its associated
 // code breakpoints.
-void Debugger::RemoveBreakpoint(SourceBreakpoint* bpt) {
+void Debugger::RemoveBreakpoint(intptr_t bp_id) {
   ASSERT(src_breakpoints_ != NULL);
   SourceBreakpoint* prev_bpt = NULL;
   SourceBreakpoint* curr_bpt = src_breakpoints_;
   while (curr_bpt != NULL) {
-    if (bpt == curr_bpt) {
+    if (curr_bpt->id() == bp_id) {
       if (prev_bpt == NULL) {
         src_breakpoints_ = src_breakpoints_->next();
       } else {
         prev_bpt->set_next(curr_bpt->next());
       }
       // Remove the code breakpoints associated with the source breakpoint.
-      RemoveCodeBreakpoints(bpt);
-      delete bpt;
+      RemoveCodeBreakpoints(curr_bpt);
+      delete curr_bpt;
       return;
     }
     prev_bpt = curr_bpt;
     curr_bpt = curr_bpt->next();
   }
   // bpt is not a registered breakpoint, nothing to do.
 }
 
 
 // Remove and delete the code breakpoints that are associated with given
@@ skipping 34 matching lines @@
     if ((bpt->function() == func.raw()) &&
         (bpt->token_index() == token_index)) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
 
+SourceBreakpoint* Debugger::GetBreakpointById(intptr_t id) {
+  SourceBreakpoint* bpt = src_breakpoints_;
+  while (bpt != NULL) {
+    if (bpt->id() == id) {
+      return bpt;
+    }
+    bpt = bpt->next();
+  }
+  return NULL;
+}
+
+
 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