Include the awaiter stack trace in the service protocol

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 359 matching lines @@
   if (ignore_breakpoints_ || IsPaused()) {
     // We don't let the isolate get interrupted if we are already
     // paused or ignoring breakpoints.
     return Error::null();
   }
   ServiceEvent event(isolate_, kind);
   DebuggerStackTrace* trace = CollectStackTrace();
   if (trace->Length() > 0) {
     event.set_top_frame(trace->FrameAt(0));
   }
-  CacheStackTraces(trace, CollectAsyncCausalStackTrace());
+  CacheStackTraces(trace, CollectAsyncCausalStackTrace(),
+                   CollectAwaiterReturnStackTrace());
   resume_action_ = kContinue;
   Pause(&event);
   HandleSteppingRequest(trace);
   ClearCachedStackTraces();
 
   // If any error occurred while in the debug message loop, return it here.
   const Error& error = Error::Handle(Thread::Current()->sticky_error());
   ASSERT(error.IsNull() || error.IsUnwindError());
   Thread::Current()->clear_sticky_error();
   return error.raw();
@@ skipping 315 matching lines @@
         }
       }
     }
     ASSERT(context_level_ >= 0);
   }
   return context_level_;
 }
 
 
 RawObject* ActivationFrame::GetAsyncContextVariable(const String& name) {
-  if (!function_.IsAsyncClosure()) {
+  if (!function_.IsAsyncClosure() && !function_.IsAsyncGenClosure()) {
     return Object::null();
   }
   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);
     if (var_descriptors_.GetName(i) == name.raw()) {
       const int8_t kind = var_info.kind();
       if (!live_frame_) {
@@ skipping 65 matching lines @@
   const Object& async_stream_controller_stream =
       Object::Handle(GetAsyncStreamControllerStream());
   if (!async_stream_controller_stream.IsNull()) {
     return GetAsyncStreamControllerStreamAwaiter(
         async_stream_controller_stream);
   }
   return Object::null();
 }
 
 
+RawObject* ActivationFrame::GetCausalStack() {
+  return GetAsyncContextVariable(Symbols::AsyncStackTraceVar());
+}
+
+
 bool ActivationFrame::HandlesException(const Instance& exc_obj) {
   intptr_t try_index = TryIndex();
   if (try_index < 0) {
     return false;
   }
   ExceptionHandlers& handlers = ExceptionHandlers::Handle();
   Array& handled_types = Array::Handle();
   AbstractType& type = Type::Handle();
   const bool is_async =
       function().IsAsyncClosure() || function().IsAsyncGenClosure();
@@ skipping 490 matching lines @@
 }
 
 
 void ActivationFrame::PrintToJSONObject(JSONObject* jsobj, bool full) {
   if (kind_ == kRegular) {
     PrintToJSONObjectRegular(jsobj, full);
   } else if (kind_ == kAsyncCausal) {
     PrintToJSONObjectAsyncCausal(jsobj, full);
   } else if (kind_ == kAsyncSuspensionMarker) {
     PrintToJSONObjectAsyncSuspensionMarker(jsobj, full);
+  } else if (kind_ == kAsyncActivation) {
+    PrintToJSONObjectAsyncActivation(jsobj, full);
   } else {
     UNIMPLEMENTED();
   }
 }
 
 
 void ActivationFrame::PrintToJSONObjectRegular(JSONObject* jsobj, bool full) {
   const Script& script = Script::Handle(SourceScript());
   jsobj->AddProperty("type", "Frame");
   jsobj->AddProperty("kind", KindToCString(kind_));
@@ skipping 14 matching lines @@
       String& var_name = String::Handle();
       Instance& var_value = Instance::Handle();
       TokenPosition declaration_token_pos;
       TokenPosition visible_start_token_pos;
       TokenPosition visible_end_token_pos;
       VariableAt(v, &var_name, &declaration_token_pos, &visible_start_token_pos,
                  &visible_end_token_pos, &var_value);
       if ((var_name.raw() != Symbols::AsyncOperation().raw()) &&
           (var_name.raw() != Symbols::AsyncCompleter().raw()) &&
           (var_name.raw() != Symbols::ControllerStream().raw()) &&
-          (var_name.raw() != Symbols::AwaitJumpVar().raw())) {
+          (var_name.raw() != Symbols::AwaitJumpVar().raw()) &&
+          (var_name.raw() != Symbols::AsyncStackTraceVar().raw())) {
         JSONObject jsvar(&jsvars);
         jsvar.AddProperty("type", "BoundVariable");
         var_name = String::ScrubName(var_name);
         jsvar.AddProperty("name", var_name.ToCString());
         jsvar.AddProperty("value", var_value, !full);
         // Where was the variable declared?
         jsvar.AddProperty("declarationTokenPos", declaration_token_pos);
         // When the variable becomes visible to the scope.
         jsvar.AddProperty("scopeStartTokenPos", visible_start_token_pos);
         // When the variable stops being visible to the scope.
@@ skipping 23 matching lines @@
 
 
 void ActivationFrame::PrintToJSONObjectAsyncSuspensionMarker(JSONObject* jsobj,
                                                              bool full) {
   jsobj->AddProperty("type", "Frame");
   jsobj->AddProperty("kind", KindToCString(kind_));
   jsobj->AddProperty("marker", "AsynchronousSuspension");
 }
 
 
+void ActivationFrame::PrintToJSONObjectAsyncActivation(JSONObject* jsobj,
+                                                       bool full) {
+  jsobj->AddProperty("type", "Frame");
+  jsobj->AddProperty("kind", KindToCString(kind_));
+  const Script& script = Script::Handle(SourceScript());
+  const TokenPosition pos = TokenPos().SourcePosition();
+  jsobj->AddLocation(script, pos);
+  jsobj->AddProperty("function", function(), !full);
+  jsobj->AddProperty("code", code());
+  if (full) {
+    // TODO(cutch): The old "full" script usage no longer fits
+    // in the world where we pass the script as part of the
+    // location.
+    jsobj->AddProperty("script", script, !full);
+  }
+}
+
+
 static bool IsFunctionVisible(const Function& function) {
   return FLAG_show_invisible_frames || function.is_visible();
 }
 
 
 void DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
   if (IsFunctionVisible(frame->function())) {
     trace_.Add(frame);
   }
 }
@@ skipping 133 matching lines @@
       breakpoint_locations_(NULL),
       code_breakpoints_(NULL),
       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),
       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());
@@ skipping 377 matching lines @@
   ASSERT(!FLAG_precompiled_runtime);
 
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
 
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
 
   Code& code = Code::Handle(zone);
+  Smi& offset = Smi::Handle(zone);
   Function& function = Function::Handle(zone);
   Code& inlined_code = Code::Handle(zone);
   Closure& async_activation = Closure::Handle(zone);
+  Object& next_async_activation = Object::Handle(zone);
   Array& deopt_frame = Array::Handle(zone);
+  class StackTrace& async_stack_trace = StackTrace::Handle(zone);
 
   for (StackFrame* frame = iterator.NextFrame(); frame != NULL;
        frame = iterator.NextFrame()) {
     ASSERT(frame->IsValid());
     if (FLAG_trace_debugger_stacktrace) {
       OS::PrintErr("CollectStackTrace: visiting frame:\n\t%s\n",
                    frame->ToCString());
     }
     if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
@@ skipping 50 matching lines @@
   }
 
   // Return NULL to indicate that there is no useful information in this stack
   // trace because we never found an awaiter.
   if (async_activation.IsNull()) {
     return NULL;
   }
 
   // Append the awaiter return call stack.
   while (!async_activation.IsNull()) {
-    ActivationFrame* activation = new ActivationFrame(async_activation);
-    async_activation ^= activation->GetAsyncAwaiter();
+    ActivationFrame* activation = new (zone) ActivationFrame(async_activation);
     activation->ExtractTokenPositionFromAsyncClosure();
     stack_trace->AddActivation(activation);
+    next_async_activation = activation->GetAsyncAwaiter();
+    if (next_async_activation.IsNull()) {
+      // No more awaiters. Extract the causal stack trace (if it exists).
+      async_stack_trace ^= activation->GetCausalStack();
+      break;
+    }
+    async_activation = Closure::RawCast(next_async_activation.raw());
+  }
+
+  // Now we append the asynchronous causal stack trace. These are not active
+  // frames but a historical record of how this asynchronous function was
+  // activated.
+  while (!async_stack_trace.IsNull()) {
+    for (intptr_t i = 0; i < async_stack_trace.Length(); i++) {
+      if (async_stack_trace.CodeAtFrame(i) == Code::null()) {
+        // Incomplete OutOfMemory/StackOverflow trace OR array padding.
+        break;
+      }
+      if (async_stack_trace.CodeAtFrame(i) ==
+          StubCode::AsynchronousGapMarker_entry()->code()) {
+        stack_trace->AddMarker(ActivationFrame::kAsyncSuspensionMarker);
+        // The frame immediately below the asynchronous gap marker is the
+        // identical to the frame above the marker. Skip the frame to enhance
+        // the readability of the trace.
+        i++;
+      } else {
+        code = Code::RawCast(async_stack_trace.CodeAtFrame(i));
+        offset = Smi::RawCast(async_stack_trace.PcOffsetAtFrame(i));
+        uword pc = code.PayloadStart() + offset.Value();
+        if (code.is_optimized()) {
+          for (InlinedFunctionsIterator it(code, pc); !it.Done();
+               it.Advance()) {
+            inlined_code = it.code();
+            stack_trace->AddAsyncCausalFrame(it.pc(), inlined_code);
+          }
+        } else {
+          stack_trace->AddAsyncCausalFrame(pc, code);
+        }
+      }
+    }
+    // Follow the link.
+    async_stack_trace = async_stack_trace.async_link();
   }
 
   return stack_trace;
 }
 
 
 ActivationFrame* Debugger::TopDartFrame() const {
   StackFrameIterator iterator(false);
   StackFrame* frame = iterator.NextFrame();
   while ((frame != NULL) && !frame->IsDartFrame()) {
@@ skipping 20 matching lines @@
   return (async_causal_stack_trace_ != NULL) ? async_causal_stack_trace_
                                              : CollectAsyncCausalStackTrace();
 }
 
 
 DebuggerStackTrace* Debugger::CurrentAsyncCausalStackTrace() {
   return CollectAsyncCausalStackTrace();
 }
 
 
+DebuggerStackTrace* Debugger::AwaiterStackTrace() {
+  return (awaiter_stack_trace_ != NULL) ? awaiter_stack_trace_
+                                        : CollectAwaiterReturnStackTrace();
+}
+
+
+DebuggerStackTrace* Debugger::CurrentAwaiterStackTrace() {
+  return CollectAwaiterReturnStackTrace();
+}
+
+
 DebuggerStackTrace* Debugger::StackTraceFrom(const class StackTrace& ex_trace) {
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   Function& function = Function::Handle();
   Code& code = Code::Handle();
 
   const uword fp = 0;
   const uword sp = 0;
   const Array& deopt_frame = Array::Handle();
   const intptr_t deopt_frame_offset = -1;
 
@@ skipping 96 matching lines @@
   } else {
     if (!ShouldPauseOnException(stack_trace, exc)) {
       return;
     }
   }
   ServiceEvent event(isolate_, ServiceEvent::kPauseException);
   event.set_exception(&exc);
   if (stack_trace->Length() > 0) {
     event.set_top_frame(stack_trace->FrameAt(0));
   }
-  CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace());
+  CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace(),
+                   CollectAwaiterReturnStackTrace());
   Pause(&event);
   HandleSteppingRequest(stack_trace_);  // we may get a rewind request
   ClearCachedStackTraces();
 }
 
 
 static TokenPosition LastTokenOnLine(Zone* zone,
                                      const TokenStream& tokens,
                                      TokenPosition pos) {
   TokenStream::Iterator iter(zone, tokens, pos,
@@ skipping 983 matching lines @@
         frame = iterator.NextFrame();
       }
     }
     RewindToFrame(resume_frame_index_);
     UNREACHABLE();
   }
 }
 
 
 void Debugger::CacheStackTraces(DebuggerStackTrace* stack_trace,
-                                DebuggerStackTrace* async_causal_stack_trace) {
+                                DebuggerStackTrace* async_causal_stack_trace,
+                                DebuggerStackTrace* awaiter_stack_trace) {
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
   ASSERT(async_causal_stack_trace_ == NULL);
   async_causal_stack_trace_ = async_causal_stack_trace;
+  ASSERT(awaiter_stack_trace_ == NULL);
+  awaiter_stack_trace_ = awaiter_stack_trace;
 }
 
 
 void Debugger::ClearCachedStackTraces() {
   stack_trace_ = NULL;
   async_causal_stack_trace_ = NULL;
+  awaiter_stack_trace_ = NULL;
 }
 
 
 static intptr_t FindNextRewindFrameIndex(DebuggerStackTrace* stack,
                                          intptr_t frame_index) {
   for (intptr_t i = frame_index + 1; i < stack->Length(); i++) {
     ActivationFrame* frame = stack->FrameAt(i);
     if (frame->IsRewindable()) {
       return i;
     }
@@ skipping 320 matching lines @@
 
   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());
+  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;
   }
   HandleSteppingRequest(stack_trace_);
   ClearCachedStackTraces();
@@ skipping 20 matching lines @@
   ASSERT(cbpt != NULL);
 
   Breakpoint* bpt_hit = FindHitBreakpoint(cbpt->bpt_location_, top_frame);
   if (bpt_hit == NULL) {
     return Error::null();
   }
 
   if (bpt_hit->is_synthetic_async()) {
     DebuggerStackTrace* stack_trace = CollectStackTrace();
     ASSERT(stack_trace->Length() > 0);
-    CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace());
+    CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace(),
+                     CollectAwaiterReturnStackTrace());
 
     // Hit a synthetic async breakpoint.
     if (FLAG_verbose_debug) {
       OS::Print(">>> hit synthetic breakpoint at %s:%" Pd
                 " "
                 "(token %s) (address %#" Px ")\n",
                 String::Handle(cbpt->SourceUrl()).ToCString(),
                 cbpt->LineNumber(), cbpt->token_pos().ToCString(),
                 top_frame->pc());
     }
@@ skipping 14 matching lines @@
 
   if (FLAG_verbose_debug) {
     OS::Print(">>> hit breakpoint %" Pd " at %s:%" Pd
               " (token %s) "
               "(address %#" Px ")\n",
               bpt_hit->id(), String::Handle(cbpt->SourceUrl()).ToCString(),
               cbpt->LineNumber(), cbpt->token_pos().ToCString(),
               top_frame->pc());
   }
 
-  CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace());
+  CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace(),
+                   CollectAwaiterReturnStackTrace());
   SignalPausedEvent(top_frame, bpt_hit);
   // When we single step from a user breakpoint, our next stepping
   // point will be at the exact same pc.  Skip it.
   HandleSteppingRequest(stack_trace_, true /* skip next step */);
   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 48 matching lines @@
 void Debugger::PauseDeveloper(const String& msg) {
   // 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()) {
     return;
   }
 
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   ASSERT(stack_trace->Length() > 0);
-  CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace());
+  CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace(),
+                   CollectAwaiterReturnStackTrace());
   // TODO(johnmccutchan): Send |msg| to Observatory.
 
   // We are in the native call to Developer_debugger.  the developer
   // gets a better experience by not seeing this call. To accomplish
   // this, we continue execution until the call exits (step out).
   SetResumeAction(kStepOut);
   HandleSteppingRequest(stack_trace_);
   ClearCachedStackTraces();
 }
 
@@ skipping 468 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart