Sane asynchronous debugging and stack traces

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
@@ skipping 305 matching lines @@
       last_used_block_id_(0),  // 0 is used for the graph entry.
       try_index_(CatchClauseNode::kInvalidTryIndex),
       catch_try_index_(CatchClauseNode::kInvalidTryIndex),
       loop_depth_(0),
       graph_entry_(NULL),
       temp_count_(0),
       args_pushed_(0),
       nesting_stack_(NULL),
       osr_id_(osr_id),
       jump_count_(0),
-      await_joins_(new (Z) ZoneGrowableArray<JoinEntryInstr*>()) {}
+      await_joins_(new (Z) ZoneGrowableArray<JoinEntryInstr*>()),
+      await_token_positions_(new (Z) ZoneGrowableArray<TokenPosition>()) {}
 
 
 void FlowGraphBuilder::AddCatchEntry(CatchBlockEntryInstr* entry) {
   graph_entry_->AddCatchEntry(entry);
 }
 
 
 void InlineExitCollector::PrepareGraphs(FlowGraph* callee_graph) {
   ASSERT(callee_graph->graph_entry()->SuccessorCount() == 1);
   ASSERT(callee_graph->max_block_id() > caller_graph_->max_block_id());
@@ skipping 802 matching lines @@
     // However, factories may create an instance of the wrong type.
     if (!is_implicit_dynamic_getter && !function.IsGenerativeConstructor()) {
       const AbstractType& dst_type =
           AbstractType::ZoneHandle(Z, function.result_type());
       return_value =
           BuildAssignableValue(node->value()->token_pos(), return_value,
                                dst_type, Symbols::FunctionResult());
     }
   }
 
+  if (function.IsAsyncClosure() || function.IsAsyncGenClosure()) {
+    // We are returning from an asynchronous closure. Before we do that, be
+    // sure to clear the thread's asynchronous stack trace.
+    const Library& async_lib = Library::Handle(Library::AsyncLibrary());
+    ASSERT(!async_lib.IsNull());
+    const String& private_name = String::ZoneHandle(
+        async_lib.PrivateName(Symbols::ClearAsyncThreadStackTrace()));
+    ASSERT(!private_name.IsNull());
+    const Function& async_clear_thread_stack_trace = Function::ZoneHandle(
+        Z,
+        Resolver::ResolveStatic(async_lib, String::ZoneHandle(String::null()),
+                                private_name, 0, Object::null_array()));
+    ASSERT(!async_clear_thread_stack_trace.IsNull());
+    // Mark that this function is not debuggable.
+    async_clear_thread_stack_trace.set_is_debuggable(false);
+    ZoneGrowableArray<PushArgumentInstr*>* no_arguments =
+        new (Z) ZoneGrowableArray<PushArgumentInstr*>(0);
+    StaticCallInstr* call_async_clear_thread_stack_trace = new (Z)
+        StaticCallInstr(node->token_pos().ToSynthetic(),
+                        async_clear_thread_stack_trace, Object::null_array(),
+                        no_arguments, owner()->ic_data_array());
+    Do(call_async_clear_thread_stack_trace);
+  }
+
   // Async functions contain two types of return statements:
   // 1) Returns that should complete the completer once all finally blocks have
   //    been inlined (call: :async_completer.complete(return_value)). These
   //    returns end up returning null in the end.
   // 2) "Continuation" returns that should not complete the completer but return
   //    the value.
   //
   // We distinguish those kinds of nodes via is_regular_return().
   //
   if (function.IsAsyncClosure() &&
       (node->return_type() == ReturnNode::kRegular)) {
     // Temporary store the computed return value.
     Do(BuildStoreExprTemp(return_value, node->token_pos()));
 
     LocalVariable* rcv_var =
         node->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
     ASSERT(rcv_var != NULL && rcv_var->is_captured());
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
     Value* rcv_value = Bind(BuildLoadLocal(*rcv_var, node->token_pos()));
     arguments->Add(PushArgument(rcv_value));
     Value* returned_value = Bind(BuildLoadExprTemp(node->token_pos()));
     arguments->Add(PushArgument(returned_value));
-    InstanceCallInstr* call = new (Z) InstanceCallInstr(
-        node->token_pos(), Symbols::CompleterComplete(), Token::kILLEGAL,
-        arguments, Object::null_array(), 1, owner()->ic_data_array());
+
+    const Library& async_library = Library::Handle(Library::AsyncLibrary());
+    ASSERT(!async_library.IsNull());
+
+    const Function& complete_on_async_return_function =
+        Function::ZoneHandle(async_library.LookupFunctionAllowPrivate(
+            Symbols::CompleterCompleteOnAsyncReturn()));
+    ASSERT(!complete_on_async_return_function.IsNull());
+
+    StaticCallInstr* call = new (Z) StaticCallInstr(
+        node->token_pos().ToSynthetic(), complete_on_async_return_function,
+        Object::null_array(), arguments, owner()->ic_data_array());
     Do(call);
 
     // Rebind the return value for the actual return call to be null.
     return_value = BuildNullValue(node->token_pos());
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (HasContextScope()) {
     UnchainContexts(current_context_level);
@@ skipping 989 matching lines @@
   ASSERT((ctx_var != NULL) && ctx_var->is_captured());
   const intptr_t jump_count = owner()->next_await_counter();
   ASSERT(jump_count >= 0);
   // Sanity check that we always add a JoinEntryInstr before adding a new
   // state.
   ASSERT(jump_count == owner()->await_joins()->length());
   // Store the counter in :await_jump_var.
   Value* jump_val = Bind(new (Z) ConstantInstr(
       Smi::ZoneHandle(Z, Smi::New(jump_count)), node->token_pos()));
   Do(BuildStoreLocal(*jump_var, jump_val, node->token_pos()));
+  // Add a mapping from jump_count -> token_position.
+  owner()->AppendAwaitTokenPosition(node->token_pos());
   // Save the current context for resuming.
   BuildSaveContext(*ctx_var, node->token_pos());
 }
 
 
 intptr_t EffectGraphVisitor::GetCurrentTempLocalIndex() const {
   return kFirstLocalSlotFromFp - owner()->num_stack_locals() -
          owner()->num_copied_params() - owner()->args_pushed() -
          owner()->temp_count() + 1;
 }
@@ skipping 1601 matching lines @@
           // the function.
           Value* null_constant = Bind(
               new (Z) ConstantInstr(Object::ZoneHandle(Z, Object::null())));
           Do(BuildStoreLocal(*temp_local, null_constant,
                              ST(node->token_pos())));
         }
       }
     }
   }
 
+  if (is_top_level_sequence &&
+      (function.IsAsyncClosure() || function.IsAsyncGenClosure())) {
+    LocalScope* top_scope = node->scope();
+    // Fetch the :async_stack_trace variable and store it into the thread.
+    LocalVariable* async_stack_trace_var =
+        top_scope->LookupVariable(Symbols::AsyncStackTraceVar(), false);
+    ASSERT((async_stack_trace_var != NULL) &&
+           async_stack_trace_var->is_captured());
+    // Load :async_stack_trace
+    Value* async_stack_trace_value = Bind(BuildLoadLocal(
+        *async_stack_trace_var, node->token_pos().ToSynthetic()));
+    // Setup arguments for _asyncSetThreadStackTrace.
+    ZoneGrowableArray<PushArgumentInstr*>* arguments =
+        new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
+    arguments->Add(PushArgument(async_stack_trace_value));
+
+    // Lookup _asyncSetThreadStackTrace
+    const Library& async_lib = Library::Handle(Library::AsyncLibrary());
+    ASSERT(!async_lib.IsNull());
+    const String& private_name = String::ZoneHandle(
+        async_lib.PrivateName(Symbols::SetAsyncThreadStackTrace()));
+    ASSERT(!private_name.IsNull());
+    const Function& async_set_thread_stack_trace = Function::ZoneHandle(
+        Z,
+        Resolver::ResolveStatic(async_lib, String::ZoneHandle(String::null()),
+                                private_name, 1, Object::null_array()));
+    ASSERT(!async_set_thread_stack_trace.IsNull());
+    // Mark that this function is not debuggable.
+    async_set_thread_stack_trace.set_is_debuggable(false);
+    // Call _asyncSetThreadStackTrace
+    StaticCallInstr* call_async_set_thread_stack_trace = new (Z)
+        StaticCallInstr(node->token_pos().ToSynthetic(),
+                        async_set_thread_stack_trace, Object::null_array(),
+                        arguments, owner()->ic_data_array());
+    Do(call_async_set_thread_stack_trace);
+  }
+
   if (FLAG_support_debugger && is_top_level_sequence &&
       function.is_debuggable()) {
     // Place a debug check at method entry to ensure breaking on a method always
     // happens, even if there are no assignments/calls/runtimecalls in the first
     // basic block. Place this check at the last parameter to ensure parameters
     // are in scope in the debugger at method entry.
     const int num_params = function.NumParameters();
     TokenPosition check_pos = TokenPosition::kNoSource;
     if (num_params > 0) {
       const LocalVariable& parameter = *scope->VariableAt(num_params - 1);
@@ skipping 88 matching lines @@
     // We are at the top level. Fetch the corresponding scope.
     LocalScope* top_scope = node->scope();
     LocalVariable* jump_var =
         top_scope->LookupVariable(Symbols::AwaitJumpVar(), false);
     ASSERT(jump_var != NULL && jump_var->is_captured());
     Instruction* saved_entry = entry_;
     Instruction* saved_exit = exit_;
     entry_ = NULL;
     exit_ = NULL;
 
+    // Load the jump counter.
     LoadLocalNode* load_jump_count =
         new (Z) LoadLocalNode(node->token_pos(), jump_var);
     ComparisonNode* check_jump_count;
     const intptr_t num_await_states = owner()->await_joins()->length();
 
     LocalVariable* old_context =
         top_scope->LookupVariable(Symbols::AwaitContextVar(), false);
     for (intptr_t i = 0; i < num_await_states; i++) {
       check_jump_count = new (Z)
           ComparisonNode(ST(node->token_pos()), Token::kEQ, load_jump_count,
@@ skipping 407 matching lines @@
 
   // When compiling for OSR, use a depth first search to prune instructions
   // unreachable from the OSR entry. Catch entries are always considered
   // reachable, even if they become unreachable after OSR.
   if (osr_id_ != Compiler::kNoOSRDeoptId) {
     PruneUnreachable();
   }
 
   FlowGraph* graph =
       new (Z) FlowGraph(parsed_function(), graph_entry_, last_used_block_id_);
+  graph->set_await_token_positions(await_token_positions_);
   return graph;
 }
 
 
+void FlowGraphBuilder::AppendAwaitTokenPosition(TokenPosition token_pos) {
+  await_token_positions_->Add(token_pos);
+}
+
+
 void FlowGraphBuilder::PruneUnreachable() {
   ASSERT(osr_id_ != Compiler::kNoOSRDeoptId);
   BitVector* block_marks = new (Z) BitVector(Z, last_used_block_id_ + 1);
   bool found =
       graph_entry_->PruneUnreachable(graph_entry_, NULL, osr_id_, block_marks);
   ASSERT(found);
 }
 
 
 void FlowGraphBuilder::Bailout(const char* reason) const {
   parsed_function_.Bailout("FlowGraphBuilder", reason);
 }
 
 }  // namespace dart