Revert "Remove classes Computation and BindInstr."

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/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 46 matching lines @@
     entry_ = other_fragment.entry();
     exit_ = other_fragment.exit();
   } else {
     exit()->set_next(other_fragment.entry());
     exit_ = other_fragment.exit();
   }
   temp_index_ = other_fragment.temp_index();
 }
 
 
-Value* EffectGraphVisitor::Bind(Definition* definition) {
+Value* EffectGraphVisitor::Bind(Computation* computation) {
   ASSERT(is_open());
-  DeallocateTempIndex(definition->InputCount());
-  definition->set_use_kind(Definition::kValue);
-  definition->set_temp_index(AllocateTempIndex());
+  DeallocateTempIndex(computation->InputCount());
+  BindInstr* bind_instr = new BindInstr(Definition::kValue, computation);
+  bind_instr->set_temp_index(AllocateTempIndex());
   if (is_empty()) {
-    entry_ = definition;
+    entry_ = bind_instr;
   } else {
-    exit()->set_next(definition);
+    exit()->set_next(bind_instr);
   }
-  exit_ = definition;
-  return new Value(definition);
+  exit_ = bind_instr;
+  return new Value(bind_instr);
 }
 
 
-void EffectGraphVisitor::Do(Definition* definition) {
+void EffectGraphVisitor::Do(Computation* computation) {
   ASSERT(is_open());
-  DeallocateTempIndex(definition->InputCount());
-  definition->set_use_kind(Definition::kEffect);
+  DeallocateTempIndex(computation->InputCount());
+  BindInstr* do_instr = new BindInstr(Definition::kEffect, computation);
   if (is_empty()) {
-    entry_ = definition;
+    entry_ = do_instr;
   } else {
-    exit()->set_next(definition);
+    exit()->set_next(do_instr);
   }
-  exit_ = definition;
+  exit_ = do_instr;
 }
 
 
 void EffectGraphVisitor::AddInstruction(Instruction* instruction) {
   ASSERT(is_open());
-  ASSERT(instruction->IsPushArgument() || !instruction->IsDefinition());
+  ASSERT(!instruction->IsBind());
   ASSERT(!instruction->IsBlockEntry());
   DeallocateTempIndex(instruction->InputCount());
   if (is_empty()) {
     entry_ = exit_ = instruction;
   } else {
     exit()->set_next(instruction);
     exit_ = instruction;
   }
 }
 
@@ skipping 96 matching lines @@
 }
 
 
 PushArgumentInstr* EffectGraphVisitor::PushArgument(Value* value) {
   PushArgumentInstr* result = new PushArgumentInstr(value);
   AddInstruction(result);
   return result;
 }
 
 
-Definition* EffectGraphVisitor::BuildStoreLocal(
+Computation* EffectGraphVisitor::BuildStoreLocal(
     const LocalVariable& local, Value* value) {
   if (local.is_captured()) {
-    intptr_t delta =
-        owner()->context_level() - local.owner()->context_level();
+    intptr_t delta = owner()->context_level() -
+                     local.owner()->context_level();
     ASSERT(delta >= 0);
-    Value* context = Bind(new CurrentContextInstr());
+    Value* context = Bind(new CurrentContextComp());
     while (delta-- > 0) {
-      context = Bind(new LoadVMFieldInstr(
+      context = Bind(new LoadVMFieldComp(
           context, Context::parent_offset(), Type::ZoneHandle()));
     }
-    return new StoreVMFieldInstr(
+    return new StoreVMFieldComp(
         context,
         Context::variable_offset(local.index()),
         value,
         local.type());
   } else {
-    return new StoreLocalInstr(local, value, owner()->context_level());
+    return new StoreLocalComp(local, value, owner()->context_level());
   }
 }
 
 
-Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local) {
+Computation* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local) {
   if (local.is_captured()) {
-    intptr_t delta =
-        owner()->context_level() - local.owner()->context_level();
+    intptr_t delta = owner()->context_level() -
+                     local.owner()->context_level();
     ASSERT(delta >= 0);
-    Value* context = Bind(new CurrentContextInstr());
+    Value* context = Bind(new CurrentContextComp());
     while (delta-- > 0) {
-      context = Bind(new LoadVMFieldInstr(
+      context = Bind(new LoadVMFieldComp(
           context, Context::parent_offset(), Type::ZoneHandle()));
     }
-    return new LoadVMFieldInstr(context,
-                                Context::variable_offset(local.index()),
-                                local.type());
+    return new LoadVMFieldComp(context,
+                               Context::variable_offset(local.index()),
+                               local.type());
   } else {
-    return new LoadLocalInstr(local, owner()->context_level());
+    return new LoadLocalComp(local, owner()->context_level());
   }
 }
 
 
 // Stores current context into the 'variable'
 void EffectGraphVisitor::BuildStoreContext(const LocalVariable& variable) {
-  Value* context = Bind(new CurrentContextInstr());
+  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) {
   Value* load_saved_context = Bind(BuildLoadLocal(variable));
-  Do(new StoreContextInstr(load_saved_context));
+  Do(new StoreContextComp(load_saved_context));
 }
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
-    value = Bind(new AssertBooleanInstr(condition_token_pos(), value));
+    value = Bind(new AssertBooleanComp(condition_token_pos(), value));
   }
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  Value* constant_true = Bind(new ConstantInstr(bool_true));
-  StrictCompareInstr* comp =
-      new StrictCompareInstr(Token::kEQ_STRICT, value, constant_true);
+  Value* constant_true = Bind(new ConstantComp(bool_true));
+  StrictCompareComp* comp =
+      new StrictCompareComp(Token::kEQ_STRICT, value, constant_true);
   BranchInstr* branch = new BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
-void TestGraphVisitor::MergeBranchWithComparison(ComparisonInstr* comp) {
+void TestGraphVisitor::MergeBranchWithComparison(ComparisonComp* comp) {
   ASSERT(!FLAG_enable_type_checks);
   ControlInstruction* branch;
   if (Token::IsStrictEqualityOperator(comp->kind())) {
-    branch = new BranchInstr(new StrictCompareInstr(comp->kind(),
-                                                    comp->left(),
-                                                    comp->right()));
+    branch = new BranchInstr(new StrictCompareComp(comp->kind(),
+                                                   comp->left(),
+                                                   comp->right()));
   } else if (Token::IsEqualityOperator(comp->kind()) &&
              (comp->left()->BindsToConstantNull() ||
               comp->right()->BindsToConstantNull())) {
-    branch = new BranchInstr(new StrictCompareInstr(
+    branch = new BranchInstr(new StrictCompareComp(
         (comp->kind() == Token::kEQ) ? Token::kEQ_STRICT : Token::kNE_STRICT,
         comp->left(),
         comp->right()));
   } else {
     branch = new BranchInstr(comp);
   }
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
-void TestGraphVisitor::MergeBranchWithNegate(BooleanNegateInstr* neg) {
+void TestGraphVisitor::MergeBranchWithNegate(BooleanNegateComp* comp) {
   ASSERT(!FLAG_enable_type_checks);
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  Value* constant_true = Bind(new ConstantInstr(bool_true));
+  Value* constant_true = Bind(new ConstantComp(bool_true));
   BranchInstr* branch = new BranchInstr(
-      new StrictCompareInstr(Token::kNE_STRICT, neg->value(), constant_true));
+      new StrictCompareComp(Token::kNE_STRICT,
+                            comp->value(),
+                            constant_true));
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
-void TestGraphVisitor::ReturnDefinition(Definition* definition) {
+void TestGraphVisitor::ReturnComputation(Computation* computation) {
   if (!FLAG_enable_type_checks) {
-    ComparisonInstr* comp = definition->AsComparison();
-    if (comp != NULL) {
-      MergeBranchWithComparison(comp);
+    if (computation->AsComparison() != NULL) {
+      MergeBranchWithComparison(computation->AsComparison());
       return;
     }
-    BooleanNegateInstr* neg = definition->AsBooleanNegate();
-    if (neg != NULL) {
-      MergeBranchWithNegate(neg);
+    if (computation->IsBooleanNegate()) {
+      MergeBranchWithNegate(computation->AsBooleanNegate());
       return;
     }
   }
-  ReturnValue(Bind(definition));
+  ReturnValue(Bind(computation));
 }
 
 
 void EffectGraphVisitor::Bailout(const char* reason) {
   owner()->Bailout(reason);
 }
 
 
 void EffectGraphVisitor::InlineBailout(const char* reason) {
   if (owner()->InInliningContext()) owner()->Bailout(reason);
@@ skipping 59 matching lines @@
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
-  ReturnDefinition(new ConstantInstr(node->literal()));
+  ReturnComputation(new ConstantComp(node->literal()));
 }
 
 
 // Type nodes only occur as the right-hand side of instanceof comparisons,
 // and they are handled specially in that context.
 void EffectGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 
 
 // Returns true if the type check can be skipped, for example, if the
 // destination type is Dynamic or if the compile type of the value is a subtype
@@ skipping 98 matching lines @@
   ValueGraphVisitor for_right_value(owner(), temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_left);
   arguments->Add(push_right);
   const String& name = String::ZoneHandle(Symbols::New(node->Name()));
-  InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
-                                                  name,
-                                                  node->kind(),
-                                                  arguments,
-                                                  Array::ZoneHandle(),
-                                                  2);
-  ReturnDefinition(call);
+  InstanceCallComp* call = new InstanceCallComp(node->token_pos(),
+                                                name,
+                                                node->kind(),
+                                                arguments,
+                                                Array::ZoneHandle(),
+                                                2);
+  ReturnComputation(call);
 }
 
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   InlineBailout("ValueGraphVisitor::VisitBinaryOpNode");
   // 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
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
     const Bool& bool_true = Bool::ZoneHandle(Bool::True());
     const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
     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) {
       right_value =
-          for_right.Bind(new AssertBooleanInstr(node->right()->token_pos(),
-                                                right_value));
+          for_right.Bind(new AssertBooleanComp(node->right()->token_pos(),
+                                               right_value));
     }
-    Value* constant_true = for_right.Bind(new ConstantInstr(bool_true));
+    Value* constant_true = for_right.Bind(new ConstantComp(bool_true));
     Value* compare =
-        for_right.Bind(new StrictCompareInstr(Token::kEQ_STRICT,
-                                              right_value,
-                                              constant_true));
+        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());
-      Value* constant_false = for_false.Bind(new ConstantInstr(bool_false));
+      Value* constant_false = for_false.Bind(new ConstantComp(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());
-      Value* constant_true = for_true.Bind(new ConstantInstr(bool_true));
+      Value* constant_true = for_true.Bind(new ConstantComp(bool_true));
       for_true.Do(BuildStoreLocal(
           *owner()->parsed_function().expression_temp_var(),
           constant_true));
       Join(for_test, for_true, for_right);
     }
-    ReturnDefinition(
+    ReturnComputation(
         BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 void EffectGraphVisitor::BuildTypecheckArguments(
     intptr_t token_pos,
     Value** instantiator_result,
@@ skipping 20 matching lines @@
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, loaded);
   }
   *instantiator_result = instantiator;
   *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
 Value* EffectGraphVisitor::BuildNullValue() {
   InlineBailout("EffectGraphVisitor::BuildNullValue");
-  return Bind(new ConstantInstr(Object::ZoneHandle()));
+  return Bind(new ConstantComp(Object::ZoneHandle()));
 }
 
 
 // Used for testing incoming arguments.
-AssertAssignableInstr* EffectGraphVisitor::BuildAssertAssignable(
+AssertAssignableComp* EffectGraphVisitor::BuildAssertAssignable(
     intptr_t token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
   InlineBailout("EffectGraphVisitor::BuildAssertAssignable");
   // Build the type check computation.
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   if (dst_type.IsInstantiated()) {
     instantiator = BuildNullValue();
     instantiator_type_arguments = BuildNullValue();
   } else {
     BuildTypecheckArguments(token_pos,
                             &instantiator,
                             &instantiator_type_arguments);
   }
-  return new AssertAssignableInstr(token_pos,
-                                   value,
-                                   instantiator,
-                                   instantiator_type_arguments,
-                                   dst_type,
-                                   dst_name);
+  return new AssertAssignableComp(token_pos,
+                                  value,
+                                  instantiator,
+                                  instantiator_type_arguments,
+                                  dst_type,
+                                  dst_name);
 }
 
 
 // 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) {
   InlineBailout("EffectGraphVisitor::BuildAssignableValue");
   if (CanSkipTypeCheck(token_pos, value, dst_type, dst_name)) {
@@ skipping 37 matching lines @@
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   const bool negate_result = (node->kind() == Token::kISNOT);
   // All objects are instances of type T if Object type is a subtype of type T.
   const Type& object_type = Type::Handle(Type::ObjectType());
   if (type.IsInstantiated() && object_type.IsSubtypeOf(type, NULL)) {
     // Must evaluate left side.
     EffectGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
-    ReturnDefinition(new ConstantInstr(negate_result ? bool_false : bool_true));
+    ReturnComputation(new ConstantComp(negate_result ? bool_false : bool_true));
     return;
   }
 
   // Eliminate the test if it can be performed successfully at compile time.
   if ((node->left() != NULL) &&
       node->left()->IsLiteralNode() &&
       type.IsInstantiated()) {
     const Instance& literal_value = node->left()->AsLiteralNode()->literal();
     const Class& cls = Class::Handle(literal_value.clazz());
-    ConstantInstr* result = NULL;
+    ConstantComp* result = NULL;
     if (cls.IsNullClass()) {
       // A null object is only an instance of Object and Dynamic, which has
       // already been checked above (if the type is instantiated). So we can
       // return false here if the instance is null (and if the type is
       // instantiated).
-      result = new ConstantInstr(negate_result ? bool_true : bool_false);
+      result = new ConstantComp(negate_result ? bool_true : bool_false);
     } else {
       if (literal_value.IsInstanceOf(type, TypeArguments::Handle(), NULL)) {
-        result = new ConstantInstr(negate_result ? bool_false : bool_true);
+        result = new ConstantComp(negate_result ? bool_false : bool_true);
       } else {
-        result = new ConstantInstr(negate_result ? bool_true : bool_false);
+        result = new ConstantComp(negate_result ? bool_true : bool_false);
       }
     }
-    ReturnDefinition(result);
+    ReturnComputation(result);
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   if (type.IsInstantiated()) {
     instantiator = BuildNullValue();
     instantiator_type_arguments = BuildNullValue();
   } else {
     BuildTypecheckArguments(node->token_pos(),
                             &instantiator,
                             &instantiator_type_arguments);
   }
-  InstanceOfInstr* instance_of =
-      new InstanceOfInstr(node->token_pos(),
-                          for_left_value.value(),
-                          instantiator,
-                          instantiator_type_arguments,
-                          node->right()->AsTypeNode()->type(),
-                          (node->kind() == Token::kISNOT));
-  ReturnDefinition(instance_of);
+  InstanceOfComp* instance_of =
+      new InstanceOfComp(node->token_pos(),
+                         for_left_value.value(),
+                         instantiator,
+                         instantiator_type_arguments,
+                         node->right()->AsTypeNode()->type(),
+                         (node->kind() == Token::kISNOT));
+  ReturnComputation(instance_of);
 }
 
 
 void ValueGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   InlineBailout("ValueGraphVisitor::BuildTypeCast");
   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);
@@ skipping 22 matching lines @@
     return;
   }
   if ((node->kind() == Token::kEQ_STRICT) ||
       (node->kind() == Token::kNE_STRICT)) {
     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);
-    StrictCompareInstr* comp = new StrictCompareInstr(
+    StrictCompareComp* comp = new StrictCompareComp(
         node->kind(), for_left_value.value(), for_right_value.value());
-    ReturnDefinition(comp);
+    ReturnComputation(comp);
     return;
   }
 
   if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     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);
     if (FLAG_enable_type_checks) {
-      EqualityCompareInstr* comp = new EqualityCompareInstr(
+      EqualityCompareComp* comp = new EqualityCompareComp(
           node->token_pos(),
           Token::kEQ,
           for_left_value.value(),
           for_right_value.value());
       if (node->kind() == Token::kEQ) {
-        ReturnDefinition(comp);
+        ReturnComputation(comp);
       } else {
         Value* eq_result = Bind(comp);
-        eq_result = Bind(new AssertBooleanInstr(node->token_pos(), eq_result));
-        ReturnDefinition(new BooleanNegateInstr(eq_result));
+        eq_result = Bind(new AssertBooleanComp(node->token_pos(), eq_result));
+        ReturnComputation(new BooleanNegateComp(eq_result));
       }
     } else {
-      EqualityCompareInstr* comp = new EqualityCompareInstr(
+      EqualityCompareComp* comp = new EqualityCompareComp(
           node->token_pos(),
           node->kind(),
           for_left_value.value(),
           for_right_value.value());
-      ReturnDefinition(comp);
+      ReturnComputation(comp);
     }
     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);
-  RelationalOpInstr* comp = new RelationalOpInstr(node->token_pos(),
-                                                  node->kind(),
-                                                  for_left_value.value(),
-                                                  for_right_value.value());
-  ReturnDefinition(comp);
+  RelationalOpComp* comp = new RelationalOpComp(node->token_pos(),
+                                                node->kind(),
+                                                for_left_value.value(),
+                                                for_right_value.value());
+  ReturnComputation(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   InlineBailout("EffectGraphVisitor::VisitUnaryOpNode");
   // "!" 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) {
       value =
-          Bind(new AssertBooleanInstr(node->operand()->token_pos(), value));
+          Bind(new AssertBooleanComp(node->operand()->token_pos(), value));
     }
-    BooleanNegateInstr* negate = new BooleanNegateInstr(value);
-    ReturnDefinition(negate);
+    BooleanNegateComp* negate = new BooleanNegateComp(value);
+    ReturnComputation(negate);
     return;
   }
   ValueGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   PushArgumentInstr* push_value = PushArgument(for_value.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
   String& name = String::ZoneHandle();
   if (node->kind() == Token::kSUB) {
     name = Symbols::New("unary-");
   } else {
     name = Symbols::New(Token::Str(node->kind()));
   }
-  InstanceCallInstr* call = new InstanceCallInstr(
+  InstanceCallComp* call = new InstanceCallComp(
       node->token_pos(), name, node->kind(),
       arguments, Array::ZoneHandle(), 1);
-  ReturnDefinition(call);
+  ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   InlineBailout("EffectGraphVisitor::VisitConditionalExprNode");
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
@@ skipping 20 matching lines @@
   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.Do(BuildStoreLocal(
       *owner()->parsed_function().expression_temp_var(), for_false.value()));
 
   Join(for_test, for_true, for_false);
-  ReturnDefinition(
+  ReturnComputation(
       BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
@@ skipping 150 matching lines @@
 void EffectGraphVisitor::VisitWhileNode(WhileNode* node) {
   InlineBailout("EffectGraphVisitor::VisitWhileNode");
   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());
   for_body.Do(
-      new CheckStackOverflowInstr(node->token_pos()));
+      new CheckStackOverflowComp(node->token_pos()));
   node->body()->Visit(&for_body);
 
   // Labels are set after body traversal.
   SourceLabel* lbl = node->label();
   ASSERT(lbl != NULL);
   JoinEntryInstr* join = lbl->join_for_continue();
   if (join != NULL) {
     if (for_body.is_open()) for_body.Goto(join);
     for_body.exit_ = join;
   }
@@ skipping 12 matching lines @@
 // 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) {
   InlineBailout("EffectGraphVisitor::VisitDoWhileNode");
   // Traverse body first in order to generate continue and break labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   for_body.Do(
-      new CheckStackOverflowInstr(node->token_pos()));
+      new CheckStackOverflowComp(node->token_pos()));
   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(owner()->try_index());
@@ skipping 40 matching lines @@
 void EffectGraphVisitor::VisitForNode(ForNode* node) {
   InlineBailout("EffectGraphVisitor::VisitForNode");
   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());
   for_body.Do(
-      new CheckStackOverflowInstr(node->token_pos()));
+      new CheckStackOverflowComp(node->token_pos()));
   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());
   node->increment()->Visit(&for_increment);
   JoinEntryInstr* join = node->label()->join_for_continue();
   if (join != NULL) {
     // Insert the join between the body and increment.
@@ skipping 105 matching lines @@
 
 
 void EffectGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
   InlineBailout("EffectGraphVisitor::VisitArgumentListNode");
   UNREACHABLE();
 }
 
 
 void EffectGraphVisitor::VisitArgumentDefinitionTestNode(
     ArgumentDefinitionTestNode* node) {
-  Definition* load = BuildLoadLocal(node->saved_arguments_descriptor());
+  Computation* load = BuildLoadLocal(node->saved_arguments_descriptor());
   Value* arguments_descriptor = Bind(load);
-  ArgumentDefinitionTestInstr* arg_def_test =
-      new ArgumentDefinitionTestInstr(node, arguments_descriptor);
-  ReturnDefinition(arg_def_test);
+  ArgumentDefinitionTestComp* arg_def_test =
+      new ArgumentDefinitionTestComp(node, arguments_descriptor);
+  ReturnComputation(arg_def_test);
 }
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   InlineBailout("EffectGraphVisitor::VisitArrayNode");
   // Translate the array elements and collect their values.
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(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);
     arguments->Add(PushArgument(for_value.value()));
   }
   const AbstractTypeArguments& type_args =
       AbstractTypeArguments::ZoneHandle(node->type().arguments());
   Value* element_type = BuildInstantiatedTypeArguments(node->token_pos(),
                                                        type_args);
-  CreateArrayInstr* create = new CreateArrayInstr(node->token_pos(),
-                                                  arguments,
-                                                  node->type(),
-                                                  element_type);
-  ReturnDefinition(create);
+  CreateArrayComp* create = new CreateArrayComp(node->token_pos(),
+                                                arguments,
+                                                node->type(),
+                                                element_type);
+  ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   InlineBailout("EffectGraphVisitor::VisitClosureNode");
   const Function& function = node->function();
 
   Value* receiver = NULL;
   if (function.IsNonImplicitClosureFunction()) {
     // The context scope may have already been set by the non-optimizing
@@ skipping 28 matching lines @@
   const bool requires_type_arguments = cls.HasTypeArguments();
   Value* type_arguments = NULL;
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
     type_arguments = BuildInstantiatorTypeArguments(node->token_pos(), NULL);
   } else {
     type_arguments = BuildNullValue();
   }
   PushArgumentInstr* push_type_arguments = PushArgument(type_arguments);
   arguments->Add(push_type_arguments);
-  ReturnDefinition(new CreateClosureInstr(node, arguments));
+  ReturnComputation(new CreateClosureComp(node, arguments));
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
     ZoneGrowableArray<Value*>* values) {
   InlineBailout("EffectGraphVisitor::TranslateArgumentList");
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_argument(owner(), temp_index());
     node.NodeAt(i)->Visit(&for_argument);
@@ skipping 22 matching lines @@
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(
           node->arguments()->length() + 1);
   arguments->Add(push_receiver);
 
   BuildPushArguments(*node->arguments(), arguments);
-  InstanceCallInstr* call = new InstanceCallInstr(
+  InstanceCallComp* call = new InstanceCallComp(
       node->token_pos(),
       node->function_name(), Token::kILLEGAL, arguments,
       node->arguments()->names(), 1);
-  ReturnDefinition(call);
+  ReturnComputation(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   InlineBailout("EffectGraphVisitor::VisitStaticCallNode");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   BuildPushArguments(*node->arguments(), arguments);
-  StaticCallInstr* call =
-      new StaticCallInstr(node->token_pos(),
-                          node->function(),
-                          node->arguments()->names(),
-                          arguments);
-  ReturnDefinition(call);
+  StaticCallComp* call =
+      new StaticCallComp(node->token_pos(),
+                         node->function(),
+                         node->arguments()->names(),
+                         arguments);
+  ReturnComputation(call);
 }
 
 
-ClosureCallInstr* EffectGraphVisitor::BuildClosureCall(
+ClosureCallComp* EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node) {
   InlineBailout("EffectGraphVisitor::BuildClosureCall");
   ValueGraphVisitor for_closure(owner(), temp_index());
   node->closure()->Visit(&for_closure);
   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.
   BuildStoreContext(*owner()->parsed_function().expression_temp_var());
-  return new ClosureCallInstr(node, arguments);
+  return new ClosureCallComp(node, arguments);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   InlineBailout("EffectGraphVisitor::VisitClosureCallNode");
   Do(BuildClosureCall(node));
   // Restore context from saved location.
   BuildLoadContext(*owner()->parsed_function().expression_temp_var());
 }
 
 
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   InlineBailout("ValueGraphVisitor::VisitClosureCallNode");
   Value* result = Bind(BuildClosureCall(node));
   // Restore context from temp.
   BuildLoadContext(*owner()->parsed_function().expression_temp_var());
   ReturnValue(result);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   InlineBailout("EffectGraphVisitor::VisitCloneContextNode");
-  Value* context = Bind(new CurrentContextInstr());
-  Value* clone = Bind(new CloneContextInstr(node->token_pos(), context));
-  ReturnDefinition(new StoreContextInstr(clone));
+  Value* context = Bind(new CurrentContextComp());
+  Value* clone = Bind(new CloneContextComp(node->token_pos(), context));
+  ReturnComputation(new StoreContextComp(clone));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   InlineBailout("EffectGraphVisitor::BuildObjectAllocation");
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   // In checked mode, if the type arguments are uninstantiated, they may need to
   // be checked against declared bounds at run time.
-  Definition* allocate_comp = NULL;
+  Computation* allocate_comp = NULL;
   if (FLAG_enable_type_checks &&
       requires_type_arguments &&
       !node->type_arguments().IsNull() &&
       !node->type_arguments().IsInstantiated() &&
       !node->type_arguments().IsWithinBoundsOf(cls,
                                                node->type_arguments(),
                                                NULL)) {
     Value* type_arguments = NULL;
     Value* instantiator = NULL;
     BuildConstructorTypeArguments(node, &type_arguments, &instantiator, NULL);
 
     // The uninstantiated type arguments cannot be verified to be within their
     // bounds at compile time, so verify them at runtime.
     // Although the type arguments may be uninstantiated at compile time, they
     // may represent the identity vector and may be replaced by the instantiated
     // type arguments of the instantiator at run time.
-    allocate_comp = new AllocateObjectWithBoundsCheckInstr(node,
-                                                           type_arguments,
-                                                           instantiator);
+    allocate_comp = new AllocateObjectWithBoundsCheckComp(node,
+                                                          type_arguments,
+                                                          instantiator);
   } else {
     ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
         new ZoneGrowableArray<PushArgumentInstr*>();
 
     if (requires_type_arguments) {
       BuildConstructorTypeArguments(node, NULL, NULL, allocate_arguments);
     }
 
-    allocate_comp = new AllocateObjectInstr(node, allocate_arguments);
+    allocate_comp = new AllocateObjectComp(node, allocate_arguments);
   }
   return Bind(allocate_comp);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
   InlineBailout("EffectGraphVisitor::BuildConstructorCall");
   Value* ctor_arg = Bind(
-      new ConstantInstr(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
+      new ConstantComp(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
   PushArgumentInstr* push_ctor_arg = PushArgument(ctor_arg);
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_alloc_value);
   arguments->Add(push_ctor_arg);
 
   BuildPushArguments(*node->arguments(), arguments);
-  Do(new StaticCallInstr(node->token_pos(),
-                         node->constructor(),
-                         node->arguments()->names(),
-                         arguments));
+  Do(new StaticCallComp(node->token_pos(),
+                        node->constructor(),
+                        node->arguments()->names(),
+                        arguments));
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   InlineBailout("EffectGraphVisitor::VisitConstructorCallNode");
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new 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 StaticCallInstr(node->token_pos(),
-                            node->constructor(),
-                            node->arguments()->names(),
-                            arguments);
-    ReturnDefinition(call);
+    StaticCallComp* call =
+        new StaticCallComp(node->token_pos(),
+                           node->constructor(),
+                           node->arguments()->names(),
+                           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).
   Value* allocated_value = BuildObjectAllocation(node);
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
@@ skipping 36 matching lines @@
     // The type arguments are compile time constants.
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
     // Type is temporary. Only its type arguments are preserved.
     Type& type = Type::Handle(
         Type::New(instantiator_class, type_arguments, token_pos, Heap::kNew));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalize);
     ASSERT(!type.IsMalformed());
     type_arguments = type.arguments();
     type_arguments = type_arguments.Canonicalize();
-    return Bind(new ConstantInstr(type_arguments));
+    return Bind(new ConstantComp(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);
 
-  return Bind(new LoadVMFieldInstr(
+  return Bind(new LoadVMFieldComp(
       instantiator,
       type_arguments_instance_field_offset,
       Type::ZoneHandle()));  // Not an instance, no type.
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_pos,
     const AbstractTypeArguments& type_arguments) {
   InlineBailout("EffectGraphVisitor::BuildInstantiatedTypeArguments");
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
-    return Bind(new ConstantInstr(type_arguments));
+    return Bind(new ConstantComp(type_arguments));
   }
   // The type arguments are uninstantiated.
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(token_pos, NULL);
-  return Bind(new InstantiateTypeArgumentsInstr(token_pos,
-                                                type_arguments,
-                                                instantiator_value));
+  return Bind(new InstantiateTypeArgumentsComp(token_pos,
+                                               type_arguments,
+                                               instantiator_value));
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
     Value** type_arguments,
     Value** instantiator,
     ZoneGrowableArray<PushArgumentInstr*>* call_arguments) {
   InlineBailout("EffectGraphVisitor::BuildConstructorTypeArguments");
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   ASSERT(cls.HasTypeArguments() && !node->constructor().IsFactory());
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
-    Value* type_arguments_val = Bind(new ConstantInstr(node->type_arguments()));
+    Value* type_arguments_val = Bind(new ConstantComp(node->type_arguments()));
     if (call_arguments != NULL) {
       ASSERT(type_arguments == NULL);
       call_arguments->Add(PushArgument(type_arguments_val));
     } else {
       ASSERT(type_arguments != NULL);
       *type_arguments = type_arguments_val;
     }
 
     // No instantiator required.
-    Value* instantiator_val = Bind(new ConstantInstr(
+    Value* instantiator_val = Bind(new ConstantComp(
         Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
     if (call_arguments != NULL) {
       ASSERT(instantiator == NULL);
       call_arguments->Add(PushArgument(instantiator_val));
     } else {
       ASSERT(instantiator != NULL);
       *instantiator = instantiator_val;
     }
     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);
   Value* stored_instantiator =
       Bind(BuildStoreLocal(t1, instantiator_type_arguments));
   // t1: instantiator type arguments.
 
   Value* extract_type_arguments = Bind(
-      new ExtractConstructorTypeArgumentsInstr(
+      new ExtractConstructorTypeArgumentsComp(
           node->token_pos(),
           node->type_arguments(),
           stored_instantiator));
 
   Do(BuildStoreLocal(t2, extract_type_arguments));
   // t2: extracted constructor type arguments.
   Value* load_instantiator = Bind(BuildLoadLocal(t1));
 
   Value* extract_instantiator =
-      Bind(new ExtractConstructorInstantiatorInstr(node, load_instantiator));
+      Bind(new ExtractConstructorInstantiatorComp(node, load_instantiator));
   Do(BuildStoreLocal(t1, extract_instantiator));
   // t2: extracted constructor type arguments.
   // t1: extracted constructor instantiator.
   Value* type_arguments_val = Bind(BuildLoadLocal(t2));
   if (call_arguments != NULL) {
     ASSERT(type_arguments == NULL);
     call_arguments->Add(PushArgument(type_arguments_val));
   } else {
     ASSERT(type_arguments != NULL);
     *type_arguments = type_arguments_val;
@@ skipping 19 matching lines @@
 
   // 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)
 
   Value* allocate = BuildObjectAllocation(node);
-  Definition* store_allocated = BuildStoreLocal(
+  Computation* store_allocated = BuildStoreLocal(
       node->allocated_object_var(),
       allocate);
   Value* allocated_value = Bind(store_allocated);
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
   BuildConstructorCall(node, push_allocated_value);
-  Definition* load_allocated = BuildLoadLocal(
+  Computation* load_allocated = BuildLoadLocal(
       node->allocated_object_var());
   allocated_value = Bind(load_allocated);
   ReturnValue(allocated_value);
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   InlineBailout("EffectGraphVisitor::VisitConstructorCallNode");
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_receiver);
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
-  InstanceCallInstr* call = new InstanceCallInstr(
+  InstanceCallComp* call = new InstanceCallComp(
       node->token_pos(), name, Token::kGET,
       arguments, Array::ZoneHandle(), 1);
-  ReturnDefinition(call);
+  ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
   InlineBailout("EffectGraphVisitor::BuildInstanceSetterArguments");
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
@@ skipping 16 matching lines @@
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   InlineBailout("EffectGraphVisitor::VisitInstanceSetterNode");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, false);  // Value not used.
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
-  InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
-                                                  name,
-                                                  Token::kSET,
-                                                  arguments,
-                                                  Array::ZoneHandle(),
-                                                  1);  // Checked arg count.
-  ReturnDefinition(call);
+  InstanceCallComp* call = new InstanceCallComp(node->token_pos(),
+                                                name,
+                                                Token::kSET,
+                                                arguments,
+                                                Array::ZoneHandle(),
+                                                1);  // Checked argument count.
+  ReturnComputation(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   InlineBailout("ValueGraphVisitor::VisitInstanceSetterNode");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, true);  // Value used.
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
-  Do(new InstanceCallInstr(node->token_pos(),
-                           name,
-                           Token::kSET,
-                           arguments,
-                           Array::ZoneHandle(),
-                           1));  // Checked argument count.
-  ReturnDefinition(
+  Do(new InstanceCallComp(node->token_pos(),
+                          name,
+                          Token::kSET,
+                          arguments,
+                          Array::ZoneHandle(),
+                          1));  // Checked argument count.
+  ReturnComputation(
        BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   InlineBailout("EffectGraphVisitor::VisitStaticGetterNode");
   const String& getter_name =
       String::Handle(Field::GetterName(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle();
   if (node->is_super_getter()) {
     // Statically resolved instance getter, i.e. "super getter".
     getter_function =
     Resolver::ResolveDynamicAnyArgs(node->cls(), getter_name);
     ASSERT(!getter_function.IsNull());
     ASSERT(node->receiver() != NULL);
     ValueGraphVisitor receiver_value(owner(), temp_index());
     node->receiver()->Visit(&receiver_value);
     Append(receiver_value);
     arguments->Add(PushArgument(receiver_value.value()));
   } else {
     getter_function = node->cls().LookupStaticFunction(getter_name);
     ASSERT(!getter_function.IsNull());
   }
-  StaticCallInstr* call = new StaticCallInstr(node->token_pos(),
-                                              getter_function,
-                                              Array::ZoneHandle(),  // No names.
-                                              arguments);
-  ReturnDefinition(call);
+  StaticCallComp* call = new StaticCallComp(node->token_pos(),
+                                            getter_function,
+                                            Array::ZoneHandle(),  // No names.
+                                            arguments);
+  ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
   InlineBailout("EffectGraphVisitor::BuildStaticSetter");
   const String& setter_name =
       String::Handle(Field::SetterName(node->field_name()));
   // A super setter is an instance setter whose setter function is
   // resolved at compile time (in the caller instance getter's super class).
@@ skipping 20 matching lines @@
   Value* value = NULL;
   if (result_is_needed) {
     value = Bind(
         BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
                         for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
-  StaticCallInstr* call = new StaticCallInstr(node->token_pos(),
-                                              setter_function,
-                                              Array::ZoneHandle(),  // No names.
-                                              arguments);
+  StaticCallComp* call = new StaticCallComp(node->token_pos(),
+                                            setter_function,
+                                            Array::ZoneHandle(),  // No names.
+                                            arguments);
   if (result_is_needed) {
     Do(call);
-    ReturnDefinition(
+    ReturnComputation(
          BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
   } else {
-    ReturnDefinition(call);
+    ReturnComputation(call);
   }
 }
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   InlineBailout("EffectGraphVisitor::VisitStaticSetterNode");
   BuildStaticSetter(node, false);  // Result not needed.
 }
 
 
 void ValueGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   InlineBailout("ValueGraphVisitor::VisitStaticSetterNode");
   BuildStaticSetter(node, true);  // Result needed.
 }
 
 
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
   InlineBailout("EffectGraphVisitor::VisitNativeBodyNode");
-  NativeCallInstr* native_call = new NativeCallInstr(node);
-  ReturnDefinition(native_call);
+  NativeCallComp* native_call = new NativeCallComp(node);
+  ReturnComputation(native_call);
 }
 
 
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
   InlineBailout("EffectGraphVisitor::VisitPrimaryNode");
   // PrimaryNodes are temporary during parsing.
   UNREACHABLE();
 }
 
 
 // <Expression> ::= LoadLocal { local: LocalVariable }
 void EffectGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   InlineBailout("EffectGraphVisitor::VisitLoadLocalNode");
   if (node->HasPseudo()) {
     EffectGraphVisitor for_pseudo(owner(), temp_index());
     node->pseudo()->Visit(&for_pseudo);
     Append(for_pseudo);
   }
 }
 
 
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   InlineBailout("ValueGraphVisitor::VisitLoadLocalNode");
   EffectGraphVisitor::VisitLoadLocalNode(node);
-  Definition* load = BuildLoadLocal(node->local());
-  ReturnDefinition(load);
+  Computation* load = BuildLoadLocal(node->local());
+  ReturnComputation(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   InlineBailout("EffectGraphVisitor::VisitStoreLocalNode");
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name());
   }
-  Definition* store = BuildStoreLocal(node->local(), store_value);
-  ReturnDefinition(store);
+  Computation* store = BuildStoreLocal(node->local(), store_value);
+  ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   InlineBailout("EffectGraphVisitor::VisitLoadInstanceFieldNode");
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
-  LoadInstanceFieldInstr* load = new LoadInstanceFieldInstr(
+  LoadInstanceFieldComp* load = new LoadInstanceFieldComp(
       node->field(), for_instance.value());
-  ReturnDefinition(load);
+  ReturnComputation(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
   InlineBailout("EffectGraphVisitor::VisitStoreInstanceFieldNode");
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner(), for_instance.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
   }
-  StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
+  StoreInstanceFieldComp* store = new StoreInstanceFieldComp(
       node->field(), for_instance.value(), store_value);
-  ReturnDefinition(store);
+  ReturnComputation(store);
 }
 
 
 // StoreInstanceFieldNode does not return result.
 void ValueGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
   InlineBailout("ValueGraphVisitor::VisitStoreInstanceFieldNode");
   UNIMPLEMENTED();
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   InlineBailout("EffectGraphVisitor::VisitLoadStaticFieldNode");
-  LoadStaticFieldInstr* load = new LoadStaticFieldInstr(node->field());
-  ReturnDefinition(load);
+  LoadStaticFieldComp* load = new LoadStaticFieldComp(node->field());
+  ReturnComputation(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   InlineBailout("EffectGraphVisitor::VisitStoreStaticFieldNode");
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
   }
-  StoreStaticFieldInstr* store =
-      new StoreStaticFieldInstr(node->field(), store_value);
-  ReturnDefinition(store);
+  StoreStaticFieldComp* store =
+      new StoreStaticFieldComp(node->field(), store_value);
+  ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   InlineBailout("EffectGraphVisitor::VisitLoadIndexedNode");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
   ValueGraphVisitor for_index(owner(), temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   const intptr_t checked_argument_count = 1;
   const String& name =
       String::ZoneHandle(Symbols::New(Token::Str(Token::kINDEX)));
-  InstanceCallInstr* load = new InstanceCallInstr(node->token_pos(),
-                                                  name,
-                                                  Token::kINDEX,
-                                                  arguments,
-                                                  Array::ZoneHandle(),
-                                                  checked_argument_count);
-  ReturnDefinition(load);
+  InstanceCallComp* load = new InstanceCallComp(node->token_pos(),
+                                                name,
+                                                Token::kINDEX,
+                                                arguments,
+                                                Array::ZoneHandle(),
+                                                checked_argument_count);
+  ReturnComputation(load);
 }
 
 
-Definition* EffectGraphVisitor::BuildStoreIndexedValues(
+Computation* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
   InlineBailout("EffectGraphVisitor::BuildStoreIndexedValues");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(3);
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
@@ skipping 11 matching lines @@
         BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
                         for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
   const intptr_t checked_argument_count = 1;
   const String& name =
       String::ZoneHandle(Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
-  InstanceCallInstr* store = new InstanceCallInstr(node->token_pos(),
-                                                   name,
-                                                   Token::kASSIGN_INDEX,
-                                                   arguments,
-                                                   Array::ZoneHandle(),
-                                                   checked_argument_count);
+  InstanceCallComp* store = new InstanceCallComp(node->token_pos(),
+                                                 name,
+                                                 Token::kASSIGN_INDEX,
+                                                 arguments,
+                                                 Array::ZoneHandle(),
+                                                 checked_argument_count);
   if (result_is_needed) {
     Do(store);
     return BuildLoadLocal(*owner()->parsed_function().expression_temp_var());
   } else {
     return store;
   }
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   InlineBailout("EffectGraphVisitor::VisitStoreIndexedNode");
-  ReturnDefinition(BuildStoreIndexedValues(node,
-                                           false));  // Result not needed.
+  ReturnComputation(BuildStoreIndexedValues(node,
+                                            false));  // Result not needed.
 }
 
 
 void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   InlineBailout("ValueGraphVisitor::VisitStoreIndexedNode");
-  ReturnDefinition(BuildStoreIndexedValues(node,
-                                           true));  // Result is needed.
+  ReturnComputation(BuildStoreIndexedValues(node,
+                                            true));  // Result is needed.
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function().node_sequence()) &&
          (owner()->parsed_function().saved_context_var() != NULL);
 }
 
 
 void EffectGraphVisitor::UnchainContext() {
   InlineBailout("EffectGraphVisitor::UnchainContext");
-  Value* context = Bind(new CurrentContextInstr());
+  Value* context = Bind(new CurrentContextComp());
   Value* parent = Bind(
-      new LoadVMFieldInstr(context,
-                           Context::parent_offset(),
-                           Type::ZoneHandle()));  // Not an instance, no type.
-  Do(new StoreContextInstr(parent));
+      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) {
     InlineBailout("EffectGraphVisitor::VisitSequenceNode (captured vars)");
     // 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));
+        Bind(new AllocateContextComp(node->token_pos(), 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)) {
-      Value* current_context = Bind(new CurrentContextInstr());
+      Value* current_context = Bind(new CurrentContextComp());
       Do(BuildStoreLocal(*owner()->parsed_function().saved_context_var(),
                          current_context));
-      Value* null_context = Bind(new ConstantInstr(Object::ZoneHandle()));
-      Do(new StoreContextInstr(null_context));
+      Value* null_context = Bind(new ConstantComp(Object::ZoneHandle()));
+      Do(new StoreContextComp(null_context));
     }
 
-    Do(new ChainContextInstr(allocated_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();
       int num_params = function.NumberOfParameters();
       int param_frame_index = (num_params == function.num_fixed_parameters()) ?
           (1 + num_params) : ParsedFunction::kFirstLocalSlotIndex;
@@ skipping 15 matching lines @@
               Type::ZoneHandle(Type::DynamicType()));  // Type.
           temp_local->set_index(param_frame_index);
 
           // Copy parameter from local frame to current context.
           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.
           Value* null_constant =
-              Bind(new ConstantInstr(Object::ZoneHandle()));
+              Bind(new ConstantComp(Object::ZoneHandle()));
           Do(BuildStoreLocal(*temp_local, null_constant));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
     InlineBailout("EffectGraphVisitor::VisitSequenceNode (type check)");
     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(parameter.token_pos(),
                             NULL,
                             parameter.type(),
                             parameter.name())) {
         Value* parameter_value = Bind(BuildLoadLocal(parameter));
-        AssertAssignableInstr* assert_assignable =
+        AssertAssignableComp* assert_assignable =
             BuildAssertAssignable(parameter.token_pos(),
                                   parameter_value,
                                   parameter.type(),
                                   parameter.name());
         parameter_value = Bind(assert_assignable);
         // Store the type checked argument back to its corresponding local
         // variable so that ssa renaming detects the dependency and makes use
         // of the checked type in type propagation.
         Do(BuildStoreLocal(parameter, parameter_value));
       }
@@ skipping 37 matching lines @@
          (node != owner()->parsed_function().node_sequence()));
   owner()->set_context_level(previous_context_level);
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   InlineBailout("EffectGraphVisitor::VisitCatchClauseNode");
   // NOTE: The implicit variables ':saved_context', ':exception_var'
   // and ':stacktrace_var' can never be captured variables.
   // Restores CTX from local variable ':saved_context'.
-  Do(new CatchEntryInstr(node->exception_var(), node->stacktrace_var()));
+  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) {
   InlineBailout("EffectGraphVisitor::VisitTryCatchNode");
@@ skipping 79 matching lines @@
   CloseFragment();
 }
 
 
 // A throw cannot be part of an expression, however, the parser may replace
 // certain expression nodes with a throw. In that case generate a literal null
 // so that the fragment is not closed in the middle of an expression.
 void ValueGraphVisitor::VisitThrowNode(ThrowNode* node) {
   InlineBailout("ValueGraphVisitor::VisitThrowNode");
   BuildThrowNode(node);
-  ReturnDefinition(new ConstantInstr(Instance::ZoneHandle()));
+  ReturnComputation(new ConstantComp(Instance::ZoneHandle()));
 }
 
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   InlineBailout("EffectGraphVisitor::VisitInlinedFinallyNode");
   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.
@@ skipping 27 matching lines @@
     AstPrinter::PrintFunctionNodes(parsed_function());
   }
   // Compilation can be nested, preserve the computation-id.
   const Function& function = parsed_function().function();
   TargetEntryInstr* normal_entry = new TargetEntryInstr(
       CatchClauseNode::kInvalidTryIndex);
   graph_entry_ = new GraphEntryInstr(normal_entry);
   EffectGraphVisitor for_effect(this, 0);
   // TODO(kmillikin): We can eliminate stack checks in some cases (e.g., the
   // stack check on entry for leaf routines).
-  for_effect.Do(new CheckStackOverflowInstr(function.token_pos()));
+  for_effect.Do(new CheckStackOverflowComp(function.token_pos()));
   parsed_function().node_sequence()->Visit(&for_effect);
   AppendFragment(normal_entry, for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
   return new FlowGraph(*this, graph_entry_);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphForInlining(InliningContext context) {
   ASSERT(inlining_context_ == kNotInlining);
@@ skipping 18 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