Handle stepping requests after isolate interrupt event

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 169 matching lines @@
       deopt_frame_offset_(deopt_frame_offset),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {
 }
 
 
 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();
+    event.isolate_id = isolate_id_;
     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);
-      debugger->stack_trace_ = stack_trace;
-      debugger->Pause(&event);
-      debugger->stack_trace_ = NULL;
-      // TODO(asiva): Need some work here to be able to single step after
-      // an interrupt.
+      DebuggerStackTrace* trace = CollectStackTrace();
+      ASSERT(trace->Length() > 0);
+      ASSERT(stack_trace_ == NULL);
+      stack_trace_ = trace;
+      resume_action_ = kContinue;
+      Pause(&event);
+      HandleSteppingRequest(trace);
+      stack_trace_ = NULL;
     } else {
       (*event_handler_)(&event);
     }
   }
 }
 
 
+void Debugger::SignalIsolateInterrupted() {
+  if (event_handler_ != NULL) {
+    Debugger* debugger = Isolate::Current()->debugger();
+    ASSERT(debugger != NULL);
+    debugger->SignalIsolateEvent(kIsolateInterrupted);
+  }
+}
+
+
 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 1698 matching lines @@
   pause_event_ = event;
   obj_cache_ = new RemoteObjectCache(64);
 
   (*event_handler_)(event);
 
   pause_event_ = NULL;
   obj_cache_ = NULL;    // Zone allocated
 }
 
 
+void Debugger::HandleSteppingRequest(DebuggerStackTrace* stack_trace) {
+  stepping_fp_ = 0;
+  if (resume_action_ == kSingleStep) {
+    isolate_->set_single_step(true);
+  } else if (resume_action_ == kStepOver) {
+    isolate_->set_single_step(true);
+    ASSERT(stack_trace->Length() > 0);
+    stepping_fp_ = stack_trace->FrameAt(0)->fp();
+  } else if (resume_action_ == kStepOut) {
+    isolate_->set_single_step(true);
+    // Find topmost caller that is debuggable.
+    for (intptr_t i = 1; i < stack_trace->Length(); i++) {
+      ActivationFrame* frame = stack_trace->FrameAt(i);
+      if (frame->IsDebuggable()) {
+        stepping_fp_ = frame->fp();
+        break;
+      }
+    }
+  }
+}
+
+
 bool Debugger::IsDebuggable(const Function& func) {
   if (!IsDebuggableFunctionKind(func)) {
     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;
   stepping_fp_ = 0;
   isolate_->set_single_step(false);
   ASSERT(!IsPaused());
   ASSERT(obj_cache_ == NULL);
   DebuggerEvent event(kBreakpointReached);
   event.top_frame = top_frame;
   event.breakpoint = bpt;
   Pause(&event);
 }
 
 
-static uword DebuggableCallerFP(DebuggerStackTrace* stack_trace) {
-  for (intptr_t i = 1; i < stack_trace->Length(); i++) {
-    ActivationFrame* frame = stack_trace->FrameAt(i);
-    if (frame->IsDebuggable()) {
-      return frame->fp();
-    }
-  }
-  return 0;
-}
-
-
 void Debugger::DebuggerStepCallback() {
   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 (IsPaused()) return;
 
   // Check whether we are in a Dart function that the user is
   // interested in. If we saved the frame pointer of a stack frame
@@ skipping 27 matching lines @@
     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);
-
-  if (resume_action_ == kSingleStep) {
-    isolate_->set_single_step(true);
-    stepping_fp_ = 0;
-  } else if (resume_action_ == kStepOver) {
-    isolate_->set_single_step(true);
-    stepping_fp_ = frame->fp();
-  } else if (resume_action_ == kStepOut) {
-    isolate_->set_single_step(true);
-    stepping_fp_ = DebuggableCallerFP(stack_trace_);
-  }
+  HandleSteppingRequest(stack_trace_);
   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_ || IsPaused() || (event_handler_ == NULL)) {
     return;
@@ skipping 11 matching lines @@
               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_);
+  HandleSteppingRequest(stack_trace_);
   stack_trace_ = NULL;
-
-  if (resume_action_ == kSingleStep) {
-    isolate_->set_single_step(true);
-    stepping_fp_ = 0;
-  } else if (resume_action_ == kStepOver) {
-    isolate_->set_single_step(true);
-    stepping_fp_ = top_frame->fp();
-  } else if (resume_action_ == kStepOut) {
-    isolate_->set_single_step(true);
-    stepping_fp_ = DebuggableCallerFP(stack_trace);
-  }
   if (bpt->IsInternal()) {
     RemoveInternalBreakpoints();
   }
 }
 
 
 void Debugger::Initialize(Isolate* isolate) {
   if (initialized_) {
     return;
   }
@@ skipping 240 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart