Track async causal stack traces

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"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/deopt_instructions.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
 #include "vm/json_stream.h"
 #include "vm/message_handler.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/port.h"
 #include "vm/service_event.h"
 #include "vm/service_isolate.h"
 #include "vm/service.h"
 #include "vm/stack_frame.h"
+#include "vm/stack_trace.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/thread_interrupter.h"
 #include "vm/timeline.h"
 #include "vm/token_position.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
@@ skipping 203 matching lines @@
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&saved_value_));
 #endif
 }
 
 
 ActivationFrame::ActivationFrame(uword pc,
                                  uword fp,
                                  uword sp,
                                  const Code& code,
                                  const Array& deopt_frame,
-                                 intptr_t deopt_frame_offset)
+                                 intptr_t deopt_frame_offset,
+                                 ActivationFrame::Kind kind)
     : pc_(pc),
       fp_(fp),
       sp_(sp),
       ctx_(Context::ZoneHandle()),
       code_(Code::ZoneHandle(code.raw())),
       function_(Function::ZoneHandle(code.function())),
+      live_frame_(kind == kRegular),
       token_pos_initialized_(false),
       token_pos_(TokenPosition::kNoSource),
       try_index_(-1),
       line_number_(-1),
       column_number_(-1),
       context_level_(-1),
       deopt_frame_(Array::ZoneHandle(deopt_frame.raw())),
       deopt_frame_offset_(deopt_frame_offset),
+      kind_(kind),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {}
 
 
+ActivationFrame::ActivationFrame(Kind kind)
+    : pc_(0),
+      fp_(0),
+      sp_(0),
+      ctx_(Context::ZoneHandle()),
+      code_(Code::ZoneHandle()),
+      function_(Function::ZoneHandle()),
+      live_frame_(kind == kRegular),
+      token_pos_initialized_(false),
+      token_pos_(TokenPosition::kNoSource),
+      try_index_(-1),
+      line_number_(-1),
+      column_number_(-1),
+      context_level_(-1),
+      deopt_frame_(Array::ZoneHandle()),
+      deopt_frame_offset_(0),
+      kind_(kind),
+      vars_initialized_(false),
+      var_descriptors_(LocalVarDescriptors::ZoneHandle()),
+      desc_indices_(8),
+      pc_desc_(PcDescriptors::ZoneHandle()) {}
+
 bool Debugger::NeedsIsolateEvents() {
   return ((isolate_ != Dart::vm_isolate()) &&
           !ServiceIsolate::IsServiceIsolateDescendant(isolate_) &&
           ((event_handler_ != NULL) || Service::isolate_stream.enabled()));
 }
 
 
 bool Debugger::NeedsDebugEvents() {
   ASSERT(isolate_ != Dart::vm_isolate() &&
          !ServiceIsolate::IsServiceIsolateDescendant(isolate_));
@@ skipping 28 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));
   }
-  ASSERT(stack_trace_ == NULL);
-  stack_trace_ = trace;
+  CacheStackTraces(trace, CollectAsyncCausalStackTrace());
   resume_action_ = kContinue;
   Pause(&event);
   HandleSteppingRequest(trace);
-  stack_trace_ = NULL;
+  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();
 }
 
 
 void Debugger::SendBreakpointEvent(ServiceEvent::EventKind kind,
@@ skipping 396 matching lines @@
 }
 
 
 void ActivationFrame::GetDescIndices() {
   if (vars_initialized_) {
     return;
   }
   GetVarDescriptors();
 
   TokenPosition activation_token_pos = TokenPos();
-  if (!activation_token_pos.IsDebugPause()) {
+  if (!activation_token_pos.IsDebugPause() || !live_frame_) {
     // We don't have a token position for this frame, so can't determine
     // which variables are visible.
     vars_initialized_ = true;
     return;
   }
 
   GrowableArray<String*> var_names(8);
   intptr_t var_desc_len = var_descriptors_.Length();
   for (intptr_t cur_idx = 0; cur_idx < var_desc_len; cur_idx++) {
     ASSERT(var_names.length() == desc_indices_.length());
@@ skipping 325 matching lines @@
       "\tline = %" Pd
       "\n"
       "\tcontext = %s\n"
       "\tcontext level = %" Pd " ]\n",
       pc(), fp(), sp(), func_name, url.ToCString(), line, ctx_.ToCString(),
       ContextLevel());
 }
 
 
 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 {
+    UNIMPLEMENTED();
+  }
+}
+
+
+void ActivationFrame::PrintToJSONObjectRegular(JSONObject* jsobj, bool full) {
   const Script& script = Script::Handle(SourceScript());
   jsobj->AddProperty("type", "Frame");
+  jsobj->AddProperty("kind", KindToCString(kind_));
   TokenPosition pos = TokenPos();
   if (pos.IsSynthetic()) {
     pos = pos.FromSynthetic();
   }
   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
@@ skipping 21 matching lines @@
         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.
         jsvar.AddProperty("scopeEndTokenPos", visible_end_token_pos);
       }
     }
   }
 }
 
+
+void ActivationFrame::PrintToJSONObjectAsyncCausal(JSONObject* jsobj,
+                                                   bool full) {
+  jsobj->AddProperty("type", "Frame");
+  jsobj->AddProperty("kind", KindToCString(kind_));
+  const Script& script = Script::Handle(SourceScript());
+  TokenPosition pos = TokenPos();
+  if (pos.IsSynthetic()) {
+    pos = pos.FromSynthetic();
+  }
+  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);
+  }
+}
+
+
+void ActivationFrame::PrintToJSONObjectAsyncSuspensionMarker(JSONObject* jsobj,
+                                                             bool full) {
+  jsobj->AddProperty("type", "Frame");
+  jsobj->AddProperty("kind", KindToCString(kind_));
+  jsobj->AddProperty("marker", "AsynchronousSuspension");
+}
+
+
 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);
   }
 }
 
 
+void DebuggerStackTrace::AddMarker(ActivationFrame::Kind marker) {
+  ASSERT((marker >= ActivationFrame::kAsyncSuspensionMarker) &&
+         (marker <= ActivationFrame::kAsyncSuspensionMarker));
+  trace_.Add(new ActivationFrame(marker));
+}
+
+
+void DebuggerStackTrace::AddAsyncCausalFrame(uword pc, const Code& code) {
+  trace_.Add(new ActivationFrame(pc, 0, 0, code, Array::Handle(), 0,
+                                 ActivationFrame::kAsyncCausal));
+}
+
+
 const uint8_t kSafepointKind = RawPcDescriptors::kIcCall |
                                RawPcDescriptors::kUnoptStaticCall |
                                RawPcDescriptors::kRuntimeCall;
 
 
 CodeBreakpoint::CodeBreakpoint(const Code& code,
                                TokenPosition token_pos,
                                uword pc,
                                RawPcDescriptors::Kind kind)
     : code_(code.raw()),
@@ skipping 107 matching lines @@
       latent_locations_(NULL),
       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),
       stepping_fp_(0),
       skip_next_step_(false),
       synthetic_async_breakpoint_(NULL),
       exc_pause_info_(kNoPauseOnExceptions) {}
 
 
 Debugger::~Debugger() {
   isolate_id_ = ILLEGAL_ISOLATE_ID;
   ASSERT(!IsPaused());
   ASSERT(latent_locations_ == NULL);
   ASSERT(breakpoint_locations_ == NULL);
   ASSERT(code_breakpoints_ == NULL);
   ASSERT(stack_trace_ == NULL);
+  ASSERT(async_causal_stack_trace_ == NULL);
   ASSERT(obj_cache_ == NULL);
   ASSERT(synthetic_async_breakpoint_ == NULL);
 }
 
 
 void Debugger::Shutdown() {
   // TODO(johnmccutchan): Do not create a debugger for isolates that don't need
   // them. Then, assert here that isolate_ is not one of those isolates.
   if ((isolate_ == Dart::vm_isolate()) ||
       ServiceIsolate::IsServiceIsolateDescendant(isolate_)) {
@@ skipping 218 matching lines @@
 
   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();
-      if (code.is_optimized() && !FLAG_precompiled_runtime) {
-        deopt_frame = DeoptimizeToArray(thread, frame, code);
-        for (InlinedFunctionsIterator it(code, frame->pc()); !it.Done();
-             it.Advance()) {
-          inlined_code = it.code();
-          if (FLAG_trace_debugger_stacktrace) {
-            const Function& function =
-                Function::Handle(zone, inlined_code.function());
-            ASSERT(!function.IsNull());
-            OS::PrintErr("CollectStackTrace: visiting inlined function: %s\n",
-                         function.ToFullyQualifiedCString());
-          }
-          intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
-          stack_trace->AddActivation(CollectDartFrame(isolate, it.pc(), frame,
-                                                      inlined_code, deopt_frame,
-                                                      deopt_frame_offset));
-        }
-      } else {
-        stack_trace->AddActivation(CollectDartFrame(
-            isolate, frame->pc(), frame, code, Object::null_array(), 0));
-      }
+      AppendCodeFrames(thread, isolate, zone, stack_trace, frame, &code,
+                       &inlined_code, &deopt_frame);
     }
   }
   return stack_trace;
 }
 
+void Debugger::AppendCodeFrames(Thread* thread,
+                                Isolate* isolate,
+                                Zone* zone,
+                                DebuggerStackTrace* stack_trace,
+                                StackFrame* frame,
+                                Code* code,
+                                Code* inlined_code,
+                                Array* deopt_frame) {
+  if (code->is_optimized() && !FLAG_precompiled_runtime) {
+    // TODO(rmacnak): Use CodeSourceMap
+    *deopt_frame = DeoptimizeToArray(thread, frame, *code);
+    for (InlinedFunctionsIterator it(*code, frame->pc()); !it.Done();
+         it.Advance()) {
+      *inlined_code = it.code();
+      if (FLAG_trace_debugger_stacktrace) {
+        const Function& function =
+            Function::Handle(zone, inlined_code->function());
+        ASSERT(!function.IsNull());
+        OS::PrintErr("CollectStackTrace: visiting inlined function: %s\n",
+                     function.ToFullyQualifiedCString());
+      }
+      intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
+      stack_trace->AddActivation(CollectDartFrame(isolate, it.pc(), frame,
+                                                  *inlined_code, *deopt_frame,
+                                                  deopt_frame_offset));
+    }
+  } else {
+    stack_trace->AddActivation(CollectDartFrame(
+        isolate, frame->pc(), frame, *code, Object::null_array(), 0));
+  }
+}
+
+
+DebuggerStackTrace* Debugger::CollectAsyncCausalStackTrace() {
+  if (!FLAG_causal_async_stacks) {
+    return NULL;
+  }
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
+  DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
+
+  Code& code = Code::Handle(zone);
+  Smi& offset = Smi::Handle();
+  Code& inlined_code = Code::Handle(zone);
+  Array& deopt_frame = Array::Handle(zone);
+
+  Function& async_function = Function::Handle(zone);
+  class StackTrace& async_stack_trace = StackTrace::Handle(zone);
+  Array& async_code_array = Array::Handle(zone);
+  Array& async_pc_offset_array = Array::Handle(zone);
+  StackTraceUtils::ExtractAsyncStackTraceInfo(
+      thread, &async_function, &async_stack_trace, &async_code_array,
+      &async_pc_offset_array);
+
+  if (async_function.IsNull()) {
+    return NULL;
+  }
+
+  intptr_t synchronous_stack_trace_length =
+      StackTraceUtils::CountFrames(thread, 0, async_function);
+
+  // Append the top frames from the synchronous stack trace, up until the active
+  // asynchronous function. We truncate the remainder of the synchronous
+  // stack trace because it contains activations that are part of the
+  // asynchronous dispatch mechanisms.
+  StackFrameIterator iterator(false);
+  StackFrame* frame = iterator.NextFrame();
+  while (synchronous_stack_trace_length >= 0) {
+    ASSERT(frame != NULL);
+    if (frame->IsDartFrame()) {
+      code = frame->LookupDartCode();
+      AppendCodeFrames(thread, isolate, zone, stack_trace, frame, &code,
+                       &inlined_code, &deopt_frame);
+      synchronous_stack_trace_length--;
+    }
+    frame = iterator.NextFrame();
+  }
+
+  // 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()) {
+        break;
+      }
+      if (async_stack_trace.CodeAtFrame(i) ==
+          StubCode::AsynchronousGapMarker_entry()->code()) {
+        stack_trace->AddMarker(ActivationFrame::kAsyncSuspensionMarker);
+      } 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(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()) {
     frame = iterator.NextFrame();
   }
   Code& code = Code::Handle(frame->LookupDartCode());
   ActivationFrame* activation = new ActivationFrame(
       frame->pc(), frame->fp(), frame->sp(), code, Object::null_array(), 0);
   return activation;
 }
 
 
 DebuggerStackTrace* Debugger::StackTrace() {
   return (stack_trace_ != NULL) ? stack_trace_ : CollectStackTrace();
 }
 
+
 DebuggerStackTrace* Debugger::CurrentStackTrace() {
   return CollectStackTrace();
 }
 
+
+DebuggerStackTrace* Debugger::AsyncCausalStackTrace() {
+  return (async_causal_stack_trace_ != NULL) ? async_causal_stack_trace_
+                                             : CollectAsyncCausalStackTrace();
+}
+
+
+DebuggerStackTrace* Debugger::CurrentAsyncCausalStackTrace() {
+  return CollectAsyncCausalStackTrace();
+}
+
+
 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 80 matching lines @@
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   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));
   }
-  ASSERT(stack_trace_ == NULL);
-  stack_trace_ = stack_trace;
+  CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace());
   Pause(&event);
   HandleSteppingRequest(stack_trace_);  // we may get a rewind request
-  stack_trace_ = NULL;
+  ClearCachedStackTraces();
 }
 
 
 static TokenPosition LastTokenOnLine(Zone* zone,
                                      const TokenStream& tokens,
                                      TokenPosition pos) {
   TokenStream::Iterator iter(zone, tokens, pos,
                              TokenStream::Iterator::kAllTokens);
   ASSERT(iter.IsValid());
   TokenPosition last_pos = pos;
@@ skipping 976 matching lines @@
         OS::PrintErr("#%04" Pd " %s\n", num++, frame->ToCString());
         frame = iterator.NextFrame();
       }
     }
     RewindToFrame(resume_frame_index_);
     UNREACHABLE();
   }
 }
 
 
+void Debugger::CacheStackTraces(DebuggerStackTrace* stack_trace,
+                                DebuggerStackTrace* async_causal_stack_trace) {
+  ASSERT(stack_trace_ == NULL);
+  stack_trace_ = stack_trace;
+  ASSERT(async_causal_stack_trace_ == NULL);
+  async_causal_stack_trace_ = async_causal_stack_trace;
+}
+
+
+void Debugger::ClearCachedStackTraces() {
+  stack_trace_ = NULL;
+  async_causal_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;
     }
   }
   return -1;
 }
@@ skipping 108 matching lines @@
       }
     }
   }
   UNIMPLEMENTED();
 }
 
 
 void Debugger::RewindToUnoptimizedFrame(StackFrame* frame, const Code& code) {
   // We will be jumping out of the debugger rather than exiting this
   // function, so prepare the debugger state.
-  stack_trace_ = NULL;
+  ClearCachedStackTraces();
   resume_action_ = kContinue;
   resume_frame_index_ = -1;
   EnterSingleStepMode();
 
   uword rewind_pc = LookupRewindPc(code, frame->pc());
   if (FLAG_trace_rewind && rewind_pc == 0) {
     OS::PrintErr("Unable to find rewind pc for pc(%" Px ")\n", frame->pc());
   }
   ASSERT(rewind_pc != 0);
   if (FLAG_trace_rewind) {
@@ skipping 11 matching lines @@
 }
 
 
 void Debugger::RewindToOptimizedFrame(StackFrame* frame,
                                       const Code& optimized_code,
                                       intptr_t sub_index) {
   post_deopt_frame_index_ = sub_index;
 
   // We will be jumping out of the debugger rather than exiting this
   // function, so prepare the debugger state.
-  stack_trace_ = NULL;
+  ClearCachedStackTraces();
   resume_action_ = kContinue;
   resume_frame_index_ = -1;
   EnterSingleStepMode();
 
   if (FLAG_trace_rewind) {
     OS::PrintErr(
         "===============================\n"
         "Deoptimizing frame for rewind:\n"
         "    deopt_pc(0x%" Px ") sp(0x%" Px ") fp(0x%" Px
         ")\n"
@@ skipping 155 matching lines @@
   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());
   }
 
-  ASSERT(stack_trace_ == NULL);
-  stack_trace_ = CollectStackTrace();
+
+  CacheStackTraces(CollectStackTrace(), CollectAsyncCausalStackTrace());
   // 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_);
-  stack_trace_ = NULL;
+  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();
 }
 
 
 RawError* Debugger::PauseBreakpoint() {
   // 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 Error::null();
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   ASSERT(stack_trace->Length() > 0);
   ActivationFrame* top_frame = stack_trace->FrameAt(0);
   ASSERT(top_frame != NULL);
   CodeBreakpoint* cbpt = GetCodeBreakpoint(top_frame->pc());
   ASSERT(cbpt != NULL);
 
-  BreakpointLocation* bpt_location = cbpt->bpt_location_;
-  Breakpoint* bpt_hit = NULL;
-
-  // There may be more than one applicable breakpoint at this location, but we
-  // will report only one as reached. If there is a single-shot breakpoint, we
-  // favor it; then a closure-specific breakpoint ; then an general breakpoint.
-  if (bpt_location != NULL) {
-    Breakpoint* bpt = bpt_location->breakpoints();
-    while (bpt != NULL) {
-      if (bpt->IsSingleShot()) {
-        bpt_hit = bpt;
-        break;
-      }
-      bpt = bpt->next();
-    }
-
-    if (bpt_hit == NULL) {
-      bpt = bpt_location->breakpoints();
-      while (bpt != NULL) {
-        if (bpt->IsPerClosure()) {
-          Object& closure = Object::Handle(top_frame->GetClosure());
-          ASSERT(closure.IsInstance());
-          ASSERT(Instance::Cast(closure).IsClosure());
-          if (closure.raw() == bpt->closure()) {
-            bpt_hit = bpt;
-            break;
-          }
-        }
-        bpt = bpt->next();
-      }
-    }
-
-    if (bpt_hit == NULL) {
-      bpt = bpt_location->breakpoints();
-      while (bpt != NULL) {
-        if (bpt->IsRepeated()) {
-          bpt_hit = bpt;
-          break;
-        }
-        bpt = bpt->next();
-      }
-    }
-  }
-
+  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);
-    ASSERT(stack_trace_ == NULL);
-    stack_trace_ = stack_trace;
+    CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace());
 
     // 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());
     }
 
     ASSERT(synthetic_async_breakpoint_ == NULL);
     synthetic_async_breakpoint_ = bpt_hit;
     bpt_hit = NULL;
 
     // We are at the entry of an async function.
     // We issue a step over to resume at the point after the await statement.
     SetResumeAction(kStepOver);
     // 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 */);
-    stack_trace_ = NULL;
+    ClearCachedStackTraces();
     return Error::null();
   }
 
   if (FLAG_verbose_debug) {
     OS::Print(">>> hit %s breakpoint at %s:%" Pd
               " "
               "(token %s) (address %#" Px ")\n",
               cbpt->IsInternal() ? "internal" : "user",
               String::Handle(cbpt->SourceUrl()).ToCString(), cbpt->LineNumber(),
               cbpt->token_pos().ToCString(), top_frame->pc());
   }
 
-  ASSERT(stack_trace_ == NULL);
-  stack_trace_ = stack_trace;
+  CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace());
   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 */);
-  stack_trace_ = NULL;
+  ClearCachedStackTraces();
   if (cbpt->IsInternal()) {
     RemoveInternalBreakpoints();
   }
 
   // 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();
 }
 
 
+Breakpoint* Debugger::FindHitBreakpoint(BreakpointLocation* location,
+                                        ActivationFrame* top_frame) {
+  if (location == NULL) {
+    return NULL;
+  }
+  // There may be more than one applicable breakpoint at this location, but we
+  // will report only one as reached. If there is a single-shot breakpoint, we
+  // favor it; then a closure-specific breakpoint ; then an general breakpoint.
+
+  // First check for a single-shot breakpoint.
+  Breakpoint* bpt = location->breakpoints();
+  while (bpt != NULL) {
+    if (bpt->IsSingleShot()) {
+      return bpt;
+    }
+    bpt = bpt->next();
+  }
+
+  // Now check for a closure-specific breakpoint.
+  bpt = location->breakpoints();
+  while (bpt != NULL) {
+    if (bpt->IsPerClosure()) {
+      Object& closure = Object::Handle(top_frame->GetClosure());
+      ASSERT(closure.IsInstance());
+      ASSERT(Instance::Cast(closure).IsClosure());
+      if (closure.raw() == bpt->closure()) {
+        return bpt;
+      }
+    }
+    bpt = bpt->next();
+  }
+
+  // Finally, check for a general breakpoint.
+  bpt = location->breakpoints();
+  while (bpt != NULL) {
+    if (bpt->IsRepeated()) {
+      return bpt;
+    }
+    bpt = bpt->next();
+  }
+
+  return NULL;
+}
+
+
 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);
-  ASSERT(stack_trace_ == NULL);
-  stack_trace_ = stack_trace;
-
+  CacheStackTraces(stack_trace, CollectAsyncCausalStackTrace());
   // 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_);
-
-  stack_trace_ = NULL;
+  ClearCachedStackTraces();
 }
 
 
 void Debugger::Initialize(Isolate* isolate) {
   if (initialized_) {
     return;
   }
   isolate_ = isolate;
 
   // Use the isolate's control port as the isolate_id for debugging.
@@ skipping 429 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart