Track the 'awaiter return' call stack use it to detect uncaught exceptions in async functions

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 1842 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 1872 matching lines @@
   catch_block->Visit(&for_catch);
   owner()->set_catch_try_index(prev_catch_try_index);
 
   // NOTE: The implicit variables ':saved_try_context_var', ':exception_var'
   // and ':stack_trace_var' can never be captured variables.
   ASSERT(!catch_block->context_var().is_captured());
   ASSERT(!catch_block->exception_var().is_captured());
   ASSERT(!catch_block->stacktrace_var().is_captured());
 
   CatchBlockEntryInstr* catch_entry = new (Z) CatchBlockEntryInstr(
+      catch_block->token_pos(), (node->token_pos() == TokenPosition::kNoSource),
       owner()->AllocateBlockId(), catch_handler_index, owner()->graph_entry(),
       catch_block->handler_types(), try_handler_index,
       catch_block->exception_var(), catch_block->stacktrace_var(),
       catch_block->needs_stacktrace(), Thread::Current()->GetNextDeoptId());
   owner()->AddCatchEntry(catch_entry);
   AppendFragment(catch_entry, for_catch);
 
   if (for_catch.is_open()) {
     JoinEntryInstr* join = new (Z)
         JoinEntryInstr(owner()->AllocateBlockId(), original_handler_index);
@@ skipping 22 matching lines @@
       for_finally.PushArgument(stacktrace);
       for_finally.AddInstruction(
           new (Z) ReThrowInstr(catch_block->token_pos(), catch_handler_index));
       for_finally.CloseFragment();
     }
     ASSERT(!for_finally.is_open());
 
     const Array& types = Array::ZoneHandle(Z, Array::New(1, Heap::kOld));
     types.SetAt(0, Object::dynamic_type());
     CatchBlockEntryInstr* finally_entry = new (Z) CatchBlockEntryInstr(
+        finally_block->token_pos(),
+        true,  // this is not a catch block from user code.
         owner()->AllocateBlockId(), original_handler_index,
         owner()->graph_entry(), types, catch_handler_index,
         catch_block->exception_var(), catch_block->stacktrace_var(),
         catch_block->needs_stacktrace(), Thread::Current()->GetNextDeoptId());
     owner()->AddCatchEntry(finally_entry);
     AppendFragment(finally_entry, for_finally);
   }
 
   // Generate code for the finally block if one exists.
   if ((finally_block != NULL) && is_open()) {
@@ skipping 227 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