Detect unhandled exceptions in async functions without an awaiter

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 921 matching lines @@
   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);
     const int8_t kind = var_info.kind();
     if (kind == RawLocalVarDescriptors::kSavedCurrentContext) {
       if (FLAG_trace_debugger_stacktrace) {
         OS::PrintErr("\tFound saved current ctx at index %d\n",
                      var_info.index());
       }
-      ctx_ ^= GetStackVar(var_info.index());
+      const Object& obj = Object::Handle(GetStackVar(var_info.index()));

[siva, 2017/04/13 01:22:58]

This handle could be hoisted outside the for loop.

[Cutch, 2017/04/13 14:34:44]

Done.

+      if (obj.IsClosure()) {
+        ASSERT(function().name() == Symbols::Call().raw());
+        ASSERT(function().IsInvokeFieldDispatcher());
+        // Closure.call frames.
+        ctx_ ^= Closure::Cast(obj).context();
+      } else if (obj.IsContext()) {
+        ctx_ ^= Context::Cast(obj).raw();
+      } else {
+        ASSERT(obj.IsNull());
+      }
       return ctx_;
     }
   }
   return Context::ZoneHandle(Context::null());

[siva, 2017/04/13 01:30:06]

Why is it not ok to use the same ctx_ as above
i.e
ctx ^= Context::null();
return ctx_;

[Cutch, 2017/04/13 14:34:44]

Done.

 }
 
 
 RawObject* ActivationFrame::GetAsyncOperation() {
   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) == Symbols::AsyncOperation().raw()) {
@@ skipping 1011 matching lines @@
     }
     // Follow the link.
     async_stack_trace = async_stack_trace.async_link();
   }
 
   return stack_trace;
 }
 
 
 DebuggerStackTrace* Debugger::CollectAwaiterReturnStackTrace() {
-  if (!FLAG_causal_async_stacks) {
+  if (!FLAG_async_debugger) {
     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);
   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);
-
+  bool stack_has_async_function = false;
   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()) {
         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 = it.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);
+            stack_has_async_function = true;
             // 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 {
         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);
+          stack_has_async_function = true;
           // Grab the awaiter.
           async_activation ^= activation->GetAsyncAwaiter();
+          async_stack_trace ^= activation->GetCausalStack();
           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()) {
+  // If the stack doesn't have any async functions on it, return NULL.
+  if (!stack_has_async_function) {
     return NULL;
   }
 
   // Append the awaiter return call stack.
   while (!async_activation.IsNull()) {
     ActivationFrame* activation = new (zone) ActivationFrame(async_activation);
     activation->ExtractTokenPositionFromAsyncClosure();
     stack_trace->AddActivation(activation);
     next_async_activation = activation->GetAsyncAwaiter();
     if (next_async_activation.IsNull()) {
@@ skipping 2280 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart