Enable causal stacktrace in kernel

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 702 matching lines @@
           (depth_.function_ == 0) ? &result_->yield_context_variable : &temp,
           Symbols::AwaitContextVar());
     }
     {
       LocalVariable* temp =
           scope_->LookupVariable(Symbols::AsyncOperation(), true);
       if (temp != NULL) {
         scope_->CaptureVariable(temp);
       }
     }
+    if (FLAG_causal_async_stacks) {
+      LocalVariable* temp =
+          scope_->LookupVariable(Symbols::AsyncStackTraceVar(), true);
+      if (temp != NULL) {
+        scope_->CaptureVariable(temp);
+      }
+    }
   }
 }
 
 
 void ScopeBuilder::VisitYieldStatement(YieldStatement* node) {
   ASSERT(node->is_native());
   if (depth_.function_ == 0) {
     AddSwitchVariable();
     // Promote all currently visible local variables into the context.
     // TODO(27590) CaptureLocalVariables promotes to many variables into
@@ skipping 1816 matching lines @@
   Value* value = Pop();
   ASSERT(stack_ == NULL);
 
   const Function& function = parsed_function_->function();
   if (FLAG_support_debugger && position.IsDebugPause() &&
       !function.is_native()) {
     instructions <<=
         new (Z) DebugStepCheckInstr(position, RawPcDescriptors::kRuntimeCall);
   }
 
+  if (FLAG_causal_async_stacks &&
+      (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 Function& target = Function::ZoneHandle(
+        Z, I->object_store()->async_clear_thread_stack_trace());
+    ASSERT(!target.IsNull());
+    instructions += StaticCall(TokenPosition::kNoSource, target, 0);
+    instructions += Drop();
+  }
+
   ReturnInstr* return_instr = new (Z) ReturnInstr(position, value);
   if (exit_collector_ != NULL) exit_collector_->AddExit(return_instr);
 
   instructions <<= return_instr;
 
   return instructions.closed();
 }
 
 
 Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
@@ skipping 596 matching lines @@
     body += NullConstant();
     body += Return(dart_function.end_token_pos());
   }
 
   // If functions body contains any yield points build switch statement that
   // selects a continuation point based on the value of :await_jump_var.
   if (!yield_continuations_.is_empty()) {
     // The code we are building will be executed right after we enter
     // the function and before any nested contexts are allocated.
     // Reset current context_depth_ to match this.
-    intptr_t current_context_depth = context_depth_;
+    const intptr_t current_context_depth = context_depth_;
     context_depth_ = scopes_->yield_jump_variable->owner()->context_level();
 
     // Prepend an entry corresponding to normal entry to the function.
     yield_continuations_.InsertAt(
         0, YieldContinuation(new (Z) DropTempsInstr(0, NULL),
                              CatchClauseNode::kInvalidTryIndex));
     yield_continuations_[0].entry->LinkTo(body.entry);
 
     // Build a switch statement.
     Fragment dispatch;
@@ skipping 45 matching lines @@
 
       // False branch will contain the next comparison.
       dispatch = Fragment(dispatch.entry, otherwise);
       block = otherwise;
     }
     body = dispatch;
 
     context_depth_ = current_context_depth;
   }
 
+  if (FLAG_causal_async_stacks &&
+      (dart_function.IsAsyncClosure() || dart_function.IsAsyncGenClosure())) {
+    // The code we are building will be executed right after we enter
+    // the function and before any nested contexts are allocated.
+    // Reset current context_depth_ to match this.
+    const intptr_t current_context_depth = context_depth_;
+    context_depth_ = scopes_->yield_jump_variable->owner()->context_level();
+
+    Fragment instructions;
+    LocalScope* scope = parsed_function_->node_sequence()->scope();
+
+    const Function& target = Function::ZoneHandle(
+        Z, I->object_store()->async_set_thread_stack_trace());
+    ASSERT(!target.IsNull());
+
+    // Fetch and load :async_stack_trace
+    LocalVariable* async_stack_trace_var =
+        scope->LookupVariable(Symbols::AsyncStackTraceVar(), false);
+    ASSERT((async_stack_trace_var != NULL) &&
+           async_stack_trace_var->is_captured());
+    instructions += LoadLocal(async_stack_trace_var);
+    instructions += PushArgument();
+
+    // Call _asyncSetThreadStackTrace
+    instructions += StaticCall(TokenPosition::kNoSource, target, 1);
+    instructions += Drop();
+
+    body = instructions + body;
+    context_depth_ = current_context_depth;
+  }
+
   if (FLAG_support_debugger && function->position().IsDebugPause() &&
       !dart_function.is_native() && dart_function.is_debuggable()) {
     // If a switch was added above: Start the switch by injecting a debugable
     // safepoint so stepping over an await works.
     // If not, still start the body with a debugable safepoint 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 = dart_function.NumParameters();
@@ skipping 2845 matching lines @@
 
   fragment_ = continuation;
 }
 
 
 Fragment FlowGraphBuilder::TranslateFunctionNode(FunctionNode* node,
                                                  TreeNode* parent) {
   // The VM has a per-isolate table of functions indexed by the enclosing
   // function and token position.
   Function& function = Function::ZoneHandle(Z);
+  LocalScope* scope = NULL;
   for (intptr_t i = 0; i < scopes_->function_scopes.length(); ++i) {
     if (scopes_->function_scopes[i].function != node) continue;
 
     TokenPosition position = node->position();
     if (parent->IsFunctionDeclaration()) {
       position = FunctionDeclaration::Cast(parent)->position();
     }
     if (!position.IsReal()) {
       // Positions has to be unique in regards to the parent.
       // A non-real at this point is probably -1, we cannot blindly use that
       // as others might use it too. Create a new dummy non-real TokenPosition.
       position = TokenPosition(i).ToSynthetic();
     }
 
     // NOTE: This is not TokenPosition in the general sense!
     function = I->LookupClosureFunction(parsed_function_->function(), position);
+    scope = scopes_->function_scopes[i].scope;
     if (function.IsNull()) {
       const dart::String* name;
       if (parent->IsFunctionExpression()) {
         name = &Symbols::AnonymousClosure();
       } else {
         ASSERT(parent->IsFunctionDeclaration());
         name = &H.DartSymbol(
             FunctionDeclaration::Cast(parent)->variable()->name());
       }
       // NOTE: This is not TokenPosition in the general sense!
@@ skipping 13 matching lines @@
           function.set_modifier(RawFunction::kAsyncGen);
           break;
         default:
           // no special modifier
           break;
       }
       function.set_is_generated_body(node->async_marker() ==
                                      FunctionNode::kSyncYielding);
 
       function.set_end_token_pos(node->end_position());
-      LocalScope* scope = scopes_->function_scopes[i].scope;
       const ContextScope& context_scope =
           ContextScope::Handle(Z, scope->PreserveOuterScope(context_depth_));
       function.set_context_scope(context_scope);
       function.set_kernel_function(node);
       KernelReader::SetupFunctionParameters(H, T, dart::Class::Handle(Z),
                                             function, node,
                                             false,  // is_method
                                             true);  // is_closure
       // Finalize function type.
       Type& signature_type = Type::Handle(Z, function.SignatureType());
       signature_type ^= ClassFinalizer::FinalizeType(
           *active_class_.klass, signature_type, ClassFinalizer::kCanonicalize);
       function.SetSignatureType(signature_type);
 
       I->AddClosureFunction(function);
     }
     break;
   }
 
+  Fragment instructions;
+
+  if (FLAG_causal_async_stacks &&

[kustermann, 2017/02/23 10:30:37]

You can move this code to FlowGraphBuilder::BuildGraphOfFunction

if (dart_function.hasOriginalAysncMarker()) {
  // call async helper
  // store in :async_stack var.
}

+      (function.IsAsyncClosure() || function.IsAsyncGenClosure())) {
+    // :async_stack_trace = _asyncStackTraceHelper();
+    const dart::Library& async_lib =
+        dart::Library::Handle(dart::Library::AsyncLibrary());
+    const Function& target = Function::ZoneHandle(
+        Z,
+        async_lib.LookupFunctionAllowPrivate(Symbols::AsyncStackTraceHelper()));
+    ASSERT(!target.IsNull());
+    instructions += StaticCall(TokenPosition::kNoSource, target, 0);
+    LocalVariable* async_stack_trace_var =
+        scope->LookupVariable(Symbols::AsyncStackTraceVar(), false);
+    ASSERT(async_stack_trace_var != NULL);
+    instructions += StoreLocal(TokenPosition::kNoSource, async_stack_trace_var);
+    instructions += Drop();
+  }
+
   const dart::Class& closure_class =
       dart::Class::ZoneHandle(Z, I->object_store()->closure_class());
   ASSERT(!closure_class.IsNull());
-  Fragment instructions = AllocateObject(closure_class, function);
+  instructions += AllocateObject(closure_class, function);
   LocalVariable* closure = MakeTemporary();
 
   // TODO(27590): Generic closures need type arguments.
 
   // Store the function and the context in the closure.
   instructions += LoadLocal(closure);
   instructions += Constant(function);
   instructions += StoreInstanceField(Closure::function_offset());
 
   instructions += LoadLocal(closure);
@@ skipping 110 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)