Implement support for single stepping out of an async function.

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 "platform/address_sanitizer.h"
 
@@ skipping 891 matching lines @@
       if (iter.TryIndex() != CatchClauseNode::kInvalidTryIndex) {
         if ((try_index_ == -1) || (iter.TryIndex() < try_index_)) {
           try_index_ = iter.TryIndex();
         }
       }
     }
   }
 }
 
 
+bool ActivationFrame::IsAsyncMachinery() const {
+  Isolate* isolate = Isolate::Current();
+  if (function_.raw() == isolate->object_store()->complete_on_async_return()) {
+    // We are completing an async function's completer.
+    return true;
+  }
+  if (function_.Owner() ==
+      isolate->object_store()->async_star_stream_controller()) {
+    // We are inside the async* stream controller code.
+    return true;
+  }
+  return false;
+}
+
+
 // Get the saved current context of this activation.
 const Context& ActivationFrame::GetSavedCurrentContext() {
   if (!ctx_.IsNull()) return ctx_;
   GetVarDescriptors();
   intptr_t var_desc_len = var_descriptors_.Length();
   for (intptr_t i = 0; i < var_desc_len; i++) {
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(i, &var_info);
     const int8_t kind = var_info.kind();
     if (kind == RawLocalVarDescriptors::kSavedCurrentContext) {
@@ skipping 646 matching lines @@
       resume_action_(kContinue),
       resume_frame_index_(-1),
       post_deopt_frame_index_(-1),
       ignore_breakpoints_(false),
       pause_event_(NULL),
       obj_cache_(NULL),
       stack_trace_(NULL),
       async_causal_stack_trace_(NULL),
       awaiter_stack_trace_(NULL),
       stepping_fp_(0),
+      async_stepping_fp_(0),
+      top_frame_awaiter_(Object::null()),
       skip_next_step_(false),
       needs_breakpoint_cleanup_(false),
       synthetic_async_breakpoint_(NULL),
       exc_pause_info_(kNoPauseOnExceptions) {}
 
 
 Debugger::~Debugger() {
   isolate_id_ = ILLEGAL_ISOLATE_ID;
   ASSERT(!IsPaused());
   ASSERT(latent_locations_ == NULL);
@@ skipping 1542 matching lines @@
   bpt = latent_locations_;
   while (bpt != NULL) {
     bpt->VisitObjectPointers(visitor);
     bpt = bpt->next();
   }
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     cbpt->VisitObjectPointers(visitor);
     cbpt = cbpt->next();
   }
+  visitor->VisitPointer(reinterpret_cast<RawObject**>(&top_frame_awaiter_));
 }
 
 
 // static
 void Debugger::SetEventHandler(EventHandler* handler) {
   event_handler_ = handler;
 }
 
 
 void Debugger::Pause(ServiceEvent* event) {
@@ skipping 43 matching lines @@
 
   if (needs_breakpoint_cleanup_) {
     RemoveUnlinkedCodeBreakpoints();
   }
   pause_event_ = NULL;
   obj_cache_ = NULL;  // Zone allocated
 }
 
 
 void Debugger::EnterSingleStepMode() {
-  stepping_fp_ = 0;
+  ResetSteppingFramePointers();
   DeoptimizeWorld();
   isolate_->set_single_step(true);
 }
 
 
+void Debugger::ResetSteppingFramePointers() {
+  stepping_fp_ = 0;
+  async_stepping_fp_ = 0;
+}
+
+
+bool Debugger::SteppedForSyntheticAsyncBreakpoint() const {
+  return synthetic_async_breakpoint_ != NULL;
+}
+
+
+void Debugger::CleanupSyntheticAsyncBreakpoint() {
+  if (synthetic_async_breakpoint_ != NULL) {
+    RemoveBreakpoint(synthetic_async_breakpoint_->id());
+    synthetic_async_breakpoint_ = NULL;
+  }
+}
+
+
+void Debugger::RememberTopFrameAwaiter() {
+  if (!FLAG_async_debugger_stepping) {
+    return;
+  }
+  if (stack_trace_->Length() > 0) {
+    top_frame_awaiter_ = stack_trace_->FrameAt(0)->GetAsyncAwaiter();
+  } else {
+    top_frame_awaiter_ = Object::null();
+  }
+}
+
+
+void Debugger::SetAsyncSteppingFramePointer() {
+  if (!FLAG_async_debugger_stepping) {
+    return;
+  }
+  if (stack_trace_->FrameAt(0)->function().IsAsyncClosure() ||
+      stack_trace_->FrameAt(0)->function().IsAsyncGenClosure()) {
+    async_stepping_fp_ = stack_trace_->FrameAt(0)->fp();
+  } else {
+    async_stepping_fp_ = 0;
+  }
+}
+
+
 void Debugger::HandleSteppingRequest(DebuggerStackTrace* stack_trace,
                                      bool skip_next_step) {
-  stepping_fp_ = 0;
+  ResetSteppingFramePointers();
+  RememberTopFrameAwaiter();
   if (resume_action_ == kStepInto) {
     // When single stepping, we need to deoptimize because we might be
     // stepping into optimized code.  This happens in particular if
     // the isolate has been interrupted, but can happen in other cases
     // as well.  We need to deoptimize the world in case we are about
     // to call an optimized function.
     DeoptimizeWorld();
     isolate_->set_single_step(true);
     skip_next_step_ = skip_next_step;
+    SetAsyncSteppingFramePointer();
     if (FLAG_verbose_debug) {
       OS::Print("HandleSteppingRequest- kStepInto\n");
     }
   } else if (resume_action_ == kStepOver) {
     DeoptimizeWorld();
     isolate_->set_single_step(true);
     skip_next_step_ = skip_next_step;
     ASSERT(stack_trace->Length() > 0);
     stepping_fp_ = stack_trace->FrameAt(0)->fp();
+    SetAsyncSteppingFramePointer();
     if (FLAG_verbose_debug) {
       OS::Print("HandleSteppingRequest- kStepOver %" Px "\n", stepping_fp_);
     }
   } else if (resume_action_ == kStepOut) {
     if (FLAG_async_debugger_stepping) {
       if (stack_trace->FrameAt(0)->function().IsAsyncClosure() ||
           stack_trace->FrameAt(0)->function().IsAsyncGenClosure()) {
         // Request to step out of an async/async* closure.
         const Object& async_op =
             Object::Handle(stack_trace->FrameAt(0)->GetAsyncAwaiter());
@@ skipping 286 matching lines @@
     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, Breakpoint* bpt) {
   resume_action_ = kContinue;
-  stepping_fp_ = 0;
+  ResetSteppingFramePointers();
   isolate_->set_single_step(false);
   ASSERT(!IsPaused());
   ASSERT(obj_cache_ == NULL);
   if ((bpt != NULL) && bpt->IsSingleShot()) {
     RemoveBreakpoint(bpt->id());
     bpt = NULL;
   }
 
   ServiceEvent event(isolate_, ServiceEvent::kPauseBreakpoint);
   event.set_top_frame(top_frame);
@@ skipping 45 matching lines @@
   }
 
   // Check whether we are in a Dart function that the user is
   // 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);
 
+  if (FLAG_async_debugger_stepping) {
+    if ((async_stepping_fp_ != 0) && (top_frame_awaiter_ != Object::null())) {
+      // Check if the user has single stepped out of an async function with
+      // an awaiter. The first check handles the case of calling into the
+      // async machinery as we finish the async function. The second check
+      // handles the case of returning from an async function.
+      const bool exited_async_function =
+          (IsCalleeFrameOf(async_stepping_fp_, frame->fp()) &&
+           frame->IsAsyncMachinery()) ||
+          IsCalleeFrameOf(frame->fp(), async_stepping_fp_);
+      if (exited_async_function) {
+        // Step to the top frame awaiter.
+        const Object& async_op = Object::Handle(top_frame_awaiter_);
+        top_frame_awaiter_ = Object::null();
+        AsyncStepInto(Closure::Cast(async_op));
+        return Error::null();
+      }
+    }
+  }
+
   if (stepping_fp_ != 0) {
     // There is an "interesting frame" set. Only pause at appropriate
     // locations in this frame.
     if (IsCalleeFrameOf(stepping_fp_, frame->fp())) {
       // We are in a callee of the frame we're interested in.
       // Ignore this stepping break.
       return Error::null();
     } else if (IsCalleeFrameOf(frame->fp(), stepping_fp_)) {
       // We returned from the "interesting frame", there can be no more
       // stepping breaks for it. Pause at the next appropriate location
       // and let the user set the "interesting" frame again.
-      stepping_fp_ = 0;
+      ResetSteppingFramePointers();
     }
   }
 
   if (!frame->IsDebuggable()) {
     return Error::null();
   }
   if (!frame->TokenPos().IsDebugPause()) {
     return Error::null();
   }
 
   // If there is an active breakpoint at this pc, then we should have
   // already bailed out of this function in the skip_next_step_ test
   // above.
   ASSERT(!HasActiveBreakpoint(frame->pc()));
 
   if (FLAG_verbose_debug) {
     OS::Print(">>> single step break at %s:%" Pd " (func %s token %s)\n",
               String::Handle(frame->SourceUrl()).ToCString(),
               frame->LineNumber(),
               String::Handle(frame->QualifiedFunctionName()).ToCString(),
               frame->TokenPos().ToCString());
   }
 
 
   CacheStackTraces(CollectStackTrace(), CollectAsyncCausalStackTrace(),
                    CollectAwaiterReturnStackTrace());
-  // If this step callback is part of stepping over an await statement,
-  // we saved the synthetic async breakpoint in PauseBreakpoint. We report
-  // that we are paused at that breakpoint and then delete it after continuing.
-  SignalPausedEvent(frame, synthetic_async_breakpoint_);
-  if (synthetic_async_breakpoint_ != NULL) {
-    RemoveBreakpoint(synthetic_async_breakpoint_->id());
-    synthetic_async_breakpoint_ = NULL;
+  if (SteppedForSyntheticAsyncBreakpoint()) {
+    CleanupSyntheticAsyncBreakpoint();
   }
+  SignalPausedEvent(frame, NULL);
   HandleSteppingRequest(stack_trace_);
   ClearCachedStackTraces();
 
   // If any error occurred while in the debug message loop, return it here.
   const Error& error = Error::Handle(Thread::Current()->sticky_error());
   Thread::Current()->clear_sticky_error();
   return error.raw();
 }
 
 
@@ skipping 572 matching lines @@
 
 void Debugger::AsyncStepInto(const Closure& async_op) {
   SetBreakpointAtActivation(async_op, true);
   Continue();
 }
 
 
 void Debugger::Continue() {
   SetResumeAction(kContinue);
   stepping_fp_ = 0;
+  async_stepping_fp_ = 0;
   isolate_->set_single_step(false);
 }
 
 
 BreakpointLocation* Debugger::GetLatentBreakpoint(const String& url,
                                                   intptr_t line,
                                                   intptr_t column) {
   BreakpointLocation* bpt = latent_locations_;
   String& bpt_url = String::Handle();
   while (bpt != NULL) {
@@ skipping 21 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart