Make CTX allocatable by the register allocator.

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 741 matching lines @@
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreLocal(const LocalVariable& local,
                                                 Value* value) {
   if (local.is_captured()) {
     LocalVariable* tmp_var = EnterTempLocalScope(value);
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
-    Value* context = Bind(new(I) CurrentContextInstr());
+    Value* context = Bind(BuildCurrentContext());
     while (delta-- > 0) {
       context = Bind(new(I) LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle(I, Type::null()),
           Scanner::kNoSourcePos));
     }
     Value* tmp_val = Bind(new(I) LoadLocalInstr(*tmp_var));
     StoreInstanceFieldInstr* store =
         new(I) StoreInstanceFieldInstr(Context::variable_offset(local.index()),
                                     context,
                                     tmp_val,
                                     kEmitStoreBarrier,
                                     Scanner::kNoSourcePos);
     Do(store);
     return ExitTempLocalScope(tmp_var);
   } else {
     return new(I) StoreLocalInstr(local, value);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local) {
   if (local.IsConst()) {
     return new(I) ConstantInstr(*local.ConstValue());
   } else if (local.is_captured()) {
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
-    Value* context = Bind(new(I) CurrentContextInstr());
+    Value* context = Bind(BuildCurrentContext());
     while (delta-- > 0) {
       context = Bind(new(I) LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle(I, Type::null()),
           Scanner::kNoSourcePos));
     }
     return new(I) LoadFieldInstr(context,
                               Context::variable_offset(local.index()),
                               local.type(),
                               Scanner::kNoSourcePos);
   } else {
     return new(I) LoadLocalInstr(local);
   }
 }
 
 
 // Stores current context into the 'variable'
 void EffectGraphVisitor::BuildSaveContext(const LocalVariable& variable) {
-  Value* context = Bind(new(I) CurrentContextInstr());
+  Value* context = Bind(BuildCurrentContext());
   Do(BuildStoreLocal(variable, context));
 }
 
 
 // Loads context saved in 'context_variable' into the current context.
 void EffectGraphVisitor::BuildRestoreContext(const LocalVariable& variable) {
   Value* load_saved_context = Bind(BuildLoadLocal(variable));
-  AddInstruction(new(I) StoreContextInstr(load_saved_context));
+  Do(BuildStoreContext(load_saved_context));
+}
+
+
+Definition* EffectGraphVisitor::BuildStoreContext(Value* value) {
+  return new(I) StoreLocalInstr(
+      *owner()->parsed_function()->current_context_var(), value);
+}
+
+
+Definition* EffectGraphVisitor::BuildCurrentContext() {
+  return new(I) LoadLocalInstr(
+      *owner()->parsed_function()->current_context_var());
 }
 
 
 void TestGraphVisitor::ConnectBranchesTo(
     const GrowableArray<TargetEntryInstr**>& branches,
     JoinEntryInstr* join) const {
   ASSERT(!branches.is_empty());
   for (intptr_t i = 0; i < branches.length(); i++) {
     TargetEntryInstr* target =
         new(I) TargetEntryInstr(owner()->AllocateBlockId(),
@@ skipping 434 matching lines @@
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(I) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_left);
   arguments->Add(push_right);
   const String& name = String::ZoneHandle(I, Symbols::New(node->TokenName()));
   const intptr_t kNumArgsChecked = 2;
   InstanceCallInstr* call = new(I) InstanceCallInstr(node->token_pos(),
-                                                  name,
-                                                  node->kind(),
-                                                  arguments,
-                                                  Object::null_array(),
-                                                  kNumArgsChecked,
-                                                  owner()->ic_data_array());
+                                                     name,
+                                                     node->kind(),
+                                                     arguments,
+                                                     Object::null_array(),
+                                                     kNumArgsChecked,
+                                                     owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
@@ skipping 72 matching lines @@
   PushArgumentInstr* push_mask = PushArgument(mask_value);
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(I) ZoneGrowableArray<PushArgumentInstr*>(3);
   arguments->Add(push_left);
   arguments->Add(push_right);
   // Call to special method 'BinaryOpAndMaskName(node)'.
   arguments->Add(push_mask);
   const intptr_t kNumArgsChecked = 2;
   InstanceCallInstr* call = new(I) InstanceCallInstr(node->token_pos(),
-                                                  BinaryOpAndMaskName(node),
-                                                  Token::kILLEGAL,
-                                                  arguments,
-                                                  Object::null_array(),
-                                                  kNumArgsChecked,
-                                                  owner()->ic_data_array());
+                                                     BinaryOpAndMaskName(node),
+                                                     Token::kILLEGAL,
+                                                     arguments,
+                                                     Object::null_array(),
+                                                     kNumArgsChecked,
+                                                     owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildTypecheckPushArguments(
     intptr_t token_pos,
     PushArgumentInstr** push_instantiator_result,
     PushArgumentInstr** push_instantiator_type_arguments_result) {
   const Class& instantiator_class = Class::Handle(
       I, owner()->parsed_function()->function().Owner());
@@ skipping 104 matching lines @@
   BuildRestoreContext(*old_context);
 
   // Pass over the continuation result.
 
   // 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();
   ASSERT(delta >= 0);
-  Value* context = Bind(new(I) CurrentContextInstr());
+  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_result_var));
   StoreInstanceFieldInstr* store = new(I) StoreInstanceFieldInstr(
@@ skipping 227 matching lines @@
     Append(for_left_value);
     PushArgumentInstr* push_left = PushArgument(for_left_value.value());
     arguments->Add(push_left);
 
     ValueGraphVisitor for_right_value(owner());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     PushArgumentInstr* push_right = PushArgument(for_right_value.value());
     arguments->Add(push_right);
 
-    Definition* result =
-        new(I) InstanceCallInstr(node->token_pos(),
-                                 Symbols::EqualOperator(),
-                              Token::kEQ,  // Result is negated later for kNE.
-                              arguments,
-                              Object::null_array(),
-                              2,
-                              owner()->ic_data_array());
+    Definition* result = new(I) InstanceCallInstr(
+        node->token_pos(),
+        Symbols::EqualOperator(),
+        Token::kEQ,  // Result is negated later for kNE.
+        arguments,
+        Object::null_array(),
+        2,
+        owner()->ic_data_array());
     if (node->kind() == Token::kNE) {
       if (FLAG_enable_type_checks) {
         Value* value = Bind(result);
         result = new(I) AssertBooleanInstr(node->token_pos(), value);
       }
       Value* value = Bind(result);
       result = new(I) BooleanNegateInstr(value);
     }
     ReturnDefinition(result);
     return;
   }
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(I) ZoneGrowableArray<PushArgumentInstr*>(2);
 
   ValueGraphVisitor for_left_value(owner());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
   arguments->Add(push_left);
 
   ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
   arguments->Add(push_right);
 
   ASSERT(Token::IsRelationalOperator(node->kind()));
-  InstanceCallInstr* comp =
-      new(I) InstanceCallInstr(node->token_pos(),
-                            String::ZoneHandle(
-                                I, Symbols::New(node->TokenName())),
-                            node->kind(),
-                            arguments,
-                            Object::null_array(),
-                            2,
-                            owner()->ic_data_array());
+  InstanceCallInstr* comp = new(I) InstanceCallInstr(
+      node->token_pos(),
+      String::ZoneHandle(I, Symbols::New(node->TokenName())),
+      node->kind(),
+      arguments,
+      Object::null_array(),
+      2,
+      owner()->ic_data_array());
   ReturnDefinition(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     if (FLAG_enable_type_checks) {
       value =
           Bind(new(I) AssertBooleanInstr(node->operand()->token_pos(), value));
     }
     BooleanNegateInstr* negate = new(I) BooleanNegateInstr(value);
     ReturnDefinition(negate);
     return;
   }
 
   ValueGraphVisitor for_value(owner());
   node->operand()->Visit(&for_value);
   Append(for_value);
   PushArgumentInstr* push_value = PushArgument(for_value.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(I) ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
-  InstanceCallInstr* call =
-      new(I) InstanceCallInstr(node->token_pos(),
-                            String::ZoneHandle(
-                                I, Symbols::New(node->TokenName())),
-                            node->kind(),
-                            arguments,
-                            Object::null_array(),
-                            1,
-                            owner()->ic_data_array());
+  InstanceCallInstr* call = new(I) InstanceCallInstr(
+      node->token_pos(),
+      String::ZoneHandle(I, Symbols::New(node->TokenName())),
+      node->kind(),
+      arguments,
+      Object::null_array(),
+      1,
+      owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(), node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   // Translate the subexpressions for their effects.
   EffectGraphVisitor for_true(owner());
@@ skipping 680 matching lines @@
         Do(new(I) StoreInstanceFieldInstr(Closure::context_offset(),
                                           closure_tmp_val,
                                           context_tmp_val,
                                           kEmitStoreBarrier,
                                           node->token_pos()));
         Do(ExitTempLocalScope(context_tmp_var));
       }
     } else {
       // Store current context in closure.
       closure_tmp_val = Bind(new(I) LoadLocalInstr(*closure_tmp_var));
-      Value* context = Bind(new(I) CurrentContextInstr());
+      Value* context = Bind(BuildCurrentContext());
       Do(new(I) StoreInstanceFieldInstr(Closure::context_offset(),
                                         closure_tmp_val,
                                         context,
                                         kEmitStoreBarrier,
                                         node->token_pos()));
     }
     ReturnDefinition(ExitTempLocalScope(closure_tmp_var));
   }
 }
 
@@ skipping 65 matching lines @@
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(I) ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   BuildPushArguments(*node->arguments(), arguments);
   StaticCallInstr* call =
       new(I) StaticCallInstr(node->token_pos(),
-                          node->function(),
-                          node->arguments()->names(),
-                          arguments,
-                          owner()->ic_data_array());
+                             node->function(),
+                             node->arguments()->names(),
+                             arguments,
+                             owner()->ic_data_array());
   if (node->function().is_native()) {
     const intptr_t result_cid = GetResultCidOfNativeFactory(node->function());
     if (result_cid != kDynamicCid) {
       call->set_result_cid(result_cid);
       call->set_is_native_list_factory(true);
     }
   }
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node, bool result_needed) {
   ValueGraphVisitor for_closure(owner());
   node->closure()->Visit(&for_closure);
   Append(for_closure);
 
   LocalVariable* tmp_var = EnterTempLocalScope(for_closure.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(I) ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   Value* closure_val = Bind(new(I) LoadLocalInstr(*tmp_var));
   PushArgumentInstr* push_closure = PushArgument(closure_val);
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
-  // Save context around the call.
-  ASSERT(owner()->parsed_function()->saved_current_context_var() != NULL);
-  BuildSaveContext(*owner()->parsed_function()->saved_current_context_var());
-  closure_val = Bind(new(I) LoadLocalInstr(*tmp_var));
-  LoadFieldInstr* context_load = new(I) LoadFieldInstr(
-      closure_val,
-      Closure::context_offset(),
-      AbstractType::ZoneHandle(I, AbstractType::null()),
-      node->token_pos());
-  context_load->set_is_immutable(true);
-  Value* context_val = Bind(context_load);
-  AddInstruction(new(I) StoreContextInstr(context_val));
   closure_val = Bind(new(I) LoadLocalInstr(*tmp_var));
   LoadFieldInstr* function_load = new(I) LoadFieldInstr(
       closure_val,
       Closure::function_offset(),
       AbstractType::ZoneHandle(I, AbstractType::null()),
       node->token_pos());
   function_load->set_is_immutable(true);
   Value* function_val = Bind(function_load);
+
   Definition* closure_call =
       new(I) ClosureCallInstr(function_val, node, arguments);
   if (result_needed) {
     Value* result = Bind(closure_call);
     Do(new(I) StoreLocalInstr(*tmp_var, result));
-    // Restore context from temp.
-    BuildRestoreContext(
-        *owner()->parsed_function()->saved_current_context_var());
-    ReturnDefinition(ExitTempLocalScope(tmp_var));
   } else {
     Do(closure_call);
-    // Restore context from saved location.
-    BuildRestoreContext(
-        *owner()->parsed_function()->saved_current_context_var());
-    Do(ExitTempLocalScope(tmp_var));
   }
+  ReturnDefinition(ExitTempLocalScope(tmp_var));
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   BuildClosureCall(node, false);
 }
 
 
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   BuildClosureCall(node, true);
 }
 
 
 void EffectGraphVisitor::VisitInitStaticFieldNode(InitStaticFieldNode* node) {
   Value* field = Bind(new(I) ConstantInstr(node->field()));
   AddInstruction(new(I) InitStaticFieldInstr(field, node->field()));
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  Value* context = Bind(new(I) CurrentContextInstr());
+  Value* context = Bind(BuildCurrentContext());
   Value* clone = Bind(new(I) CloneContextInstr(node->token_pos(), context));
-  AddInstruction(new(I) StoreContextInstr(clone));
+  Do(BuildStoreContext(clone));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(I, node->constructor().Owner());
   const bool cls_is_parameterized = cls.NumTypeArguments() > 0;
 
   ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
       new(I) ZoneGrowableArray<PushArgumentInstr*>(
           cls_is_parameterized ? 1 : 0);
@@ skipping 19 matching lines @@
       Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseAll))));
   PushArgumentInstr* push_ctor_arg = PushArgument(ctor_arg);
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(I) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_alloc_value);
   arguments->Add(push_ctor_arg);
 
   BuildPushArguments(*node->arguments(), arguments);
   Do(new(I) StaticCallInstr(node->token_pos(),
-                         node->constructor(),
-                         node->arguments()->names(),
-                         arguments,
-                         owner()->ic_data_array()));
+                            node->constructor(),
+                            node->arguments()->names(),
+                            arguments,
+                            owner()->ic_data_array()));
 }
 
 
 static intptr_t GetResultCidOfListFactory(ConstructorCallNode* node) {
   const Function& function = node->constructor();
   const Class& function_class = Class::Handle(function.Owner());
 
   if ((function_class.library() != Library::CoreLibrary()) &&
       (function_class.library() != Library::TypedDataLibrary())) {
     return kDynamicCid;
@@ skipping 19 matching lines @@
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new(I) ZoneGrowableArray<PushArgumentInstr*>();
     PushArgumentInstr* push_type_arguments = PushArgument(
         BuildInstantiatedTypeArguments(node->token_pos(),
                                        node->type_arguments()));
     arguments->Add(push_type_arguments);
     ASSERT(arguments->length() == 1);
     BuildPushArguments(*node->arguments(), arguments);
     StaticCallInstr* call =
         new(I) StaticCallInstr(node->token_pos(),
-                            node->constructor(),
-                            node->arguments()->names(),
-                            arguments,
-                            owner()->ic_data_array());
+                               node->constructor(),
+                               node->arguments()->names(),
+                               arguments,
+                               owner()->ic_data_array());
     const intptr_t result_cid = GetResultCidOfListFactory(node);
     if (result_cid != kDynamicCid) {
       call->set_result_cid(result_cid);
       call->set_is_known_list_constructor(true);
       // Recognized fixed length array factory must have two arguments:
       // (0) type-arguments, (1) length.
       ASSERT(!LoadFieldInstr::IsFixedLengthArrayCid(result_cid) ||
              arguments->length() == 2);
     }
     ReturnDefinition(call);
@@ skipping 730 matching lines @@
   arguments->Add(PushArgument(for_array.value()));
 
   ValueGraphVisitor for_index(owner());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   if (super_function != NULL) {
     // Generate static call to super operator.
     StaticCallInstr* load = new(I) StaticCallInstr(node->token_pos(),
-                                                *super_function,
-                                                Object::null_array(),
-                                                arguments,
-                                                owner()->ic_data_array());
+                                                   *super_function,
+                                                   Object::null_array(),
+                                                   arguments,
+                                                   owner()->ic_data_array());
     ReturnDefinition(load);
   } else {
     // Generate dynamic call to index operator.
     const intptr_t checked_argument_count = 1;
-    InstanceCallInstr* load = new(I) InstanceCallInstr(node->token_pos(),
-                                                    Symbols::IndexToken(),
-                                                    Token::kINDEX,
-                                                    arguments,
-                                                    Object::null_array(),
-                                                    checked_argument_count,
-                                                    owner()->ic_data_array());
+    InstanceCallInstr* load = new(I) InstanceCallInstr(
+        node->token_pos(),
+        Symbols::IndexToken(),
+        Token::kINDEX,
+        arguments,
+        Object::null_array(),
+        checked_argument_count,
+        owner()->ic_data_array());
     ReturnDefinition(load);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
   Function* super_function = NULL;
   if (node->IsSuperStore()) {
@@ skipping 46 matching lines @@
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
   if (super_function != NULL) {
     // Generate static call to super operator []=.
 
     StaticCallInstr* store =
         new(I) StaticCallInstr(node->token_pos(),
-                            *super_function,
-                            Object::null_array(),
-                            arguments,
-                            owner()->ic_data_array());
+                               *super_function,
+                               Object::null_array(),
+                               arguments,
+                               owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp();
     } else {
       return store;
     }
   } else {
     // Generate dynamic call to operator []=.
     const intptr_t checked_argument_count = 3;
     const String& name =
         String::ZoneHandle(I, Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
     InstanceCallInstr* store =
         new(I) InstanceCallInstr(node->token_pos(),
-                              name,
-                              Token::kASSIGN_INDEX,
-                              arguments,
-                              Object::null_array(),
-                              checked_argument_count,
-                              owner()->ic_data_array());
+                                 name,
+                                 Token::kASSIGN_INDEX,
+                                 arguments,
+                                 Object::null_array(),
+                                 checked_argument_count,
+                                 owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp();
     } else {
       return store;
     }
   }
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   ReturnDefinition(BuildStoreIndexedValues(node, kResultNotNeeded));
 }
 
 
 void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   ReturnDefinition(BuildStoreIndexedValues(node, kResultNeeded));
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function()->node_sequence()) &&
          (owner()->parsed_function()->saved_entry_context_var() != NULL);
 }
 
 
 void EffectGraphVisitor::UnchainContexts(intptr_t n) {
   if (n > 0) {
-    Value* context = Bind(new(I) CurrentContextInstr());
+    Value* context = Bind(BuildCurrentContext());
     while (n-- > 0) {
       context = Bind(
           new(I) LoadFieldInstr(context,
                                 Context::parent_offset(),
                                 // Not an instance, no type.
                                 Type::ZoneHandle(I, Type::null()),
                                 Scanner::kNoSourcePos));
     }
-    AddInstruction(new(I) StoreContextInstr(context));
+    Do(BuildStoreContext(context));
   }
 }
 
 
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
   const intptr_t num_context_variables =
@@ skipping 18 matching lines @@
       // memory leaks.
       // In this case, the parser pre-allocates a variable to save the context.
       Value* tmp_val = Bind(new(I) LoadLocalInstr(*tmp_var));
       Value* parent_context = NULL;
       if (MustSaveRestoreContext(node)) {
         BuildSaveContext(
             *owner()->parsed_function()->saved_entry_context_var());
         parent_context = Bind(
             new(I) ConstantInstr(Object::ZoneHandle(I, Object::null())));
       } else {
-        parent_context = Bind(new(I) CurrentContextInstr());
+        parent_context = Bind(BuildCurrentContext());
       }
       Do(new(I) StoreInstanceFieldInstr(Context::parent_offset(),
                                         tmp_val,
                                         parent_context,
                                         kEmitStoreBarrier,
                                         Scanner::kNoSourcePos));
-      AddInstruction(
-          new(I) StoreContextInstr(Bind(ExitTempLocalScope(tmp_var))));
+      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 (node == owner()->parsed_function()->node_sequence()) {
       ASSERT(scope->context_level() == 1);
       const Function& function = owner()->parsed_function()->function();
       const int num_params = function.NumParameters();
       int param_frame_index = (num_params == function.num_fixed_parameters()) ?
           (kParamEndSlotFromFp + num_params) : kFirstLocalSlotFromFp;
@@ skipping 27 matching lines @@
         }
       }
     }
   } else if (MustSaveRestoreContext(node)) {
     // Even when the current scope has no context variables, we may
     // still need to save the current context if, for example, there
     // are loop scopes below this which will allocate a context
     // object.
     BuildSaveContext(
         *owner()->parsed_function()->saved_entry_context_var());
-    AddInstruction(
-        new(I) StoreContextInstr(Bind(new(I) ConstantInstr(Object::ZoneHandle(
-            I, I->object_store()->empty_context())))));
+    Do(BuildStoreContext(Bind(new(I) ConstantInstr(Object::ZoneHandle(
+        I, I->object_store()->empty_context())))));
   }
 
   // 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()->parsed_function()->function();
   if ((node == owner()->parsed_function()->node_sequence()) &&
       !function.is_native()) {
     // Always allocate CheckOverflowInstr so that deopt-ids match regardless
     // if we inline or not.
     if (!function.IsImplicitGetterFunction() &&
@@ skipping 503 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