Implement support for single stepping out of an async function.

runtime/vm/debugger.h

 // 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.
 
 #ifndef RUNTIME_VM_DEBUGGER_H_
 #define RUNTIME_VM_DEBUGGER_H_
 
 #include "include/dart_tools_api.h"
 
 #include "vm/object.h"
@@ skipping 343 matching lines @@
   void GetVarDescriptors();
   void GetDescIndices();
 
   RawObject* GetAsyncContextVariable(const String& name);
   RawObject* GetAsyncStreamControllerStreamAwaiter(const Object& stream);
   RawObject* GetAsyncStreamControllerStream();
   RawObject* GetAsyncCompleterAwaiter(const Object& completer);
   RawObject* GetAsyncCompleter();
   void ExtractTokenPositionFromAsyncClosure();
 
+  bool IsAsyncMachinery() const;
+
   static const char* KindToCString(Kind kind) {
     switch (kind) {
       case kRegular:
         return "Regular";
       case kAsyncCausal:
         return "AsyncCausal";
       case kAsyncSuspensionMarker:
         return "AsyncSuspensionMarker";
       case kAsyncActivation:
         return "AsyncActivation";
@@ skipping 334 matching lines @@
 
   // Can we rewind to the indicated frame?
   bool CanRewindFrame(intptr_t frame_index, const char** error) const;
 
   void RewindToFrame(intptr_t frame_index);
   void RewindToUnoptimizedFrame(StackFrame* frame, const Code& code);
   void RewindToOptimizedFrame(StackFrame* frame,
                               const Code& code,
                               intptr_t post_deopt_frame_index);
 
+  void ResetSteppingFramePointers();
+  bool SteppedForSyntheticAsyncBreakpoint() const;
+  void CleanupSyntheticAsyncBreakpoint();
+  void RememberTopFrameAwaiter();
+  void SetAsyncSteppingFramePointer();
+
   Isolate* isolate_;
   Dart_Port isolate_id_;  // A unique ID for the isolate in the debugger.
   bool initialized_;
 
   // ID number generator.
   intptr_t next_id_;
 
   BreakpointLocation* latent_locations_;
   BreakpointLocation* breakpoint_locations_;
   CodeBreakpoint* code_breakpoints_;
@@ skipping 19 matching lines @@
 
   // Current stack trace. Valid only while IsPaused().
   DebuggerStackTrace* stack_trace_;
   DebuggerStackTrace* async_causal_stack_trace_;
   DebuggerStackTrace* awaiter_stack_trace_;
 
   // When stepping through code, only pause the program if the top
   // frame corresponds to this fp value, or if the top frame is
   // lower on the stack.
   uword stepping_fp_;
+  // Used to track the current async/async* function.
+  uword async_stepping_fp_;
+  RawObject* top_frame_awaiter_;
 
   // If we step while at a breakpoint, we would hit the same pc twice.
   // We use this field to let us skip the next single-step after a
   // breakpoint.
   bool skip_next_step_;
 
   bool needs_breakpoint_cleanup_;
 
   // We keep this breakpoint alive until after the debugger does the step over
   // async continuation machinery so that we can report that we've stopped
   // at the breakpoint.
   Breakpoint* synthetic_async_breakpoint_;
 
   Dart_ExceptionPauseInfo exc_pause_info_;
 
   static EventHandler* event_handler_;
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DEBUGGER_H_