Simplify adding of computations to the flow graph.

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 "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 44 matching lines @@
     entry_ = other_fragment.entry();
     exit_ = other_fragment.exit();
   } else {
     exit()->set_successor(other_fragment.entry());
     exit_ = other_fragment.exit();
   }
   temp_index_ = other_fragment.temp_index();
 }
 
 
+UseVal* EffectGraphVisitor::Bind(Computation* computation) {
+  ASSERT(is_open());
+  DeallocateTempIndex(computation->InputCount());
+  BindInstr* bind_instr = new BindInstr(computation);
+  bind_instr->set_temp_index(AllocateTempIndex());
+  if (is_empty()) {
+    entry_ = bind_instr;
+  } else {
+    exit()->set_successor(bind_instr);
+  }
+  exit_ = bind_instr;
+  return new UseVal(bind_instr);
+}
+
+
+void EffectGraphVisitor::Do(Computation* computation) {
+  ASSERT(is_open());
+  DeallocateTempIndex(computation->InputCount());
+  DoInstr* do_instr = new DoInstr(computation);
+  if (is_empty()) {
+    entry_ = do_instr;
+  } else {
+    exit()->set_successor(do_instr);
+  }
+  exit_ = do_instr;
+}
+
+
 void EffectGraphVisitor::AddInstruction(Instruction* instruction) {
   ASSERT(is_open());
+  ASSERT(!instruction->IsDo());
+  ASSERT(!instruction->IsBind());
   DeallocateTempIndex(instruction->InputCount());
   if (instruction->IsDefinition()) {
     instruction->AsDefinition()->set_temp_index(AllocateTempIndex());
   }
   if (is_empty()) {
     entry_ = exit_ = instruction;
   } else {
     exit()->set_successor(instruction);
     exit_ = instruction;
   }
@@ skipping 79 matching lines @@
   exit_ = *test_fragment.false_successor_address() = new TargetEntryInstr();
 }
 
 
 Computation* EffectGraphVisitor::BuildStoreLocal(
     const LocalVariable& local, Value* value) {
   if (local.is_captured()) {
     intptr_t delta = owner()->context_level() -
                      local.owner()->context_level();
     ASSERT(delta >= 0);
-    BindInstr* context = new BindInstr(new CurrentContextComp());
-    AddInstruction(context);
-    Value* context_value = new UseVal(context);
+    Value* context = Bind(new CurrentContextComp());
     while (delta-- > 0) {
-      BindInstr* load = new BindInstr(new LoadVMFieldComp(
-          context_value, Context::parent_offset(), Type::ZoneHandle()));
-      AddInstruction(load);
-      context_value = new UseVal(load);
+      context = Bind(new LoadVMFieldComp(
+          context, Context::parent_offset(), Type::ZoneHandle()));
     }
     return new StoreVMFieldComp(
-        context_value,
+        context,
         Context::variable_offset(local.index()),
         value,
         local.type());
   } else {
     return new StoreLocalComp(local, value, owner()->context_level());
   }
 }
 
 
 Computation* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local) {
   if (local.is_captured()) {
     intptr_t delta = owner()->context_level() -
                      local.owner()->context_level();
     ASSERT(delta >= 0);
-    BindInstr* context = new BindInstr(new CurrentContextComp());
-    AddInstruction(context);
-    Value* context_value = new UseVal(context);
+    Value* context = Bind(new CurrentContextComp());
     while (delta-- > 0) {
-      BindInstr* load = new BindInstr(new LoadVMFieldComp(
-          context_value, Context::parent_offset(), Type::ZoneHandle()));
-      AddInstruction(load);
-      context_value = new UseVal(load);
+      context = Bind(new LoadVMFieldComp(
+          context, Context::parent_offset(), Type::ZoneHandle()));
     }
-    return new LoadVMFieldComp(context_value,
+    return new LoadVMFieldComp(context,
                                Context::variable_offset(local.index()),
                                local.type());
   } else {
     return new LoadLocalComp(local, owner()->context_level());
   }
 }
 
 
 // Stores current context into the 'variable'
 void EffectGraphVisitor::BuildStoreContext(const LocalVariable& variable) {
-  BindInstr* context = new BindInstr(new CurrentContextComp());
-  AddInstruction(context);
-  Computation* store_context = BuildStoreLocal(variable, new UseVal(context));
-  AddInstruction(new DoInstr(store_context));
+  Value* context = Bind(new CurrentContextComp());
+  Do(BuildStoreLocal(variable, context));
 }
 
 
 // Loads context saved in 'context_variable' into the current context.
 void EffectGraphVisitor::BuildLoadContext(const LocalVariable& variable) {
-  BindInstr* load_saved_context = new BindInstr(BuildLoadLocal(variable));
-  AddInstruction(load_saved_context);
-  DoInstr* store_context =
-      new DoInstr(new StoreContextComp(new UseVal(load_saved_context)));
-  AddInstruction(store_context);
+  Value* load_saved_context = Bind(BuildLoadLocal(variable));
+  Do(new StoreContextComp(load_saved_context));
 }
 
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
-    BindInstr* assert_boolean =
-        new BindInstr(new AssertBooleanComp(condition_token_pos(),
-                                            owner()->try_index(),
-                                            value));
-    AddInstruction(assert_boolean);
-    value = new UseVal(assert_boolean);
+    value = Bind(new AssertBooleanComp(condition_token_pos(),
+                                       owner()->try_index(),
+                                       value));
   }
   BranchInstr* branch = new BranchInstr(value);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
 void EffectGraphVisitor::Bailout(const char* reason) {
@@ skipping 41 matching lines @@
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
     BuildLoadContext(*owner()->parsed_function().saved_context_var());
   } else {
     while (current_context_level-- > 0) {
       UnchainContext();
     }
   }
 
-  AddInstruction(
-      new ReturnInstr(node->token_pos(), return_value));
+  AddInstruction(new ReturnInstr(node->token_pos(), return_value));
   CloseFragment();
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
@@ skipping 155 matching lines @@
 
     TestGraphVisitor for_test(owner(),
                               temp_index(),
                               node->left()->token_pos());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
-      BindInstr* assert_boolean =
-          new BindInstr(new AssertBooleanComp(node->right()->token_pos(),
-                                              owner()->try_index(),
-                                              right_value));
-      for_right.AddInstruction(assert_boolean);
-      right_value = new UseVal(assert_boolean);
+      right_value =
+          for_right.Bind(new AssertBooleanComp(node->right()->token_pos(),
+                                               owner()->try_index(),
+                                               right_value));
     }
-    BindInstr* constant_true = new BindInstr(new ConstantVal(bool_true));
-    for_right.AddInstruction(constant_true);
-    BindInstr* comp =
-        new BindInstr(new StrictCompareComp(Token::kEQ_STRICT,
-                                            right_value,
-                                            new UseVal(constant_true)));
-    for_right.AddInstruction(comp);
-    for_right.AddInstruction(
-        new DoInstr(BuildStoreLocal(
-            *owner()->parsed_function().expression_temp_var(),
-            new UseVal(comp))));
+    Value* constant_true = for_right.Bind(new ConstantVal(bool_true));
+    Value* compare =
+        for_right.Bind(new StrictCompareComp(Token::kEQ_STRICT,
+                                             right_value,
+                                             constant_true));
+    for_right.Do(BuildStoreLocal(
+        *owner()->parsed_function().expression_temp_var(),
+        compare));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner(), temp_index());
-      BindInstr* constant_false = new BindInstr(new ConstantVal(bool_false));
-      for_false.AddInstruction(constant_false);
-      for_false.AddInstruction(
-          new DoInstr(BuildStoreLocal(
-              *owner()->parsed_function().expression_temp_var(),
-              new UseVal(constant_false))));
+      Value* constant_false = for_false.Bind(new ConstantVal(bool_false));
+      for_false.Do(BuildStoreLocal(
+          *owner()->parsed_function().expression_temp_var(),
+          constant_false));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
       ValueGraphVisitor for_true(owner(), temp_index());
-      BindInstr* constant_true = new BindInstr(new ConstantVal(bool_true));
-      for_true.AddInstruction(constant_true);
-      for_true.AddInstruction(
-          new DoInstr(BuildStoreLocal(
-              *owner()->parsed_function().expression_temp_var(),
-              new UseVal(constant_true))));
+      Value* constant_true = for_true.Bind(new ConstantVal(bool_true));
+      for_true.Do(BuildStoreLocal(
+          *owner()->parsed_function().expression_temp_var(),
+          constant_true));
       Join(for_test, for_true, for_right);
     }
     ReturnComputation(
         BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
@@ skipping 87 matching lines @@
   instantiator = BuildInstantiator();
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     instantiator = BuildNullValue();
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, NULL);
   } else {
     // Preserve instantiator.
     const LocalVariable& expr_temp =
         *owner()->parsed_function().expression_temp_var();
-    BindInstr* saved =
-        new BindInstr(BuildStoreLocal(expr_temp, instantiator));
-    AddInstruction(saved);
-    instantiator = new UseVal(saved);
-    BindInstr* loaded = new BindInstr(BuildLoadLocal(expr_temp));
-    AddInstruction(loaded);
+    instantiator = Bind(BuildStoreLocal(expr_temp, instantiator));
+    Value* loaded = Bind(BuildLoadLocal(expr_temp));
     instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(token_pos, new UseVal(loaded));
+        BuildInstantiatorTypeArguments(token_pos, loaded);
   }
   *instantiator_result = instantiator;
   *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
 Value* EffectGraphVisitor::BuildNullValue() {
-  BindInstr* instr = new BindInstr(new ConstantVal(Object::ZoneHandle()));
-  AddInstruction(instr);
-  return new UseVal(instr);
+  return Bind(new ConstantVal(Object::ZoneHandle()));
 }
 
 
 // Used for testing incoming arguments.
 AssertAssignableComp* EffectGraphVisitor::BuildAssertAssignable(
     intptr_t token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
   // Build the type check computation.
@@ skipping 18 matching lines @@
 
 
 // Used for type casts and to test assignments.
 Value* EffectGraphVisitor::BuildAssignableValue(intptr_t token_pos,
                                                 Value* value,
                                                 const AbstractType& dst_type,
                                                 const String& dst_name) {
   if (CanSkipTypeCheck(value, dst_type)) {
     return value;
   }
-  AssertAssignableComp* comp = BuildAssertAssignable(token_pos,
-                                                     value,
-                                                     dst_type,
-                                                     dst_name);
-  BindInstr* assert_assignable = new BindInstr(comp);
-  AddInstruction(assert_assignable);
-  return new UseVal(assert_assignable);
+  return Bind(BuildAssertAssignable(token_pos, value, dst_type, dst_name));
 }
 
 
 void EffectGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(node->kind()));
   EffectGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
 }
 
 
 void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
   ValueGraphVisitor for_value(owner(), temp_index());
   node->left()->Visit(&for_value);
   Append(for_value);
   const String& dst_name = String::ZoneHandle(
       String::NewSymbol(Exceptions::kCastExceptionDstName));
   if (!CanSkipTypeCheck(for_value.value(), type)) {
-    AssertAssignableComp* assert_assignable =
-        BuildAssertAssignable(node->token_pos(),
-                              for_value.value(),
-                              type,
-                              dst_name);
-    AddInstruction(new DoInstr(assert_assignable));
+    Do(BuildAssertAssignable(
+        node->token_pos(), for_value.value(), type, dst_name));
   }
 }
 
 
 void ValueGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(node->kind()));
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed());
@@ skipping 113 matching lines @@
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     EqualityCompareComp* comp = new EqualityCompareComp(
         node->token_pos(), owner()->try_index(),
         for_left_value.value(), for_right_value.value());
     if (node->kind() == Token::kEQ) {
       ReturnComputation(comp);
     } else {
-      BindInstr* eq_result = new BindInstr(comp);
-      AddInstruction(eq_result);
+      Value* eq_result = Bind(comp);
       if (FLAG_enable_type_checks) {
         eq_result =
-            new BindInstr(new AssertBooleanComp(node->token_pos(),
-                                                owner()->try_index(),
-                                                new UseVal(eq_result)));
-        AddInstruction(eq_result);
+            Bind(new AssertBooleanComp(node->token_pos(),
+                                       owner()->try_index(),
+                                       eq_result));
       }
-      BooleanNegateComp* negate = new BooleanNegateComp(new UseVal(eq_result));
-      ReturnComputation(negate);
+      ReturnComputation(new BooleanNegateComp(eq_result));
     }
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner(), temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   RelationalOpComp* comp = new RelationalOpComp(node->token_pos(),
                                                 owner()->try_index(),
                                                 node->kind(),
                                                 for_left_value.value(),
                                                 for_right_value.value());
   ReturnComputation(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     if (FLAG_enable_type_checks) {
-      BindInstr* assert_boolean =
-          new BindInstr(new AssertBooleanComp(node->operand()->token_pos(),
-                                              owner()->try_index(),
-                                              value));
-      AddInstruction(assert_boolean);
-      value = new UseVal(assert_boolean);
+      value =
+          Bind(new AssertBooleanComp(node->operand()->token_pos(),
+                                     owner()->try_index(),
+                                     value));
     }
     BooleanNegateComp* negate = new BooleanNegateComp(value);
     ReturnComputation(negate);
     return;
   }
   ValueGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_value.value());
@@ skipping 27 matching lines @@
 
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   ValueGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
-  for_true.AddInstruction(new DoInstr(BuildStoreLocal(
-      *owner()->parsed_function().expression_temp_var(), for_true.value())));
+  for_true.Do(BuildStoreLocal(
+      *owner()->parsed_function().expression_temp_var(), for_true.value()));
 
   ValueGraphVisitor for_false(owner(), temp_index());
   node->false_expr()->Visit(&for_false);
   ASSERT(for_false.is_open());
-  for_false.AddInstruction(new DoInstr(BuildStoreLocal(
-      *owner()->parsed_function().expression_temp_var(), for_false.value())));
+  for_false.Do(BuildStoreLocal(
+      *owner()->parsed_function().expression_temp_var(), for_false.value()));
 
   Join(for_test, for_true, for_false);
   ReturnComputation(
       BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
@@ skipping 170 matching lines @@
 // f) loop-exit-target
 // g) break-join (optional)
 void EffectGraphVisitor::VisitWhileNode(WhileNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
   ASSERT(!for_test.is_empty());  // Language spec.
 
   EffectGraphVisitor for_body(owner(), temp_index());
-  CheckStackOverflowComp* comp =
-      new CheckStackOverflowComp(node->token_pos(), owner()->try_index());
-  for_body.AddInstruction(new DoInstr(comp));
+  for_body.Do(
+      new CheckStackOverflowComp(node->token_pos(), owner()->try_index()));
   node->body()->Visit(&for_body);
 
   // Labels are set after body traversal.
   SourceLabel* lbl = node->label();
   ASSERT(lbl != NULL);
   if (lbl->join_for_continue() != NULL) {
     AddInstruction(lbl->join_for_continue());
   }
   TieLoop(for_test, for_body);
   if (lbl->join_for_break() != NULL) {
     AddInstruction(lbl->join_for_break());
   }
 }
 
 
 // The fragment is composed as follows:
 // a) body-entry-join
 // b) [ body ]
 // c) test-entry (continue-join or body-exit-target)
 // d) [ test-entry ] -> (back-target, loop-exit-target)
 // e) back-target -> (body-entry-join)
 // f) loop-exit-target
 // g) break-join
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
   // Traverse body first in order to generate continue and break labels.
   EffectGraphVisitor for_body(owner(), temp_index());
-  CheckStackOverflowComp* comp =
-      new CheckStackOverflowComp(node->token_pos(), owner()->try_index());
-  for_body.AddInstruction(new DoInstr(comp));
+  for_body.Do(
+      new CheckStackOverflowComp(node->token_pos(), owner()->try_index()));
   node->body()->Visit(&for_body);
 
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
   ASSERT(is_open());
 
   // Tie do-while loop (test is after the body).
   JoinEntryInstr* body_entry_join = new JoinEntryInstr();
@@ skipping 42 matching lines @@
 void EffectGraphVisitor::VisitForNode(ForNode* node) {
   EffectGraphVisitor for_initializer(owner(), temp_index());
   node->initializer()->Visit(&for_initializer);
   Append(for_initializer);
   ASSERT(is_open());
 
   // Compose body to set any jump labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   TargetEntryInstr* body_entry = new TargetEntryInstr();
   for_body.AddInstruction(body_entry);
-  CheckStackOverflowComp* comp =
-      new CheckStackOverflowComp(node->token_pos(), owner()->try_index());
-  for_body.AddInstruction(new DoInstr(comp));
+  for_body.Do(
+      new CheckStackOverflowComp(node->token_pos(), owner()->try_index()));
   node->body()->Visit(&for_body);
 
   // Join loop body, increment and compute their end instruction.
   ASSERT(!for_body.is_empty());
   Instruction* loop_increment_end = NULL;
   EffectGraphVisitor for_increment(owner(), temp_index());
   if ((node->label()->join_for_continue() == NULL) && for_body.is_open()) {
     // Do not insert an extra basic block.
     node->increment()->Visit(&for_increment);
     for_body.Append(for_increment);
@@ skipping 111 matching lines @@
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   // Translate the array elements and collect their values.
   ZoneGrowableArray<Value*>* values =
       new ZoneGrowableArray<Value*>(node->length());
   for (int i = 0; i < node->length(); ++i) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->ElementAt(i)->Visit(&for_value);
     Append(for_value);
     values->Add(for_value.value());
   }
-  Value* element_type = new UseVal(
-      BuildInstantiatedTypeArguments(node->token_pos(),
-                                     node->type_arguments()));
+  Value* element_type = BuildInstantiatedTypeArguments(node->token_pos(),
+                                                       node->type_arguments());
   CreateArrayComp* create = new CreateArrayComp(node->token_pos(),
                                                 owner()->try_index(),
                                                 values,
                                                 element_type);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
@@ skipping 96 matching lines @@
   arguments->Add(for_closure.value());
   TranslateArgumentList(*node->arguments(), arguments);
 
   // Save context around the call.
   BuildStoreContext(*owner()->parsed_function().expression_temp_var());
   return new ClosureCallComp(node, owner()->try_index(), arguments);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
-  ClosureCallComp* call = BuildClosureCall(node);
-  AddInstruction(new DoInstr(call));
-
+  Do(BuildClosureCall(node));
   // Restore context from saved location.
   BuildLoadContext(*owner()->parsed_function().expression_temp_var());
 }
 
 
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
-  ClosureCallComp* call = BuildClosureCall(node);
-  BindInstr* result = new BindInstr(call);
-  AddInstruction(result);
-
+  Value* result = Bind(BuildClosureCall(node));
   // Restore context from temp.
   BuildLoadContext(*owner()->parsed_function().expression_temp_var());
-
-  ReturnValue(new UseVal(result));
+  ReturnValue(result);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  BindInstr* context = new BindInstr(new CurrentContextComp());
-  AddInstruction(context);
-  BindInstr* clone =
-      new BindInstr(new CloneContextComp(node->token_pos(),
-                                         owner()->try_index(),
-                                         new UseVal(context)));
-  AddInstruction(clone);
-  ReturnComputation(new StoreContextComp(new UseVal(clone)));
+  Value* context = Bind(new CurrentContextComp());
+  Value* clone = Bind(new CloneContextComp(node->token_pos(),
+                                           owner()->try_index(),
+                                           context));
+  ReturnComputation(new StoreContextComp(clone));
 }
 
 
-BindInstr* EffectGraphVisitor::BuildObjectAllocation(
+Value* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   ZoneGrowableArray<Value*>* allocate_arguments =
       new ZoneGrowableArray<Value*>();
   if (requires_type_arguments) {
     BuildConstructorTypeArguments(node, allocate_arguments);
   }
   // In checked mode, if the type arguments are uninstantiated, they may need to
@@ skipping 13 matching lines @@
     // may represent the identity vector and may be replaced by the instantiated
     // type arguments of the instantiator at run time.
     allocate_comp = new AllocateObjectWithBoundsCheckComp(node,
                                                           owner()->try_index(),
                                                           allocate_arguments);
   } else {
     allocate_comp = new AllocateObjectComp(node,
                                            owner()->try_index(),
                                            allocate_arguments);
   }
-  BindInstr* allocate = new BindInstr(allocate_comp);
-  AddInstruction(allocate);
-  return allocate;
+  return Bind(allocate_comp);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(ConstructorCallNode* node,
                                               Value* alloc_value) {
-  BindInstr* ctor_arg =
-      new BindInstr(new ConstantVal(
-                        Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
-  AddInstruction(ctor_arg);
+  Value* ctor_arg = Bind(
+      new ConstantVal(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
 
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
   values->Add(alloc_value);
-  values->Add(new UseVal(ctor_arg));
+  values->Add(ctor_arg);
 
   TranslateArgumentList(*node->arguments(), values);
-  StaticCallComp* call =
-      new StaticCallComp(node->token_pos(),
-                         owner()->try_index(),
-                         node->constructor(),
-                         node->arguments()->names(),
-                         values);
-  AddInstruction(new DoInstr(call));
+  Do(new StaticCallComp(node->token_pos(),
+                        owner()->try_index(),
+                        node->constructor(),
+                        node->arguments()->names(),
+                        values));
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<Value*>* factory_arguments =
         new ZoneGrowableArray<Value*>();
     factory_arguments->Add(
-        new UseVal(BuildInstantiatedTypeArguments(node->token_pos(),
-                                                  node->type_arguments())));
+        BuildInstantiatedTypeArguments(node->token_pos(),
+                                       node->type_arguments()));
     ASSERT(factory_arguments->length() == 1);
     TranslateArgumentList(*node->arguments(), factory_arguments);
     StaticCallComp* call =
         new StaticCallComp(node->token_pos(),
                            owner()->try_index(),
                            node->constructor(),
                            node->arguments()->names(),
                            factory_arguments);
     ReturnComputation(call);
     return;
   }
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
-  BindInstr* allocate = BuildObjectAllocation(node);
-  BuildConstructorCall(node, new UseVal(allocate));
+  Value* allocate = BuildObjectAllocation(node);
+  BuildConstructorCall(node, allocate);
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiator() {
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     return NULL;
   }
   Function& outer_function =
@@ skipping 21 matching lines @@
       owner()->parsed_function().function().owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
         Type::New(instantiator_class, type_arguments, token_pos));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalizeWellFormed);
     type_arguments = type.arguments();
-    BindInstr* args = new BindInstr(new ConstantVal(type_arguments));
-    AddInstruction(args);
-    return new UseVal(args);
+    return Bind(new ConstantVal(type_arguments));
   }
   Function& outer_function =
       Function::Handle(owner()->parsed_function().function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     // No instantiator for factories.
     ASSERT(instantiator == NULL);
     ASSERT(owner()->parsed_function().instantiator() != NULL);
     ValueGraphVisitor for_instantiator(owner(), temp_index());
     owner()->parsed_function().instantiator()->Visit(&for_instantiator);
     Append(for_instantiator);
     return for_instantiator.value();
   }
   if (instantiator == NULL) {
     instantiator = BuildInstantiator();
   }
   // The instantiator is the receiver of the caller, which is not a factory.
   // The receiver cannot be null; extract its AbstractTypeArguments object.
   // Note that in the factory case, the instantiator is the first parameter
   // of the factory, i.e. already an AbstractTypeArguments object.
   intptr_t type_arguments_instance_field_offset =
       instantiator_class.type_arguments_instance_field_offset();
   ASSERT(type_arguments_instance_field_offset != Class::kNoTypeArguments);
 
-  BindInstr* load =
-      new BindInstr(new LoadVMFieldComp(
-                        instantiator,
-                        type_arguments_instance_field_offset,
-                        Type::ZoneHandle()));  // Not an instance, no type.
-  AddInstruction(load);
-  return new UseVal(load);
+  return Bind(new LoadVMFieldComp(
+      instantiator,
+      type_arguments_instance_field_offset,
+      Type::ZoneHandle()));  // Not an instance, no type.
 }
 
 
-BindInstr* EffectGraphVisitor::BuildInstantiatedTypeArguments(
+Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_pos,
     const AbstractTypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
-    BindInstr* type_args =
-        new BindInstr(new ConstantVal(type_arguments));
-    AddInstruction(type_args);
-    return type_args;
+    return Bind(new ConstantVal(type_arguments));
   }
   // The type arguments are uninstantiated.
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(token_pos, NULL);
-  BindInstr* instantiate =
-      new BindInstr(new InstantiateTypeArgumentsComp(token_pos,
-                                                     owner()->try_index(),
-                                                     type_arguments,
-                                                     instantiator_value));
-  AddInstruction(instantiate);
-  return instantiate;
+  return Bind(new InstantiateTypeArgumentsComp(token_pos,
+                                               owner()->try_index(),
+                                               type_arguments,
+                                               instantiator_value));
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
     ZoneGrowableArray<Value*>* args) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   ASSERT(cls.HasTypeArguments() && !node->constructor().IsFactory());
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
-    BindInstr* type_args =
-        new BindInstr(new ConstantVal(node->type_arguments()));
-    AddInstruction(type_args);
+    Value* type_args = Bind(new ConstantVal(node->type_arguments()));
     // No instantiator required.
-    BindInstr* no_instantiator =
-        new BindInstr(new ConstantVal(
-                          Smi::ZoneHandle(Smi::New(
-                              StubCode::kNoInstantiator))));
-    AddInstruction(no_instantiator);
-    args->Add(new UseVal(type_args));
-    args->Add(new UseVal(no_instantiator));
+    Value* no_instantiator = Bind(
+        new ConstantVal(Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
+    args->Add(type_args);
+    args->Add(no_instantiator);
     return;
   }
   // The type arguments are uninstantiated. The generated pseudo code:
   //   t1 = InstantiatorTypeArguments();
   //   t2 = ExtractConstructorTypeArguments(t1);
   //   t1 = ExtractConstructorInstantiator(t1);
   //   t_n   <- t2
   //   t_n+1 <- t1
   // Use expression_temp_var and node->allocated_object_var() locals to keep
   // intermediate results around (t1 and t2 above).
   ASSERT(owner()->parsed_function().expression_temp_var() != NULL);
   const LocalVariable& t1 = *owner()->parsed_function().expression_temp_var();
   const LocalVariable& t2 = node->allocated_object_var();
   Value* instantiator_type_arguments = BuildInstantiatorTypeArguments(
       node->token_pos(), NULL);
   ASSERT(instantiator_type_arguments->IsUse());
-  BindInstr* stored_instantiator = new BindInstr(
-      BuildStoreLocal(t1, instantiator_type_arguments));
-  AddInstruction(stored_instantiator);
+  Value* stored_instantiator =
+      Bind(BuildStoreLocal(t1, instantiator_type_arguments));
   // t1: instantiator type arguments.
 
-  BindInstr* extract_type_arguments = new BindInstr(
+  Value* extract_type_arguments = Bind(
       new ExtractConstructorTypeArgumentsComp(
           node->token_pos(),
           owner()->try_index(),
           node->type_arguments(),
-          new UseVal(stored_instantiator)));
-  AddInstruction(extract_type_arguments);
+          stored_instantiator));
 
-  Instruction* stored_type_arguments = new DoInstr(
-      BuildStoreLocal(t2, new UseVal(extract_type_arguments)));
-  AddInstruction(stored_type_arguments);
+  Do(BuildStoreLocal(t2, extract_type_arguments));
   // t2: extracted constructor type arguments.
-  BindInstr* load_instantiator = new BindInstr(BuildLoadLocal(t1));
-  AddInstruction(load_instantiator);
+  Value* load_instantiator = Bind(BuildLoadLocal(t1));
 
-  BindInstr* extract_instantiator =
-      new BindInstr(new ExtractConstructorInstantiatorComp(
-                        node,
-                        new UseVal(load_instantiator)));
-  AddInstruction(extract_instantiator);
-  AddInstruction(new DoInstr(
-      BuildStoreLocal(t1, new UseVal(extract_instantiator))));
+  Value* extract_instantiator =
+      Bind(new ExtractConstructorInstantiatorComp(node, load_instantiator));
+  Do(BuildStoreLocal(t1, extract_instantiator));
   // t2: extracted constructor type arguments.
   // t1: extracted constructor instantiator.
-  BindInstr* load_0 = new BindInstr(BuildLoadLocal(t2));
-  AddInstruction(load_0);
-  BindInstr* load_1 = new BindInstr(BuildLoadLocal(t1));
-  AddInstruction(load_1);
-  args->Add(new UseVal(load_0));
-  args->Add(new UseVal(load_1));
+  Value* load_0 = Bind(BuildLoadLocal(t2));
+  Value* load_1 = Bind(BuildLoadLocal(t1));
+  args->Add(load_0);
+  args->Add(load_1);
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n      <- StoreLocal(temp, t_n);
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n, t_n+1, ...)
   //   tn       <- LoadLocal(temp)
 
-  BindInstr* allocate = BuildObjectAllocation(node);
+  Value* allocate = BuildObjectAllocation(node);
   Computation* store_allocated = BuildStoreLocal(
       node->allocated_object_var(),
-      new UseVal(allocate));
-  BindInstr* allocated_value = new BindInstr(store_allocated);
-  AddInstruction(allocated_value);
-  BuildConstructorCall(node, new UseVal(allocated_value));
+      allocate);
+  Value* allocated_value = Bind(store_allocated);
+  BuildConstructorCall(node, allocated_value);
   Computation* load_allocated = BuildLoadLocal(
       node->allocated_object_var());
-  allocated_value = new BindInstr(load_allocated);
-  AddInstruction(allocated_value);
-  ReturnValue(new UseVal(allocated_value));
+  allocated_value = Bind(load_allocated);
+  ReturnValue(allocated_value);
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_receiver.value());
   const String& name =
@@ skipping 27 matching lines @@
                              node->field_name(),
                              receiver,
                              value);
   ReturnComputation(setter);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   Value *receiver, *value;
   BuildInstanceSetterValues(node, &receiver, &value);
-  BindInstr* store_local_instr = new BindInstr(
+  Value* saved_value = Bind(
       BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
                       value));
-  AddInstruction(store_local_instr);
-  UseVal* saved_value = new UseVal(store_local_instr);
-  InstanceSetterComp* setter =
-      new InstanceSetterComp(node->token_pos(),
-                             owner()->try_index(),
-                             node->field_name(),
-                             receiver,
-                             saved_value);
-  AddInstruction(new DoInstr(setter));
+  Do(new InstanceSetterComp(node->token_pos(),
+                            owner()->try_index(),
+                            node->field_name(),
+                            receiver,
+                            saved_value));
   ReturnComputation(
        BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
       String::Handle(Field::GetterName(node->field_name()));
   const Function& getter_function =
       Function::ZoneHandle(node->cls().LookupStaticFunction(getter_name));
@@ skipping 181 matching lines @@
                                                  array,
                                                  index,
                                                  value);
   ReturnComputation(store);
 }
 
 
 void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   Value *array, *index, *value;
   BuildStoreIndexedValues(node, &array, &index, &value);
-  BindInstr* store_local_instr = new BindInstr(
+  Value* saved_value = Bind(
       BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
                       value));
-  AddInstruction(store_local_instr);
-  UseVal* saved_value = new UseVal(store_local_instr);
-  StoreIndexedComp* store = new StoreIndexedComp(node->token_pos(),
-                                                 owner()->try_index(),
-                                                 array,
-                                                 index,
-                                                 saved_value);
-  AddInstruction(new DoInstr(store));
+  Do(new StoreIndexedComp(node->token_pos(),
+                          owner()->try_index(),
+                          array,
+                          index,
+                          saved_value));
   ReturnComputation(
        BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function().node_sequence()) &&
          (owner()->parsed_function().saved_context_var() != NULL);
 }
 
 
 void EffectGraphVisitor::UnchainContext() {
-  BindInstr* context = new BindInstr(new CurrentContextComp());
-  AddInstruction(context);
-  BindInstr* parent =
-      new BindInstr(
-          new LoadVMFieldComp(
-              new UseVal(context),
-              Context::parent_offset(),
-              Type::ZoneHandle()));  // Not an instance, no type.
-  AddInstruction(parent);
-  AddInstruction(new DoInstr(new StoreContextComp(new UseVal(parent))));
+  Value* context = Bind(new CurrentContextComp());
+  Value* parent = Bind(
+      new LoadVMFieldComp(context,
+                          Context::parent_offset(),
+                          Type::ZoneHandle()));  // Not an instance, no type.
+  Do(new StoreContextComp(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) {
     // The loop local scope declares variables that are captured.
     // Allocate and chain a new context.
     // Allocate context computation (uses current CTX)
-    BindInstr* allocated_context =
-        new BindInstr(new AllocateContextComp(node->token_pos(),
-                                              owner()->try_index(),
-                                              num_context_variables));
-    AddInstruction(allocated_context);
+    Value* allocated_context =
+        Bind(new AllocateContextComp(node->token_pos(),
+                                     owner()->try_index(),
+                                     num_context_variables));
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function is not a closure, do not link the current context as the
     // parent of the newly allocated context, as it is not accessible. Instead,
     // save it in a pre-allocated variable and restore it on exit.
     if (MustSaveRestoreContext(node)) {
-      BindInstr* current_context = new BindInstr(new CurrentContextComp());
-      AddInstruction(current_context);
-      Computation* store_local = BuildStoreLocal(
-          *owner()->parsed_function().saved_context_var(),
-          new UseVal(current_context));
-      AddInstruction(new DoInstr(store_local));
-      BindInstr* null_context =
-          new BindInstr(new ConstantVal(Object::ZoneHandle()));
-      AddInstruction(null_context);
-      StoreContextComp* store_context =
-          new StoreContextComp(new UseVal(null_context));
-      AddInstruction(new DoInstr(store_context));
+      Value* current_context = Bind(new CurrentContextComp());
+      Do(BuildStoreLocal(*owner()->parsed_function().saved_context_var(),
+                         current_context));
+      Value* null_context = Bind(new ConstantVal(Object::ZoneHandle()));
+      Do(new StoreContextComp(null_context));
     }
 
-    ChainContextComp* chain_context =
-        new ChainContextComp(new UseVal(allocated_context));
-    AddInstruction(new DoInstr(chain_context));
+    Do(new ChainContextComp(allocated_context));
     owner()->set_context_level(scope->context_level());
 
     // 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.NumberOfParameters();
       int param_frame_index = (num_params == function.num_fixed_parameters()) ?
           (1 + num_params) : ParsedFunction::kFirstLocalSlotIndex;
       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 = String::ZoneHandle(String::Concat(
               parameter.name(), String::Handle(String::NewSymbol("-orig"))));
           LocalVariable* temp_local = new LocalVariable(
               0,  // Token index.
               temp_name,
               Type::ZoneHandle(Type::DynamicType()));  // Type.
           temp_local->set_index(param_frame_index);
 
           // Copy parameter from local frame to current context.
-          BindInstr* load = new BindInstr(BuildLoadLocal(*temp_local));
-          AddInstruction(load);
-          Computation* store_local =
-              BuildStoreLocal(parameter, new UseVal(load));
-          AddInstruction(new DoInstr(store_local));
+          Value* load = Bind(BuildLoadLocal(*temp_local));
+          Do(BuildStoreLocal(parameter, load));
           // Write NULL to the source location to detect buggy accesses and
           // allow GC of passed value if it gets overwritten by a new value in
           // the function.
-          BindInstr* null_constant =
-              new BindInstr(new ConstantVal(Object::ZoneHandle()));
-          AddInstruction(null_constant);
-          Computation* clear_local =
-              BuildStoreLocal(*temp_local, new UseVal(null_constant));
-          AddInstruction(new DoInstr(clear_local));
+          Value* null_constant = Bind(new ConstantVal(Object::ZoneHandle()));
+          Do(BuildStoreLocal(*temp_local, null_constant));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
     const Function& function = owner()->parsed_function().function();
     const int num_params = function.NumberOfParameters();
     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(NULL, parameter.type())) {
-        BindInstr* load = new BindInstr(BuildLoadLocal(parameter));
-        AddInstruction(load);
-        AssertAssignableComp* assert_assignable =
-            BuildAssertAssignable(parameter.token_pos(),
-                                  new UseVal(load),
-                                  parameter.type(),
-                                  parameter.name());
-        AddInstruction(new DoInstr(assert_assignable));
+        Value* load = Bind(BuildLoadLocal(parameter));
+        Do(BuildAssertAssignable(parameter.token_pos(),
+                                 load,
+                                 parameter.type(),
+                                 parameter.name()));
       }
       pos++;
     }
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
@@ skipping 30 matching lines @@
   ASSERT((node->label() == NULL) ||
          (node != owner()->parsed_function().node_sequence()));
   owner()->set_context_level(previous_context_level);
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   // NOTE: The implicit variables ':saved_context', ':exception_var'
   // and ':stacktrace_var' can never be captured variables.
   // Restores CTX from local variable ':saved_context'.
-  CatchEntryComp* catch_entry = new CatchEntryComp(node->exception_var(),
-                                                   node->stacktrace_var());
-  AddInstruction(new DoInstr(catch_entry));
+  Do(new CatchEntryComp(node->exception_var(), node->stacktrace_var()));
   BuildLoadContext(node->context_var());
 
   EffectGraphVisitor for_catch(owner(), temp_index());
   node->VisitChildren(&for_catch);
   Append(for_catch);
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
   intptr_t old_try_index = owner()->try_index();
@@ skipping 534 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(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