Sane asynchronous debugging and stack traces

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"
 #include "vm/port.h"
 #include "vm/service_event.h"
 
+DECLARE_FLAG(bool, verbose_debug);
+
+// 'Trace Debugger' TD_Print.
+#if defined(_MSC_VER)
+#define TD_Print(format, ...)                                                  \
+  if (FLAG_verbose_debug) Log::Current()->Print(format, __VA_ARGS__)
+#else
+#define TD_Print(format, ...)                                                  \
+  if (FLAG_verbose_debug) Log::Current()->Print(format, ##__VA_ARGS__)
+#endif
+
 namespace dart {
 
 class CodeBreakpoint;
 class Isolate;
 class JSONArray;
 class JSONStream;
 class ObjectPointerVisitor;
 class RemoteObjectCache;
 class BreakpointLocation;
 class StackFrame;
@@ skipping 173 matching lines @@
   RawScript* SourceCode();
   RawString* SourceUrl();
   intptr_t LineNumber();
 
   void Enable();
   void Disable();
   bool IsEnabled() const { return is_enabled_; }
 
   RawCode* OrigStubAddress() const;
 
+  const char* ToCString();
+
  private:
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   BreakpointLocation* bpt_location() const { return bpt_location_; }
   void set_bpt_location(BreakpointLocation* value) { bpt_location_ = value; }
 
   void set_next(CodeBreakpoint* value) { next_ = value; }
   CodeBreakpoint* next() const { return this->next_; }
 
   void PatchCode();
@@ skipping 21 matching lines @@
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(CodeBreakpoint);
 };
 
 
 // ActivationFrame represents one dart function activation frame
 // on the call stack.
 class ActivationFrame : public ZoneAllocated {
  public:
+  enum Kind {
+    kRegular,
+    kAsyncLive,
+    kAsyncSuspensionMarker,
+    kAsyncHistorical,
+  };
+
   ActivationFrame(uword pc,
                   uword fp,
                   uword sp,
                   const Code& code,
                   const Array& deopt_frame,
-                  intptr_t deopt_frame_offset);
+                  intptr_t deopt_frame_offset,
+                  Kind kind = kRegular);
+
+  ActivationFrame(uword pc, const Code& code);
+
+  explicit ActivationFrame(Kind kind);
+
+  explicit ActivationFrame(const Closure& async_activation);
 
   uword pc() const { return pc_; }
   uword fp() const { return fp_; }
   uword sp() const { return sp_; }
   const Function& function() const {
     ASSERT(!function_.IsNull());
     return function_;
   }
   const Code& code() const {
     ASSERT(!code_.IsNull());
     return code_;
   }
 
   RawString* QualifiedFunctionName();
   RawString* SourceUrl();
   RawScript* SourceScript();
   RawLibrary* Library();
   TokenPosition TokenPos();
   intptr_t LineNumber();
   intptr_t ColumnNumber();
 
+  bool IsLiveFrame() const {
+    return (kind_ == kRegular) || (kind_ == kAsyncLive);
+  }
+
   // Returns true if this frame is for a function that is visible
   // to the user and can be debugged.
   bool IsDebuggable() const;
 
   // Returns true if it is possible to rewind the debugger to this frame.
   bool IsRewindable() const;
 
+  // Returns true if this function is _SyncCompleter._completeOnAsyncReturn
+  // from the async library.
+  bool IsCompleteOnAsyncReturn();
+
+  // Returns true if this function is from the AsyncStartStreamController class.
+  bool IsInAsyncStarStreamController();
+
+  // Returns true if this function is part of the async implementation
+  // machinery.
+  bool IsInAsyncMachinery();
+
   // The context level of a frame is the context level at the
   // PC/token index of the frame. It determines the depth of the context
   // chain that belongs to the function of this activation frame.
   intptr_t ContextLevel();
 
   const char* ToCString();
 
   intptr_t NumLocalVariables();
 
   void VariableAt(intptr_t i,
                   String* name,
                   TokenPosition* declaration_token_pos,
                   TokenPosition* visible_start_token_pos,
                   TokenPosition* visible_end_token_pos,
                   Object* value);
 
   RawArray* GetLocalVariables();
   RawObject* GetParameter(intptr_t index);
   RawObject* GetClosure();
   RawObject* GetReceiver();
 
   const Context& GetSavedCurrentContext();
   RawObject* GetAsyncOperation();
+  RawObject* GetAsyncCompleter();
+  RawObject* GetAsyncCompleterAwaiter(const Object& completer);
+
+  void ExtractTokenPositionFromAsyncClosure();
+
+  RawObject* GetAsyncStreamControllerStream();
+  RawObject* GetAsyncStreamControllerStreamAwaiter(const Object& stream);
+
+  RawObject* GetAsyncAwaiter();
 
   RawObject* Evaluate(const String& expr);
 
   // Print the activation frame into |jsobj|. if |full| is false, script
   // and local variable objects are only references. if |full| is true,
   // the complete script, function, and, local variable objects are included.
   void PrintToJSONObject(JSONObject* jsobj, bool full = false);
 
  private:
+  void PrintToJSONObjectAsync(JSONObject* jsobj, bool full = false);
+  void PrintToJSONObjectRegular(JSONObject* jsobj, bool full = false);
+  void PrintToJSONObjectHistoricalFrame(JSONObject* jsobj, bool full = false);
+
+  void PrintToJSONObjectLiveFrame(JSONObject* jsobj, bool full = false);
+
   void PrintContextMismatchError(intptr_t ctx_slot,
                                  intptr_t frame_ctx_level,
                                  intptr_t var_ctx_level);
 
   intptr_t TryIndex();
   void GetPcDescriptors();
   void GetVarDescriptors();
   void GetDescIndices();
 
+  static const char* KindToCString(Kind kind) {
+    switch (kind) {
+      case kRegular:
+        return "kRegular";
+      case kAsyncLive:
+        return "kAsyncLive";
+      case kAsyncSuspensionMarker:
+        return "kMarker";
+      case kAsyncHistorical:
+        return "kAsyncHistorical";
+      default:
+        UNREACHABLE();
+        return "";
+    }
+  }
+
   RawObject* GetStackVar(intptr_t slot_index);
   RawObject* GetContextVar(intptr_t ctxt_level, intptr_t slot_index);
 
   uword pc_;
   uword fp_;
   uword sp_;
 
   // The anchor of the context chain for this function.
   Context& ctx_;
-  const Code& code_;
-  const Function& function_;
+  Code& code_;
+  Function& function_;
+  bool suspended_frame_;
   bool token_pos_initialized_;
   TokenPosition token_pos_;
   intptr_t try_index_;
 
   intptr_t line_number_;
   intptr_t column_number_;
   intptr_t context_level_;
 
   // Some frames are deoptimized into a side array in order to inspect them.
   const Array& deopt_frame_;
   const intptr_t deopt_frame_offset_;
 
+  Kind kind_;
+
   bool vars_initialized_;
   LocalVarDescriptors& var_descriptors_;
   ZoneGrowableArray<intptr_t> desc_indices_;
   PcDescriptors& pc_desc_;
 
   friend class Debugger;
   friend class DebuggerStackTrace;
   DISALLOW_COPY_AND_ASSIGN(ActivationFrame);
 };
 
 
 // Array of function activations on the call stack.
 class DebuggerStackTrace : public ZoneAllocated {
  public:
   explicit DebuggerStackTrace(int capacity) : trace_(capacity) {}
 
   intptr_t Length() const { return trace_.length(); }
 
   ActivationFrame* FrameAt(int i) const { return trace_[i]; }
 
   ActivationFrame* GetHandlerFrame(const Instance& exc_obj) const;
 
  private:
   void AddActivation(ActivationFrame* frame);
+  void AddMarker(ActivationFrame::Kind marker);
+  void AddAsyncHistoricalFrame(uword pc, const Code& code);
+
   ZoneGrowableArray<ActivationFrame*> trace_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(DebuggerStackTrace);
 };
 
 
 class Debugger {
  public:
   enum ResumeAction {
     kContinue,
     kStepInto,
     kStepOver,
     kStepOut,
     kStepRewind,
     kStepOverAsyncSuspension,
   };
 
   typedef void EventHandler(ServiceEvent* event);
 
   Debugger();
   ~Debugger();
 
   void Initialize(Isolate* isolate);
   void NotifyIsolateCreated();
   void Shutdown();
 
+  void WhenRunnable();
+
   void NotifyCompilation(const Function& func);
   void NotifyDoneLoading();
 
   RawFunction* ResolveFunction(const Library& library,
                                const String& class_name,
                                const String& function_name);
 
   // Set breakpoint at closest location to function entry.
   Breakpoint* SetBreakpointAtEntry(const Function& target_function,
                                    bool single_shot);
@@ skipping 16 matching lines @@
 
   void RemoveBreakpoint(intptr_t bp_id);
   Breakpoint* GetBreakpointById(intptr_t id);
 
   bool SetResumeAction(ResumeAction action,
                        intptr_t frame_index = 1,
                        const char** error = NULL);
 
   bool IsStepping() const { return resume_action_ != kContinue; }
 
+  bool IsSingleStepping() const { return resume_action_ == kStepInto; }
+
   bool IsPaused() const { return pause_event_ != NULL; }
 
+  void AsyncStepInto(const Closure& async_op);
+  void AsyncContinue();
+
   // Put the isolate into single stepping mode when Dart code next runs.
   //
   // This is used by the vm service to allow the user to step while
   // paused at isolate start.
   void EnterSingleStepMode();
 
   // Indicates why the debugger is currently paused.  If the debugger
   // is not paused, this returns NULL.  Note that the debugger can be
   // paused for breakpoints, isolate interruption, and (sometimes)
   // exceptions.
@@ skipping 18 matching lines @@
   // a debugger stub.
   bool HasActiveBreakpoint(uword pc);
 
   // Returns a stack trace with frames corresponding to invisible functions
   // omitted. CurrentStackTrace always returns a new trace on the current stack.
   // The trace returned by StackTrace may have been cached; it is suitable for
   // use when stepping, but otherwise may be out of sync with the current stack.
   DebuggerStackTrace* StackTrace();
   DebuggerStackTrace* CurrentStackTrace();
 
+  // Returns a stack trace with frames corresponding to invisible functions
+  // omitted. CurrentAsyncStackTrace always returns a new trace on the current
+  // stack. The trace returned by AsyncStackTrace may have been cached; it is
+  // suitable for use when stepping, but otherwise may be out of sync with the
+  // current stack.
+  DebuggerStackTrace* AsyncStackTrace();
+  DebuggerStackTrace* CurrentAsyncStackTrace();
+
+  DebuggerStackTrace* AsyncReturnStack();
+  DebuggerStackTrace* CurrentAsyncReturnStack();
+
   // Returns a debugger stack trace corresponding to a dart.core.StackTrace.
   // Frames corresponding to invisible functions are omitted. It is not valid
   // to query local variables in the returned stack.
   DebuggerStackTrace* StackTraceFrom(const class StackTrace& dart_stacktrace);
 
   RawArray* GetInstanceFields(const Instance& obj);
   RawArray* GetStaticFields(const Class& cls);
   RawArray* GetLibraryFields(const Library& lib);
   RawArray* GetGlobalFields(const Library& lib);
 
@@ skipping 40 matching lines @@
   static bool IsDebuggable(const Function& func);
 
   intptr_t limitBreakpointId() { return next_id_; }
 
   // Callback to the debugger to continue frame rewind, post-deoptimization.
   void RewindPostDeopt();
 
  private:
   RawError* PauseRequest(ServiceEvent::EventKind kind);
 
+  /// Finds the breakpoint we hit at |location|.
+  Breakpoint* FindHitBreakpoint(BreakpointLocation* location,
+                                ActivationFrame* top_frame);
+
+  // Returns true if the debugger had just taken a step after hitting a
+  // synthetic async breakpoint.
+  bool SteppedForSyntheticAsyncBreakpoint() const;
+
+  RawError* StepForSyntheticAsyncBreakpoint(Breakpoint* bpt);
+
+  void CleanupSyntheticAsyncBreakpoint();
+
   // Will return false if we are not at an await.
   bool SetupStepOverAsyncSuspension(const char** error);
 
+  uword GetAsyncActivationGeneratorSteppingFramePointer();
+
   bool NeedsIsolateEvents();
   bool NeedsDebugEvents();
   void InvokeEventHandler(ServiceEvent* event);
 
   void SendBreakpointEvent(ServiceEvent::EventKind kind, Breakpoint* bpt);
 
   bool IsAtAsyncJump(ActivationFrame* top_frame);
   void FindCompiledFunctions(const Script& script,
                              TokenPosition start_pos,
                              TokenPosition end_pos,
@@ skipping 21 matching lines @@
   BreakpointLocation* GetBreakpointLocation(const Script& script,
                                             TokenPosition token_pos,
                                             intptr_t requested_column);
   void MakeCodeBreakpointAt(const Function& func, BreakpointLocation* bpt);
   // Returns NULL if no breakpoint exists for the given address.
   CodeBreakpoint* GetCodeBreakpoint(uword breakpoint_address);
 
   void SyncBreakpointLocation(BreakpointLocation* loc);
 
   ActivationFrame* TopDartFrame() const;
-  static ActivationFrame* CollectDartFrame(Isolate* isolate,
-                                           uword pc,
-                                           StackFrame* frame,
-                                           const Code& code,
-                                           const Array& deopt_frame,
-                                           intptr_t deopt_frame_offset);
+  static ActivationFrame* CollectDartFrame(
+      Isolate* isolate,
+      uword pc,
+      StackFrame* frame,
+      const Code& code,
+      const Array& deopt_frame,
+      intptr_t deopt_frame_offset,
+      ActivationFrame::Kind kind = ActivationFrame::kRegular);
   static RawArray* DeoptimizeToArray(Thread* thread,
                                      StackFrame* frame,
                                      const Code& code);
+  static DebuggerStackTrace* CollectAsyncStackTrace();
   static DebuggerStackTrace* CollectStackTrace();
+  static DebuggerStackTrace* CollectAsyncReturnCallStack();
+
   void SignalPausedEvent(ActivationFrame* top_frame, Breakpoint* bpt);
 
   intptr_t nextId() { return next_id_++; }
 
   bool ShouldPauseOnException(DebuggerStackTrace* stack_trace,
                               const Instance& exc);
 
   void CollectLibraryFields(const GrowableObjectArray& field_list,
                             const Library& lib,
                             const String& prefix,
                             bool include_private_fields);
 
   // Handles any events which pause vm execution.  Breakpoints,
   // interrupts, etc.
   void Pause(ServiceEvent* event);
 
   void HandleSteppingRequest(DebuggerStackTrace* stack_trace,
                              bool skip_next_step = false);
 
+  void CacheStackTraces(DebuggerStackTrace* stack_trace,
+                        DebuggerStackTrace* async_stack_trace,
+                        DebuggerStackTrace* async_return_stack_trace);
+  void ClearCachedStackTraces();
+
   // 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);
 
   Isolate* isolate_;
@@ skipping 22 matching lines @@
   // paused for breakpoints, isolate interruption, and (sometimes)
   // exceptions.
   ServiceEvent* pause_event_;
 
   // An id -> object map.  Valid only while IsPaused().
   RemoteObjectCache* obj_cache_;
 
   // Current stack trace. Valid only while IsPaused().
   DebuggerStackTrace* stack_trace_;
 
+  // Current async stack trace. Valid only while IsPaused().
+  DebuggerStackTrace* async_stack_trace_;
+
+  // Current async return call trace. Valid only while IsPaused().
+  DebuggerStackTrace* async_return_call_stack_;
+
   // 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_;
 
+  // In order to support automatic step-out behaviour for asynchronous functions
+  // we track the top frame's awaiter. This is where execution should begin
+  // once we've left the current function. We keep track of the
+  // async_stepping_fp_ and use it to determine if we have single stepped our
+  // way out of the asynchronous function.
+  RawObject* top_frame_awaiter_;
+  uword async_stepping_fp_;
+
   // 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_;
 
   // 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_