Fix two bugs with async 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"
 
@@ skipping 1886 matching lines @@
         // 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(pc, inlined_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;
 }
 
 
 DebuggerStackTrace* Debugger::CollectAwaiterReturnStackTrace() {
   if (!FLAG_causal_async_stacks) {
     return NULL;
   }
+  // Causal async stacks are not supported in the AOT runtime.
+  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);
   Function& function = Function::Handle(zone);
   Code& inlined_code = Code::Handle(zone);
   Closure& async_activation = Closure::Handle(zone);
   Array& deopt_frame = Array::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();
-      function = code.function();
-      if (function.IsAsyncClosure() || function.IsAsyncGenClosure()) {
-        ActivationFrame* activation = CollectDartFrame(
-            isolate, frame->pc(), frame, code, Object::null_array(), 0,
-            ActivationFrame::kAsyncActivation);
-        ASSERT(activation != NULL);
-        stack_trace->AddActivation(activation);
-        // Grab the awaiter.
-        async_activation ^= activation->GetAsyncAwaiter();
-        break;
+      if (code.is_optimized()) {
+        deopt_frame = DeoptimizeToArray(thread, frame, code);
+        bool found_async_awaiter = false;
+        for (InlinedFunctionsIterator it(code, frame->pc()); !it.Done();
+             it.Advance()) {
+          inlined_code = it.code();
+          function = inlined_code.function();
+          if (FLAG_trace_debugger_stacktrace) {
+            ASSERT(!function.IsNull());
+            OS::PrintErr("CollectStackTrace: visiting inlined function: %s\n",
+                         function.ToFullyQualifiedCString());
+          }
+          intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
+          if (function.IsAsyncClosure() || function.IsAsyncGenClosure()) {
+            ActivationFrame* activation = CollectDartFrame(
+                isolate, it.pc(), frame, inlined_code, deopt_frame,
+                deopt_frame_offset, ActivationFrame::kAsyncActivation);
+            ASSERT(activation != NULL);
+            stack_trace->AddActivation(activation);
+            // Grab the awaiter.
+            async_activation ^= activation->GetAsyncAwaiter();
+            found_async_awaiter = true;
+            break;
+          } else {
+            stack_trace->AddActivation(
+                CollectDartFrame(isolate, it.pc(), frame, inlined_code,
+                                 deopt_frame, deopt_frame_offset));
+          }
+        }
+        // Break out of outer loop.
+        if (found_async_awaiter) {
+          break;
+        }
       } else {
-        AppendCodeFrames(thread, isolate, zone, stack_trace, frame, &code,
-                         &inlined_code, &deopt_frame);
+        function = code.function();
+        if (function.IsAsyncClosure() || function.IsAsyncGenClosure()) {
+          ActivationFrame* activation = CollectDartFrame(
+              isolate, frame->pc(), frame, code, Object::null_array(), 0,
+              ActivationFrame::kAsyncActivation);
+          ASSERT(activation != NULL);
+          stack_trace->AddActivation(activation);
+          // Grab the awaiter.
+          async_activation ^= activation->GetAsyncAwaiter();
+          break;
+        } else {
+          stack_trace->AddActivation(CollectDartFrame(
+              isolate, frame->pc(), frame, code, Object::null_array(), 0));
+        }
       }
     }
   }
 
   // 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;
   }
 
@@ skipping 102 matching lines @@
          (pause_info == kPauseOnAllExceptions));
   exc_pause_info_ = pause_info;
 }
 
 
 Dart_ExceptionPauseInfo Debugger::GetExceptionPauseInfo() const {
   return exc_pause_info_;
 }
 
 
-bool Debugger::ShouldPauseOnAsyncException(DebuggerStackTrace* stack_trace,
-                                           const Instance& exc) {
-  if (exc_pause_info_ == kNoPauseOnExceptions) {
-    return false;
-  }
-  if (exc_pause_info_ == kPauseOnAllExceptions) {
-    return true;
-  }
-  ASSERT(exc_pause_info_ == kPauseOnUnhandledExceptions);
-  for (intptr_t i = 0; i < stack_trace->Length(); i++) {
-    ActivationFrame* frame = stack_trace->FrameAt(i);
-    if (frame->HandlesException(exc)) {
-      if (FLAG_verbose_debug) {
-        OS::PrintErr("%s is caught by frame %s\n", exc.ToCString(),
-                     frame->ToCString());
-      }
-      return false;
-    }
-  }
-  return true;
-}
-
-
 bool Debugger::ShouldPauseOnException(DebuggerStackTrace* stack_trace,
                                       const Instance& exception) {
   if (exc_pause_info_ == kNoPauseOnExceptions) {
     return false;
   }
   if (exc_pause_info_ == kPauseOnAllExceptions) {
     return true;
   }
   ASSERT(exc_pause_info_ == kPauseOnUnhandledExceptions);
   ActivationFrame* handler_frame = stack_trace->GetHandlerFrame(exception);
   if (handler_frame == NULL) {
     // Did not find an exception handler that catches this exception.
     // Note that this check is not precise, since we can't check
     // uninstantiated types, i.e. types containing type parameters.
     // Thus, we may report an exception as unhandled when in fact
     // it will be caught once we unwind the stack.
     return true;
   }
   return false;
 }
 
 
 void Debugger::PauseException(const Instance& exc) {
+  if (FLAG_stress_async_stacks) {
+    CollectAwaiterReturnStackTrace();
+  }
   // We ignore this exception event when the VM is executing code invoked
   // by the debugger to evaluate variables values, when we see a nested
   // breakpoint or exception event, or if the debugger is not
   // interested in exception events.
   if (ignore_breakpoints_ || IsPaused() ||
       (exc_pause_info_ == kNoPauseOnExceptions)) {
     return;
   }
   DebuggerStackTrace* awaiter_stack_trace = CollectAwaiterReturnStackTrace();
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   if (awaiter_stack_trace != NULL) {
-    if (!ShouldPauseOnAsyncException(awaiter_stack_trace, exc)) {
+    if (!ShouldPauseOnException(awaiter_stack_trace, exc)) {
       return;
     }
   } else {
     if (!ShouldPauseOnException(stack_trace, exc)) {
       return;
     }
   }
   ServiceEvent event(isolate_, ServiceEvent::kPauseException);
   event.set_exception(&exc);
   if (stack_trace->Length() > 0) {
@@ skipping 1964 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart