Handle all debugger stepping with the isolate single step flag

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 815 matching lines @@
       isolate_id_(ILLEGAL_ISOLATE_ID),
       initialized_(false),
       next_id_(1),
       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(src_breakpoints_ == NULL);
   ASSERT(code_breakpoints_ == NULL);
   ASSERT(stack_trace_ == NULL);
@@ skipping 22 matching lines @@
                         const Library& library,
                         const String& fname) {
   ASSERT(!library.IsNull());
   const Object& object = Object::Handle(library.LookupObject(fname));
   if (!object.IsNull() && object.IsFunction()) {
     return Function::Cast(object).raw();
   }
   return Function::null();
 }
 
+
 void Debugger::SetSingleStep() {
-  isolate_->set_single_step(true);
   resume_action_ = kSingleStep;
 }
 
+
 void Debugger::SetStepOver() {
-  isolate_->set_single_step(false);
   resume_action_ = kStepOver;
 }
 
+
 void Debugger::SetStepOut() {
-  isolate_->set_single_step(false);
   resume_action_ = kStepOut;
 }
 
 RawFunction* Debugger::ResolveFunction(const Library& library,
                                        const String& class_name,
                                        const String& function_name) {
   ASSERT(!library.IsNull());
   ASSERT(!class_name.IsNull());
   ASSERT(!function_name.IsNull());
   if (class_name.Length() == 0) {
@@ skipping 60 matching lines @@
           if (function.HasOptimizedCode()) {
             function.SwitchToUnoptimizedCode();
           }
         }
       }
     }
   }
 }
 
 
-void Debugger::InstrumentForStepping(const Function& target_function) {
+void Debugger::SetInternalBreakpoints(const Function& target_function) {
   if (target_function.is_native()) {
     // Can't instrument native functions.
     return;
   }
   if (!target_function.HasCode()) {
     Compiler::CompileFunction(target_function);
     // If there were any errors, ignore them silently and return without
     // adding breakpoints to target.
     if (!target_function.HasCode()) {
       return;
@@ skipping 577 matching lines @@
       } else {
         cbpt->Disable();
       }
     }
     cbpt = cbpt->next();
   }
 }
 
 
 void Debugger::OneTimeBreakAtEntry(const Function& target_function) {
-  InstrumentForStepping(target_function);
+  SetInternalBreakpoints(target_function);
   if (target_function.HasImplicitClosureFunction()) {
     const Function& closure_func =
         Function::Handle(target_function.ImplicitClosureFunction());
-    InstrumentForStepping(closure_func);
+    SetInternalBreakpoints(closure_func);
   }
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpointAtEntry(
       const Function& target_function) {
   ASSERT(!target_function.IsNull());
   const Script& script = Script::Handle(target_function.script());
   return SetBreakpoint(script, target_function.token_pos());
 }
@@ skipping 295 matching lines @@
   }
   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);
 }
 
 
-void Debugger::SingleStepCallback() {
-  ASSERT(resume_action_ == kSingleStep);
+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.
+  // interested in. If we saved the frame pointer of a stack frame
+  // the user is interested in, we ignore the single step if we are
+  // in a callee of that frame. Note that we assume that the stack
+  // grows towards lower addresses.
   ActivationFrame* frame = TopDartFrame();
   ASSERT(frame != NULL);
-  const Function& func = frame->function();
-  if (!IsDebuggable(func)) {
+  if ((stepping_fp_ != 0) && (stepping_fp_ > frame->fp())) {
+    return;
+  }
+  // If an "interesting" frame is set, we are either in that frame
+  // or the program has returned from that frame. Let the user set
+  // the "interesting" frame again next time we pause.
+  stepping_fp_ = 0;
+
+  if (!frame->IsDebuggable()) {
     return;
   }
   if (frame->TokenPos() == Scanner::kNoSourcePos) {
     return;
   }
+
   // Don't pause for a single step if there is a breakpoint set
   // at this location.
   if (HasActiveBreakpoint(frame->pc())) {
     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);
+  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) {
-    if (stack_trace_->Length() > 1) {
-      ActivationFrame* caller_frame = stack_trace_->FrameAt(1);
-      InstrumentForStepping(caller_frame->function());
-    }
+    isolate_->set_single_step(true);
+    stepping_fp_ = DebuggableCallerFP(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()) {
+  if (ignore_breakpoints_ || IsPaused() || (event_handler_ == NULL)) {
     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 " "
+    OS::Print(">>> hit %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;
+  ASSERT(stack_trace_ == NULL);
+  stack_trace_ = stack_trace;
+  SignalPausedEvent(top_frame, bpt->src_bpt_);
+  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);
   }
-
-  Function& func_to_instrument = Function::Handle();
-  if ((resume_action_ == kStepOver) &&
-      (bpt->breakpoint_kind_ == PcDescriptors::kReturn)) {
-    resume_action_ = kStepOut;
-  }
-  if (resume_action_ == kStepOver) {
-    ASSERT(bpt->breakpoint_kind_ != PcDescriptors::kReturn);
-    func_to_instrument = bpt->function();
-  } else if (resume_action_ == kStepOut) {
-    if (stack_trace->Length() > 1) {
-      ActivationFrame* caller_frame = stack_trace->FrameAt(1);
-      func_to_instrument = caller_frame->function().raw();
-    }
-  } else {
-    ASSERT((resume_action_ == kContinue) || (resume_action_ == kSingleStep));
-    // Nothing to do here. Any potential instrumentation will be removed
-    // below. Single stepping is handled by the single step callback.
-  }
-
-  if (func_to_instrument.IsNull() ||
-      (func_to_instrument.raw() != bpt->function())) {
-    RemoveInternalBreakpoints();  // *bpt is now invalid.
-  }
-  if (!func_to_instrument.IsNull()) {
-    InstrumentForStepping(func_to_instrument);
+  if (bpt->IsInternal()) {
+    RemoveInternalBreakpoints();
   }
 }
 
 
 void Debugger::Initialize(Isolate* isolate) {
   if (initialized_) {
     return;
   }
   isolate_ = isolate;
   // Use the isolate's control port as the isolate_id for debugging.
@@ skipping 238 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart