Add support for sync* and yield

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/class_finalizer.h"
@@ skipping 1056 matching lines @@
 
   // 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.is_async_closure() &&
+  if (function.IsAsyncClosure() &&
       (node->return_type() == ReturnNode::kRegular)) {
     // Temporary store the computed return value.
     Do(BuildStoreExprTemp(return_value));
 
-    LocalVariable* rcv_var = node->scope()->LookupVariable(
-        Symbols::AsyncCompleter(), false);
+    LocalVariable* rcv_var =
+        node->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
     ASSERT(rcv_var != NULL && rcv_var->is_captured());
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new(I) ZoneGrowableArray<PushArgumentInstr*>(2);
     Value* rcv_value = Bind(BuildLoadLocal(*rcv_var));
     arguments->Add(PushArgument(rcv_value));
     Value* returned_value = Bind(BuildLoadExprTemp());
     arguments->Add(PushArgument(returned_value));
     InstanceCallInstr* call = new(I) InstanceCallInstr(
         Scanner::kNoSourcePos,
         Symbols::CompleterComplete(),
         Token::kILLEGAL,
         arguments,
         Object::null_array(),
         1,
         owner()->ic_data_array());
     Do(call);
 
     // Rebind the return value for the actual return call to be null.
     return_value = BuildNullValue();
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (HasContextScope()) {
     UnchainContexts(current_context_level);
   }
 
-
   AddReturnExit(node->token_pos(), return_value);
 
-  if (function.is_async_closure() &&
+  if ((function.IsAsyncClosure() || function.IsSyncGenClosure()) &&
       (node->return_type() == ReturnNode::kContinuationTarget)) {
     JoinEntryInstr* const join = new(I) JoinEntryInstr(
         owner()->AllocateBlockId(), owner()->try_index());
     owner()->await_joins()->Add(join);
     exit_ = join;
   }
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
@@ skipping 349 matching lines @@
   return new(I) AssertAssignableInstr(token_pos,
                                       value,
                                       instantiator,
                                       instantiator_type_arguments,
                                       dst_type,
                                       dst_name,
                                       deopt_id);
 }
 
 
+void EffectGraphVisitor::BuildYieldJump(LocalVariable* old_context,
+                                        LocalVariable* iterator_param,
+                                        const intptr_t old_ctx_level,
+                                        JoinEntryInstr* target) {
+  // Building a jump consists of the following actions:
+  // * Load the generator body's iterator parameter (:iterator)
+  //   from the current context into a temporary.
+  // * Restore the old context from :await_cxt_var.
+  // * Copy the iterator saved above into the restored context.
+  // * Append a Goto to the target's join.
+  ASSERT((iterator_param != NULL) && iterator_param->is_captured());
+  ASSERT((old_context != NULL) && old_context->is_captured());
+  // Before restoring the context we need to temporarily save the
+  // iterator parameter.
+  LocalVariable* temp_iterator_var =
+      EnterTempLocalScope(Bind(BuildLoadLocal(*iterator_param)));
+
+  // Restore the saved continuation context, i.e. the context that was
+  // saved into :await_ctx_var before the closure suspended.
+  BuildRestoreContext(*old_context);
+
+  // Store the continuation result and continuation error values into
+  // the restored context.
+
+  // FlowGraphBuilder is at top context level, but the continuation
+  // target has possibly been recorded in a nested context (old_ctx_level).
+  // We need to unroll manually here.
+  intptr_t delta =
+      old_ctx_level - iterator_param->owner()->context_level();
+  ASSERT(delta >= 0);
+  Value* context = Bind(BuildCurrentContext());
+  while (delta-- > 0) {
+    context = Bind(new(I) LoadFieldInstr(
+        context, Context::parent_offset(), Type::ZoneHandle(I, Type::null()),
+        Scanner::kNoSourcePos));
+  }
+  LocalVariable* temp_context_var = EnterTempLocalScope(context);
+
+  Value* context_val = Bind(new(I) LoadLocalInstr(*temp_context_var));
+  Value* store_val = Bind(new(I) LoadLocalInstr(*temp_iterator_var));
+  StoreInstanceFieldInstr* store = new(I) StoreInstanceFieldInstr(
+      Context::variable_offset(iterator_param->index()),
+      context_val,
+      store_val,
+      kEmitStoreBarrier,
+      Scanner::kNoSourcePos);
+  Do(store);
+
+  Do(ExitTempLocalScope(temp_context_var));
+  Do(ExitTempLocalScope(temp_iterator_var));
+
+  // Goto saved join.
+  Goto(target);
+}
+
+
 void EffectGraphVisitor::BuildAwaitJump(LocalVariable* old_context,
                                         LocalVariable* continuation_result,
                                         LocalVariable* continuation_error,
                                         const intptr_t old_ctx_level,
                                         JoinEntryInstr* target) {
   // Building a jump consists of the following actions:
-  // * Record the current continuation result in a temporary.
-  // * Restore the old context.
-  // * Overwrite the old context's continuation result with the temporary.
+  // * Load the current continuation result parameter (:async_result)
+  //   and continuation error parameter (:async_error_param) from
+  //   the current context into temporaries.
+  // * Restore the old context from :await_cxt_var.
+  // * Copy the result and error parameters saved above into the restored
+  //   context.
   // * Append a Goto to the target's join.
   ASSERT((continuation_result != NULL) && continuation_result->is_captured());
   ASSERT((continuation_error != NULL) && continuation_error->is_captured());
   ASSERT((old_context != NULL) && old_context->is_captured());
   // Before restoring the continuation context we need to temporary save the
   // result and error parameter.
-  LocalVariable* temp_result_var = EnterTempLocalScope(
-      Bind(BuildLoadLocal(*continuation_result)));
-  LocalVariable* temp_error_var = EnterTempLocalScope(
-      Bind(BuildLoadLocal(*continuation_error)));
-  // Restore the saved continuation context.
+  LocalVariable* temp_result_var =
+      EnterTempLocalScope(Bind(BuildLoadLocal(*continuation_result)));
+  LocalVariable* temp_error_var =
+      EnterTempLocalScope(Bind(BuildLoadLocal(*continuation_error)));
+
+  // Restore the saved continuation context, i.e. the context that was
+  // saved into :await_ctx_var before the closure suspended.
   BuildRestoreContext(*old_context);
 
-  // Pass over the continuation result.
+  // Store the continuation result and continuation error values into
+  // the restored context.
 
   // FlowGraphBuilder is at top context level, but the await target has possibly
   // been recorded in a nested context (old_ctx_level). We need to unroll
   // manually here.
-  intptr_t delta = old_ctx_level -
-                   continuation_result->owner()->context_level();
+  intptr_t delta =
+      old_ctx_level - continuation_result->owner()->context_level();
   ASSERT(delta >= 0);
   Value* context = Bind(BuildCurrentContext());
   while (delta-- > 0) {
     context = Bind(new(I) LoadFieldInstr(
         context, Context::parent_offset(), Type::ZoneHandle(I, Type::null()),
         Scanner::kNoSourcePos));
   }
   LocalVariable* temp_context_var = EnterTempLocalScope(context);
 
   Value* context_val = Bind(new(I) LoadLocalInstr(*temp_context_var));
@@ skipping 2204 matching lines @@
     Do(BuildStoreContext(context));
   }
 }
 
 
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
+  const Function& function = owner()->parsed_function().function();

[srdjan, 2015/02/04 19:29:12]

owner()->function();

[hausner, 2015/02/04 22:09:24]

Done.

   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   const bool is_top_level_sequence =
       node == owner()->parsed_function().node_sequence();
   // The outermost function sequence cannot contain a label.
   ASSERT((node->label() == NULL) || !is_top_level_sequence);
   NestedBlock nested_block(owner(), node);
 
   if (num_context_variables > 0) {
     // The local scope declares variables that are captured.
@@ skipping 12 matching lines @@
                                           kEmitStoreBarrier,
                                           Scanner::kNoSourcePos));
       }
       Do(BuildStoreContext(Bind(ExitTempLocalScope(tmp_var))));
     }
 
     // If this node_sequence is the body of the function being compiled, copy
     // the captured parameters from the frame into the context.
     if (is_top_level_sequence) {
       ASSERT(scope->context_level() == 1);
-      const Function& function = owner()->function();
       const int num_params = function.NumParameters();
       int param_frame_index = (num_params == function.num_fixed_parameters()) ?
           (kParamEndSlotFromFp + num_params) : kFirstLocalSlotFromFp;
       for (int pos = 0; pos < num_params; param_frame_index--, pos++) {
         const LocalVariable& parameter = *scope->VariableAt(pos);
         ASSERT(parameter.owner() == scope);
         if (parameter.is_captured()) {
           // Create a temporary local describing the original position.
           const String& temp_name = Symbols::TempParam();
           LocalVariable* temp_local = new(I) LocalVariable(
@@ skipping 17 matching lines @@
           Value* null_constant = Bind(new(I) ConstantInstr(
               Object::ZoneHandle(I, Object::null())));
           Do(BuildStoreLocal(*temp_local, null_constant));
         }
       }
     }
   }
 
   // This check may be deleted if the generated code is leaf.
   // Native functions don't need a stack check at entry.
-  const Function& function = owner()->function();
   if (is_top_level_sequence && !function.is_native()) {
     // Always allocate CheckOverflowInstr so that deopt-ids match regardless
     // if we inline or not.
     if (!function.IsImplicitGetterFunction() &&
         !function.IsImplicitSetterFunction()) {
       CheckStackOverflowInstr* check =
           new(I) CheckStackOverflowInstr(function.token_pos(), 0);
       // If we are inlining don't actually attach the stack check. We must still
       // create the stack check in order to allocate a deopt id.
       if (!owner()->IsInlining()) {
         AddInstruction(check);
       }
     }
   }
 
   if (FLAG_enable_type_checks && is_top_level_sequence) {
-    const Function& function = owner()->function();
     const int num_params = function.NumParameters();
     int pos = 0;
     if (function.IsConstructor()) {
       // Skip type checking of receiver and phase for constructor functions.
       pos = 2;
     } else if (function.IsFactory() || function.IsDynamicFunction()) {
       // Skip type checking of type arguments for factory functions.
       // Skip type checking of receiver for instance functions.
       pos = 1;
     }
     while (pos < num_params) {
       const LocalVariable& parameter = *scope->VariableAt(pos);
       ASSERT(parameter.owner() == scope);
       if (!CanSkipTypeCheck(parameter.token_pos(),
                             NULL,
                             parameter.type(),
                             parameter.name())) {
         Value* parameter_value = Bind(BuildLoadLocal(parameter));
         Do(BuildAssertAssignable(parameter.token_pos(),
                                  parameter_value,
                                  parameter.type(),
                                  parameter.name()));
       }
       pos++;
     }
   }
 
   // Continuation part:
-  // If this node sequence is the body of an async closure leave room for a
-  // preamble. The preamble is generated after visiting the body.
+  // If this node sequence is the body of a function with continuations,
+  // leave room for a preamble.
+  // The preamble is generated after visiting the body.
   GotoInstr* preamble_start = NULL;
-  if (is_top_level_sequence && (owner()->function().is_async_closure())) {
+  if (is_top_level_sequence &&
+      (function.IsAsyncClosure() || function.IsSyncGenClosure())) {
     JoinEntryInstr* preamble_end = new(I) JoinEntryInstr(
         owner()->AllocateBlockId(), owner()->try_index());
     ASSERT(exit() != NULL);
     exit()->Goto(preamble_end);
     ASSERT(exit()->next()->IsGoto());
     preamble_start = exit()->next()->AsGoto();
     ASSERT(preamble_start->IsGoto());
     exit_ = preamble_end;
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) {
       // E.g., because of a JumpNode.
       break;
     }
   }
 
   // Continuation part:
-  // After generating the CFG for the body we can create the preamble because we
-  // know exactly how many continuation states we need.
-  if (is_top_level_sequence && (owner()->function().is_async_closure())) {
+  // After generating the CFG for the body we can create the preamble
+  // because we know exactly how many continuation states we need.
+  if (is_top_level_sequence &&
+      (function.IsAsyncClosure() || function.IsSyncGenClosure())) {
     ASSERT(preamble_start != NULL);
     // 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;
 
-    LoadLocalNode* load_jump_count = new(I) LoadLocalNode(
-        Scanner::kNoSourcePos, jump_var);
+    LoadLocalNode* load_jump_count =
+        new(I) LoadLocalNode(Scanner::kNoSourcePos, 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);
-    LocalVariable* continuation_result = top_scope->LookupVariable(
-        Symbols::AsyncOperationParam(), false);
-    LocalVariable* continuation_error = top_scope->LookupVariable(
-        Symbols::AsyncOperationErrorParam(), false);
     for (intptr_t i = 0; i < num_await_states; i++) {
       check_jump_count = new(I) ComparisonNode(
           Scanner::kNoSourcePos,
           Token::kEQ,
           load_jump_count,
           new(I) LiteralNode(
               Scanner::kNoSourcePos, Smi::ZoneHandle(I, Smi::New(i))));
       TestGraphVisitor for_test(owner(), Scanner::kNoSourcePos);
       check_jump_count->Visit(&for_test);
       EffectGraphVisitor for_true(owner());
       EffectGraphVisitor for_false(owner());
 
-      for_true.BuildAwaitJump(old_context,
-                              continuation_result,
-                              continuation_error,
-                              (*owner()->await_levels())[i],
-                              (*owner()->await_joins())[i]);
+      if (function.IsAsyncClosure()) {
+        LocalVariable* result_param =
+            top_scope->LookupVariable(Symbols::AsyncOperationParam(), false);
+        LocalVariable* error_param =
+            top_scope->LookupVariable(Symbols::AsyncOperationErrorParam(),
+                                      false);
+        for_true.BuildAwaitJump(old_context,
+                                result_param,
+                                error_param,
+                                (*owner()->await_levels())[i],
+                                (*owner()->await_joins())[i]);
+      } else {
+        ASSERT(function.IsSyncGenClosure());
+        LocalVariable* iterator_param =
+            top_scope->LookupVariable(Symbols::IteratorParameter(), false);
+        for_true.BuildYieldJump(old_context,
+                                iterator_param,
+                                (*owner()->await_levels())[i],
+                                (*owner()->await_joins())[i]);
+      }
       Join(for_test, for_true, for_false);
 
       if (i == 0) {
         // Manually link up the preamble start.
         preamble_start->previous()->set_next(for_test.entry());
         for_test.entry()->set_previous(preamble_start->previous());
       }
       if (i == (num_await_states - 1)) {
         // Link up preamble end.
         if (exit_ == NULL) {
@@ skipping 380 matching lines @@
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart