Keep track of current "pause" event in the debugger.

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 170 matching lines @@
 void Debugger::SignalIsolateEvent(EventType type) {
   if (event_handler_ != NULL) {
     Debugger* debugger = Isolate::Current()->debugger();
     ASSERT(debugger != NULL);
     DebuggerEvent event(type);
     event.isolate_id = debugger->GetIsolateId();
     ASSERT(event.isolate_id != ILLEGAL_ISOLATE_ID);
     if (type == kIsolateInterrupted) {
       DebuggerStackTrace* stack_trace = debugger->CollectStackTrace();
       ASSERT(stack_trace->Length() > 0);
       ASSERT(debugger->stack_trace_ == NULL);

[turnidge, 2013/12/18 21:27:58]

in_event_handler_ was missing here before.  I think this was a bug.

-      ASSERT(debugger->obj_cache_ == NULL);
-      debugger->obj_cache_ = new RemoteObjectCache(64);
       debugger->stack_trace_ = stack_trace;
-      (*event_handler_)(&event);
+      debugger->Pause(&event);
       debugger->stack_trace_ = NULL;
-      debugger->obj_cache_ = NULL;  // Remote object cache is zone allocated.
       // TODO(asiva): Need some work here to be able to single step after
       // an interrupt.
     } else {
       (*event_handler_)(&event);
     }
   }
 }
 
 
 const char* Debugger::QualifiedFunctionName(const Function& func) {
@@ skipping 640 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),
-      stack_trace_(NULL),
-      obj_cache_(NULL),
       src_breakpoints_(NULL),
       code_breakpoints_(NULL),
       resume_action_(kContinue),
       ignore_breakpoints_(false),
-      in_event_notification_(false),
+      pause_event_(NULL),
+      obj_cache_(NULL),
+      stack_trace_(NULL),
       exc_pause_info_(kNoPauseOnExceptions) {
 }
 
 
 Debugger::~Debugger() {
   isolate_id_ = ILLEGAL_ISOLATE_ID;
-  ASSERT(!in_event_notification_);
+  ASSERT(!IsPaused());
   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_;
@@ skipping 381 matching lines @@
   return false;
 }
 
 
 void Debugger::SignalExceptionThrown(const Instance& exc) {
   // We ignore this exception event when the VM is executing code invoked
   // by the debugger to evaluate variables values, when we see a nested
   // breakpoint or exception event, or if the debugger is not
   // interested in exception events.
   if (ignore_breakpoints_ ||
-      in_event_notification_ ||
+      IsPaused() ||
       (event_handler_ == NULL) ||
       (exc_pause_info_ == kNoPauseOnExceptions)) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   if (!ShouldPauseOnException(stack_trace, exc)) {
     return;
   }
+  DebuggerEvent event(kExceptionThrown);
+  event.exception = &exc;
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
-  ASSERT(obj_cache_ == NULL);
-  in_event_notification_ = true;
-  obj_cache_ = new RemoteObjectCache(64);
-  DebuggerEvent event(kExceptionThrown);
-  event.exception = &exc;
-  (*event_handler_)(&event);
-  in_event_notification_ = false;
+  Pause(&event);
   stack_trace_ = NULL;
-  obj_cache_ = NULL;  // Remote object cache is zone allocated.
 }
 
 
 // Given a function and a token position range, return the best fit
 // token position to set a breakpoint.
 // If multiple possible breakpoint positions are within the given range,
 // the one with the lowest machine code address is picked.
 // If no possible breakpoint location exists in the given range, the closest
 // token position after the range is returned.
 intptr_t Debugger::ResolveBreakpointPos(const Function& func,
@@ skipping 449 matching lines @@
     cbpt = cbpt->next();
   }
 }
 
 
 void Debugger::SetEventHandler(EventHandler* handler) {
   event_handler_ = handler;
 }
 
 
+void Debugger::Pause(DebuggerEvent* event) {
+  ASSERT(!IsPaused());  // No recursive pausing.
+  ASSERT(obj_cache_ == NULL);
+
+  pause_event_ = event;
+  obj_cache_ = new RemoteObjectCache(64);
+
+  (*event_handler_)(event);
+
+  pause_event_ = NULL;
+  obj_cache_ = NULL;    // Zone allocated
+}
+
+
 bool Debugger::IsDebuggable(const Function& func) {
   RawFunction::Kind fkind = func.kind();
   if ((fkind == RawFunction::kImplicitGetter) ||
       (fkind == RawFunction::kImplicitSetter) ||
       (fkind == RawFunction::kImplicitStaticFinalGetter) ||
       (fkind == RawFunction::kStaticInitializer) ||
       (fkind == RawFunction::kMethodExtractor) ||
       (fkind == RawFunction::kNoSuchMethodDispatcher) ||
       (fkind == RawFunction::kInvokeFieldDispatcher)) {
     return false;
   }
   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) {
   resume_action_ = kContinue;
   isolate_->set_single_step(false);
-  ASSERT(!in_event_notification_);
+  ASSERT(!IsPaused());
   ASSERT(obj_cache_ == NULL);
-  in_event_notification_ = true;
-  obj_cache_ = new RemoteObjectCache(64);
   DebuggerEvent event(kBreakpointReached);
   event.top_frame = top_frame;
   event.breakpoint = bpt;
-  (*event_handler_)(&event);
-  in_event_notification_ = false;
-  obj_cache_ = NULL;  // Remote object cache is zone allocated.
+  Pause(&event);
 }
 
 
 void Debugger::SingleStepCallback() {
   ASSERT(resume_action_ == kSingleStep);
   ASSERT(isolate_->single_step());
   // We can't get here unless the debugger event handler enabled
   // single stepping.
   ASSERT(event_handler_ != NULL);
   // Don't pause recursively.
-  if (in_event_notification_) return;
+  if (IsPaused()) return;
 
   // Check whether we are in a Dart function that the user is
   // interested in.
   ActivationFrame* frame = TopDartFrame();
   ASSERT(frame != NULL);
   const Function& func = frame->function();
   if (!IsDebuggable(func)) {
     return;
   }
   if (frame->TokenPos() == Scanner::kDummyTokenIndex) {
     return;
   }
 
   if (FLAG_verbose_debug) {
     OS::Print(">>> single step break at %s:%" Pd " (func %s token %" Pd ")\n",
               String::Handle(frame->SourceUrl()).ToCString(),
               frame->LineNumber(),
               String::Handle(frame->QualifiedFunctionName()).ToCString(),
               frame->TokenPos());
   }
 
+  ASSERT(stack_trace_ == NULL);
   stack_trace_ = CollectStackTrace();
   SignalPausedEvent(frame, NULL);
 
   RemoveInternalBreakpoints();
   if (resume_action_ == kStepOver) {
     InstrumentForStepping(func);
   } else if (resume_action_ == kStepOut) {
     if (stack_trace_->Length() > 1) {
       ActivationFrame* caller_frame = stack_trace_->FrameAt(1);
       InstrumentForStepping(caller_frame->function());
     }
   }
   stack_trace_ = NULL;
 }
 
 
 void Debugger::SignalBpReached() {
   // We ignore this breakpoint when the VM is executing code invoked
   // by the debugger to evaluate variables values, or when we see a nested
   // breakpoint or exception event.
-  if (ignore_breakpoints_ || in_event_notification_) {
+  if (ignore_breakpoints_ || IsPaused()) {
     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);
 
   bool report_bp = true;
   if (bpt->IsInternal() && !IsDebuggable(top_frame->function())) {
     report_bp = false;
   }
   if (FLAG_verbose_debug) {
     OS::Print(">>> %s %s breakpoint at %s:%" Pd " "
               "(token %" Pd ") (address %#" Px ")\n",
               report_bp ? "hit" : "ignore",
               bpt->IsInternal() ? "internal" : "user",
               String::Handle(bpt->SourceUrl()).ToCString(),
               bpt->LineNumber(),
               bpt->token_pos(),
               top_frame->pc());
   }
 
   if (report_bp && (event_handler_ != NULL)) {
+    ASSERT(stack_trace_ == NULL);
     stack_trace_ = stack_trace;
     SignalPausedEvent(top_frame, bpt->src_bpt_);
     stack_trace_ = NULL;
   }
 
   Function& func_to_instrument = Function::Handle();
   if (resume_action_ == kStepOver) {
     if (bpt->breakpoint_kind_ == PcDescriptors::kReturn) {
       // Step over return is converted into a single step so we break at
       // the caller.
@@ skipping 253 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart