Allow inlining of closures with a context change.

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/code_descriptors.h"
@@ skipping 524 matching lines @@
 
 
 Definition* EffectGraphVisitor::BuildLoadExprTemp() {
   return BuildLoadLocal(*owner()->parsed_function()->expression_temp_var());
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreLocal(
     const LocalVariable& local, Value* value, bool result_is_needed) {
   if (local.is_captured()) {
-    InlineBailout("EffectGraphVisitor::BuildStoreLocal (context)");
     if (result_is_needed) {
       value = Bind(BuildStoreExprTemp(value));
     }
 
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(new CurrentContextInstr());
     while (delta-- > 0) {
       context = Bind(new LoadFieldInstr(
@@ skipping 12 matching lines @@
       return store;
     }
   } else {
     return new StoreLocalInstr(local, value);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local) {
   if (local.is_captured()) {
-    InlineBailout("EffectGraphVisitor::BuildLoadLocal (context)");
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(new CurrentContextInstr());
     while (delta-- > 0) {
       context = Bind(new LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle()));
     }
     return new LoadFieldInstr(context,
                               Context::variable_offset(local.index()),
                               local.type());
   } else {
     return new LoadLocalInstr(local);
   }
 }
 
 
 // Stores current context into the 'variable'
-void EffectGraphVisitor::BuildStoreContext(const LocalVariable& variable) {
+void EffectGraphVisitor::BuildSaveContext(const LocalVariable& variable) {
   Value* context = Bind(new CurrentContextInstr());
   Do(BuildStoreLocal(variable, context, kResultNotNeeded));
 }
 
 
 // Loads context saved in 'context_variable' into the current context.
-void EffectGraphVisitor::BuildLoadContext(const LocalVariable& variable) {
+void EffectGraphVisitor::BuildRestoreContext(const LocalVariable& variable) {
   Value* load_saved_context = Bind(BuildLoadLocal(variable));
   AddInstruction(new StoreContextInstr(load_saved_context));
 }
 
 
 void TestGraphVisitor::ConnectBranchesTo(
     const GrowableArray<TargetEntryInstr**>& branches,
     JoinEntryInstr* join) const {
   ASSERT(!branches.is_empty());
   for (intptr_t i = 0; i < branches.length(); i++) {
@@ skipping 201 matching lines @@
                                           return_value,
                                           dst_type,
                                           Symbols::FunctionResult());
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function()->saved_entry_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
-    BuildLoadContext(*owner()->parsed_function()->saved_entry_context_var());
+    BuildRestoreContext(*owner()->parsed_function()->saved_entry_context_var());
   } else {
     while (current_context_level-- > 0) {
       UnchainContext();
     }
   }
 
   AddReturnExit(node->token_pos(), return_value);
 }
 
 
@@ skipping 1294 matching lines @@
   Append(for_closure);
   PushArgumentInstr* push_closure = PushArgument(for_closure.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
   // Save context around the call.
   ASSERT(owner()->parsed_function()->saved_current_context_var() != NULL);
-  BuildStoreContext(*owner()->parsed_function()->saved_current_context_var());
+  BuildSaveContext(*owner()->parsed_function()->saved_current_context_var());
   return new ClosureCallInstr(node, arguments);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Do(BuildClosureCall(node));
   // Restore context from saved location.
   ASSERT(owner()->parsed_function()->saved_current_context_var() != NULL);
-  BuildLoadContext(*owner()->parsed_function()->saved_current_context_var());
+  BuildRestoreContext(*owner()->parsed_function()->saved_current_context_var());
 }
 
 
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Value* result = Bind(BuildClosureCall(node));
   // Restore context from temp.
   ASSERT(owner()->parsed_function()->saved_current_context_var() != NULL);
-  BuildLoadContext(*owner()->parsed_function()->saved_current_context_var());
+  BuildRestoreContext(*owner()->parsed_function()->saved_current_context_var());
   ReturnValue(result);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitCloneContextNode (context)");
   Value* context = Bind(new CurrentContextInstr());
   Value* clone = Bind(new CloneContextInstr(node->token_pos(), context));
   AddInstruction(new StoreContextInstr(clone));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
@@ skipping 886 matching lines @@
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function()->node_sequence()) &&
          (owner()->parsed_function()->saved_entry_context_var() != NULL);
 }
 
 
 void EffectGraphVisitor::UnchainContext() {
-  InlineBailout("EffectGraphVisitor::UnchainContext (context)");
   Value* context = Bind(new CurrentContextInstr());
   Value* parent = Bind(
       new LoadFieldInstr(context,
                          Context::parent_offset(),
                          Type::ZoneHandle()));  // Not an instance, no type.
   AddInstruction(new StoreContextInstr(parent));
 }
 
 
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   int previous_context_level = owner()->context_level();
   if (num_context_variables > 0) {
-    InlineBailout("EffectGraphVisitor::VisitSequenceNode (context)");
     // The loop local scope declares variables that are captured.
     // Allocate and chain a new context.
     // Allocate context computation (uses current CTX)
     Value* allocated_context =
         Bind(new AllocateContextInstr(node->token_pos(),
                                       num_context_variables));
     { LocalVariable* tmp_var = EnterTempLocalScope(allocated_context);
       // If this node_sequence is the body of the function being compiled, and
       // if this function allocates context variables, but none of its enclosing
       // functions do, the context on entry is not linked as parent of the
@@ skipping 97 matching lines @@
     Append(for_effect);
     if (!is_open()) {
       // E.g., because of a JumpNode.
       break;
     }
   }
 
   if (is_open()) {
     if (MustSaveRestoreContext(node)) {
       ASSERT(num_context_variables > 0);
-      BuildLoadContext(*owner()->parsed_function()->saved_entry_context_var());
+      BuildRestoreContext(
+          *owner()->parsed_function()->saved_entry_context_var());
     } else if (num_context_variables > 0) {
       UnchainContext();
     }
   }
 
   // No continue on sequence allowed.
   ASSERT((node->label() == NULL) ||
          (node->label()->join_for_continue() == NULL));
   // If this node sequence is labeled, a break out of the sequence will have
   // taken care of unchaining the context.
@@ skipping 10 matching lines @@
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   InlineBailout("EffectGraphVisitor::VisitCatchClauseNode (exception)");
   // NOTE: The implicit variables ':saved_context', ':exception_var'
   // and ':stacktrace_var' can never be captured variables.
   // Restores CTX from local variable ':saved_context'.
   AddInstruction(
       new CatchEntryInstr(node->exception_var(), node->stacktrace_var()));
-  BuildLoadContext(node->context_var());
+  BuildRestoreContext(node->context_var());
 
   EffectGraphVisitor for_catch(owner(), temp_index());
   node->VisitChildren(&for_catch);
   Append(for_catch);
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
   InlineBailout("EffectGraphVisitor::VisitTryCatchNode (exception)");
   intptr_t original_handler_index = owner()->try_index();
   intptr_t try_handler_index = owner()->AllocateTryIndex();
   owner()->set_try_index(try_handler_index);
 
   // Preserve CTX into local variable '%saved_context'.
-  BuildStoreContext(node->context_var());
+  BuildSaveContext(node->context_var());
 
   EffectGraphVisitor for_try(owner(), temp_index());
   node->try_block()->Visit(&for_try);
 
   if (for_try.is_open()) {
     JoinEntryInstr* after_try =
         new JoinEntryInstr(owner()->AllocateBlockId(), original_handler_index);
     for_try.Goto(after_try);
     for_try.exit_ = after_try;
   }
@@ skipping 36 matching lines @@
     }
 
     if (finally_block != NULL) {
       // Create a handler for the code in the catch block, containing the
       // code in the finally block.
       owner()->set_try_index(original_handler_index);
       EffectGraphVisitor for_finally(owner(), temp_index());
       for_finally.AddInstruction(
           new CatchEntryInstr(catch_block->exception_var(),
                               catch_block->stacktrace_var()));
-      for_finally.BuildLoadContext(catch_block->context_var());
+      for_finally.BuildRestoreContext(catch_block->context_var());
 
       finally_block->Visit(&for_finally);
       if (for_finally.is_open()) {
         // Rethrow the exception.  Manually build the graph for rethrow.
         Value* exception = for_finally.Bind(
             for_finally.BuildLoadLocal(catch_block->exception_var()));
         for_finally.PushArgument(exception);
         Value* stacktrace = for_finally.Bind(
             for_finally.BuildLoadLocal(catch_block->stacktrace_var()));
         for_finally.PushArgument(stacktrace);
@@ skipping 149 matching lines @@
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   InlineBailout("EffectGraphVisitor::VisitInlinedFinallyNode (exception)");
   const intptr_t try_index = owner()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     owner()->set_try_index((try_index - 1));
   }
-  BuildLoadContext(node->context_var());
+  BuildRestoreContext(node->context_var());
 
   JoinEntryInstr* finally_entry =
       new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
   EffectGraphVisitor for_finally_block(owner(), temp_index());
   node->finally_block()->Visit(&for_finally_block);
 
   if (try_index >= 0) {
     owner()->set_try_index(try_index);
   }
 
@@ skipping 62 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart