Reapply "Remove classes Computation and BindInstr."

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, enable_type_checks);
 
 
-intptr_t Computation::Hashcode() const {
-  intptr_t result = computation_kind();
+intptr_t Definition::Hashcode() const {
+  intptr_t result = tag();
   for (intptr_t i = 0; i < InputCount(); ++i) {
     Value* value = InputAt(i);
     intptr_t j = value->definition()->ssa_temp_index();
     result = result * 31 + j;
   }
   return result;
 }
 
 
-bool Computation::Equals(Computation* other) const {
-  if (computation_kind() != other->computation_kind()) return false;
+bool Definition::Equals(Definition* other) const {
+  if (tag() != other->tag()) return false;
   for (intptr_t i = 0; i < InputCount(); ++i) {
     if (!InputAt(i)->Equals(other->InputAt(i))) return false;
   }
   return AttributesEqual(other);
 }
 
 
 bool Value::Equals(Value* other) const {
   return definition() == other->definition();
 }
 
 
-bool CheckClassComp::AttributesEqual(Computation* other) const {
-  CheckClassComp* other_check = other->AsCheckClass();
-  if (other_check == NULL) return false;
+bool CheckClassInstr::AttributesEqual(Definition* other) const {
+  CheckClassInstr* other_check = other->AsCheckClass();
+  ASSERT(other_check != NULL);
   if (unary_checks().NumberOfChecks() !=
       other_check->unary_checks().NumberOfChecks()) {
     return false;
   }
   for (intptr_t i = 0; i < unary_checks().NumberOfChecks(); ++i) {
     // TODO(fschneider): Make sure ic_data are sorted to hit more cases.
     if (unary_checks().GetReceiverClassIdAt(i) !=
         other_check->unary_checks().GetReceiverClassIdAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
-bool CheckArrayBoundComp::AttributesEqual(Computation* other) const {
-  CheckArrayBoundComp* other_check = other->AsCheckArrayBound();
-  if (other_check == NULL) return false;
+bool CheckArrayBoundInstr::AttributesEqual(Definition* other) const {
+  CheckArrayBoundInstr* other_check = other->AsCheckArrayBound();
+  ASSERT(other_check != NULL);
   return array_type() == other_check->array_type();
 }
 
 
 // Returns true if the value represents a constant.
 bool Value::BindsToConstant() const {
-  BindInstr* bind = definition()->AsBind();
-  return (bind != NULL) && (bind->computation()->AsConstant() != NULL);
+  return definition()->IsConstant();
 }
 
 
 // Returns true if the value represents constant null.
 bool Value::BindsToConstantNull() const {
-  BindInstr* bind = definition()->AsBind();
-  if (bind == NULL) {
-    return false;
-  }
-  ConstantComp* constant = bind->computation()->AsConstant();
+  ConstantInstr* constant = definition()->AsConstant();
   return (constant != NULL) && constant->value().IsNull();
 }
 
 
 const Object& Value::BoundConstant() const {
   ASSERT(BindsToConstant());
-  BindInstr* bind = definition()->AsBind();
-  ASSERT(bind != NULL);
-  ConstantComp* constant = bind->computation()->AsConstant();
+  ConstantInstr* constant = definition()->AsConstant();
   ASSERT(constant != NULL);
   return constant->value();
 }
 
 
-bool ConstantComp::AttributesEqual(Computation* other) const {
-  ConstantComp* other_constant = other->AsConstant();
-  return (other_constant != NULL) &&
-      (value().raw() == other_constant->value().raw());
+bool ConstantInstr::AttributesEqual(Definition* other) const {
+  ConstantInstr* other_constant = other->AsConstant();
+  ASSERT(other_constant != NULL);
+  return (value().raw() == other_constant->value().raw());
 }
 
 
 GraphEntryInstr::GraphEntryInstr(TargetEntryInstr* normal_entry)
     : BlockEntryInstr(CatchClauseNode::kInvalidTryIndex),
       normal_entry_(normal_entry),
       catch_entries_(),
       start_env_(NULL),
-      constant_null_(new BindInstr(Definition::kValue,
-                         new ConstantComp(Object::ZoneHandle()))),
+      constant_null_(new ConstantInstr(Object::ZoneHandle())),
       spill_slot_count_(0) {
 }
 
 
 MethodRecognizer::Kind MethodRecognizer::RecognizeKind(
     const Function& function) {
   // Only core and math library methods can be recognized.
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
   const Library& math_lib = Library::Handle(Library::MathLibrary());
@@ skipping 23 matching lines @@
 const char* MethodRecognizer::KindToCString(Kind kind) {
 #define KIND_TO_STRING(class_name, function_name, enum_name)                   \
   if (kind == k##enum_name) return #enum_name;
 RECOGNIZED_LIST(KIND_TO_STRING)
 #undef KIND_TO_STRING
   return "?";
 }
 
 
 // ==== Support for visiting flow graphs.
-#define DEFINE_ACCEPT(ShortName, ClassName)                                    \
-void ClassName::Accept(FlowGraphVisitor* visitor, BindInstr* instr) {          \
-  visitor->Visit##ShortName(this, instr);                                      \
-}
-
-FOR_EACH_COMPUTATION(DEFINE_ACCEPT)
-
-#undef DEFINE_ACCEPT
-
-
 #define DEFINE_ACCEPT(ShortName)                                               \
 void ShortName##Instr::Accept(FlowGraphVisitor* visitor) {                     \
   visitor->Visit##ShortName(this);                                             \
 }
 
 FOR_EACH_INSTRUCTION(DEFINE_ACCEPT)
 
 #undef DEFINE_ACCEPT
 
 
@@ skipping 32 matching lines @@
 void Definition::InsertAfter(Instruction* prev) {
   ASSERT(previous_ == NULL);
   ASSERT(next_ == NULL);
   previous_ = prev;
   next_ = prev->next_;
   next_->previous_ = this;
   previous_->next_ = this;
 }
 
 
-ConstantComp* Definition::AsConstant() {
-  BindInstr* bind = AsBind();
-  return (bind != NULL) ? bind->computation()->AsConstant() : NULL;
-}
-
-
 void ForwardInstructionIterator::RemoveCurrentFromGraph() {
   current_ = current_->RemoveFromGraph(true);  // Set current_ to previous.
 }
 
 
+void ForwardInstructionIterator::ReplaceCurrentWith(Definition* other) {
+  Definition* defn = current_->AsDefinition();
+  ASSERT(defn != NULL);
+  defn->ReplaceUsesWith(other);
+  ASSERT(other->env() == NULL);
+  other->set_env(defn->env());
+  defn->set_env(NULL);
+  ASSERT(!other->HasSSATemp());
+  if (defn->HasSSATemp()) other->set_ssa_temp_index(defn->ssa_temp_index());
+
+  other->InsertBefore(current_);  // So other will be current.
+  RemoveCurrentFromGraph();
+}
+
+
 // Default implementation of visiting basic blocks.  Can be overridden.
 void FlowGraphVisitor::VisitBlocks() {
   ASSERT(current_iterator_ == NULL);
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
     entry->Accept(this);
     ForwardInstructionIterator it(entry);
     current_iterator_ = &it;
     for (; !it.Done(); it.Advance()) {
       it.Current()->Accept(this);
@@ skipping 128 matching lines @@
 
 intptr_t JoinEntryInstr::IndexOfPredecessor(BlockEntryInstr* pred) const {
   for (intptr_t i = 0; i < predecessors_.length(); ++i) {
     if (predecessors_[i] == pred) return i;
   }
   return -1;
 }
 
 
 // ==== Recording assigned variables.
-void Computation::RecordAssignedVars(BitVector* assigned_vars,
-                                     intptr_t fixed_parameter_count) {
+void Definition::RecordAssignedVars(BitVector* assigned_vars,
+                                    intptr_t fixed_parameter_count) {
   // Nothing to do for the base class.
 }
 
 
-void StoreLocalComp::RecordAssignedVars(BitVector* assigned_vars,
-                                        intptr_t fixed_parameter_count) {
+void StoreLocalInstr::RecordAssignedVars(BitVector* assigned_vars,
+                                         intptr_t fixed_parameter_count) {
   if (!local().is_captured()) {
     assigned_vars->Add(local().BitIndexIn(fixed_parameter_count));
   }
 }
 
 
 void Instruction::RecordAssignedVars(BitVector* assigned_vars,
                                      intptr_t fixed_parameter_count) {
   // Nothing to do for the base class.
 }
@@ skipping 22 matching lines @@
   }
   while (env_use_list_ != NULL) {
     Value* current = env_use_list_;
     env_use_list_ = env_use_list_->next_use();
     current->set_definition(other);
     current->AddToEnvUseList();
   }
 }
 
 
+void Definition::ReplaceWith(Definition* other,
+                             ForwardInstructionIterator* iterator) {
+  if ((iterator != NULL) && (other == iterator->Current())) {
+    iterator->ReplaceCurrentWith(other);
+  } else {
+    ReplaceUsesWith(other);
+    ASSERT(other->env() == NULL);
+    other->set_env(env());
+    set_env(NULL);
+    ASSERT(!other->HasSSATemp());
+    if (HasSSATemp()) other->set_ssa_temp_index(ssa_temp_index());
+
+    other->set_previous(previous());
+    previous()->set_next(other);
+    set_previous(NULL);
+
+    other->set_next(next());
+    next()->set_previous(other);
+    set_next(NULL);
+  }
+}
+
+
 bool Definition::SetPropagatedCid(intptr_t cid) {
   if (cid == kIllegalCid) {
     return false;
   }
   if (propagated_cid_ == kIllegalCid) {
     // First setting, nothing has changed.
     propagated_cid_ = cid;
     return false;
   }
   bool has_changed = (propagated_cid_ != cid);
   propagated_cid_ = cid;
   return has_changed;
 }
 
-RawAbstractType* BindInstr::CompileType() const {
-  ASSERT(!HasPropagatedType());
-  // The compile type may be requested when building the flow graph, i.e. before
-  // type propagation has occurred.
-  return computation()->CompileType();
-}
 
-
-intptr_t BindInstr::GetPropagatedCid() {
+intptr_t Definition::GetPropagatedCid() {
   if (has_propagated_cid()) return propagated_cid();
-  intptr_t cid = computation()->ResultCid();
+  intptr_t cid = ResultCid();
   ASSERT(cid != kIllegalCid);
   SetPropagatedCid(cid);
   return cid;
 }
 
-void BindInstr::RecordAssignedVars(BitVector* assigned_vars,
-                                   intptr_t fixed_parameter_count) {
-  computation()->RecordAssignedVars(assigned_vars, fixed_parameter_count);
+
+intptr_t PhiInstr::GetPropagatedCid() {
+  return propagated_cid();
 }
 
 
+intptr_t ParameterInstr::GetPropagatedCid() {
+  return propagated_cid();
+}
+
+
 // ==== Postorder graph traversal.
 void GraphEntryInstr::DiscoverBlocks(
     BlockEntryInstr* current_block,
     GrowableArray<BlockEntryInstr*>* preorder,
     GrowableArray<BlockEntryInstr*>* postorder,
     GrowableArray<intptr_t>* parent,
     GrowableArray<BitVector*>* assigned_vars,
     intptr_t variable_count,
     intptr_t fixed_parameter_count) {
   // We only visit this block once, first of all blocks.
@@ skipping 219 matching lines @@
   return type.raw();
 }
 
 
 intptr_t Value::ResultCid() const {
   return definition()->GetPropagatedCid();
 }
 
 
 
-RawAbstractType* ConstantComp::CompileType() const {
+RawAbstractType* ConstantInstr::CompileType() const {
   if (value().IsNull()) {
     return Type::NullType();
   }
   if (value().IsInstance()) {
     return Instance::Cast(value()).GetType();
   } else {
     ASSERT(value().IsAbstractTypeArguments());
     return AbstractType::null();
   }
 }
 
 
-intptr_t ConstantComp::ResultCid() const {
+intptr_t ConstantInstr::ResultCid() const {
   if (value().IsNull()) {
     return kNullCid;
   }
   if (value().IsInstance()) {
     return Class::Handle(value().clazz()).id();
   } else {
     ASSERT(value().IsAbstractTypeArguments());
     return kDynamicCid;
   }
 }
 
 
-RawAbstractType* AssertAssignableComp::CompileType() const {
+RawAbstractType* AssertAssignableInstr::CompileType() const {
   const AbstractType& value_compile_type =
       AbstractType::Handle(value()->CompileType());
   if (!value_compile_type.IsNull() &&
       value_compile_type.IsMoreSpecificThan(dst_type(), NULL)) {
     return value_compile_type.raw();
   }
   return dst_type().raw();
 }
 
 
-RawAbstractType* AssertBooleanComp::CompileType() const {
+RawAbstractType* AssertBooleanInstr::CompileType() const {
   return Type::BoolType();
 }
 
 
-RawAbstractType* ArgumentDefinitionTestComp::CompileType() const {
+RawAbstractType* ArgumentDefinitionTestInstr::CompileType() const {
   return Type::BoolType();
 }
 
 
-RawAbstractType* CurrentContextComp::CompileType() const {
+RawAbstractType* CurrentContextInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* StoreContextComp::CompileType() const {
+RawAbstractType* StoreContextInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* ClosureCallComp::CompileType() const {
+RawAbstractType* ClosureCallInstr::CompileType() const {
   // Because of function subtyping rules, the declared return type of a closure
   // call cannot be relied upon for compile type analysis. For example, a
   // function returning Dynamic can be assigned to a closure variable declared
   // to return int and may actually return a double at run-time.
   return Type::DynamicType();
 }
 
 
-RawAbstractType* InstanceCallComp::CompileType() const {
+RawAbstractType* InstanceCallInstr::CompileType() const {
   // TODO(regis): Return a more specific type than Dynamic for recognized
   // combinations of receiver type and method name.
   return Type::DynamicType();
 }
 
 
-RawAbstractType* PolymorphicInstanceCallComp::CompileType() const {
+RawAbstractType* PolymorphicInstanceCallInstr::CompileType() const {
   return Type::DynamicType();
 }
 
 
-RawAbstractType* StaticCallComp::CompileType() const {
+RawAbstractType* StaticCallInstr::CompileType() const {
   if (FLAG_enable_type_checks) {
     return function().result_type();
   }
   return Type::DynamicType();
 }
 
 
-RawAbstractType* LoadLocalComp::CompileType() const {
+RawAbstractType* LoadLocalInstr::CompileType() const {
   if (FLAG_enable_type_checks) {
     return local().type().raw();
   }
   return Type::DynamicType();
 }
 
 
-RawAbstractType* StoreLocalComp::CompileType() const {
+RawAbstractType* StoreLocalInstr::CompileType() const {
   return value()->CompileType();
 }
 
 
-RawAbstractType* StrictCompareComp::CompileType() const {
+RawAbstractType* StrictCompareInstr::CompileType() const {
   return Type::BoolType();
 }
 
 
 // Only known == targets return a Boolean.
-RawAbstractType* EqualityCompareComp::CompileType() const {
+RawAbstractType* EqualityCompareInstr::CompileType() const {
   if ((receiver_class_id() == kSmiCid) ||
       (receiver_class_id() == kDoubleCid) ||
       (receiver_class_id() == kNumberCid)) {
     return Type::BoolType();
   }
   return Type::DynamicType();
 }
 
 
-intptr_t EqualityCompareComp::ResultCid() const {
+intptr_t EqualityCompareInstr::ResultCid() const {
   if ((receiver_class_id() == kSmiCid) ||
       (receiver_class_id() == kDoubleCid) ||
       (receiver_class_id() == kNumberCid)) {
     // Known/library equalities that are guaranteed to return Boolean.
     return kBoolCid;
   }
   return kDynamicCid;
 }
 
 
-RawAbstractType* RelationalOpComp::CompileType() const {
+RawAbstractType* RelationalOpInstr::CompileType() const {
   if ((operands_class_id() == kSmiCid) ||
       (operands_class_id() == kDoubleCid) ||
       (operands_class_id() == kNumberCid)) {
     // Known/library relational ops that are guaranteed to return Boolean.
     return Type::BoolType();
   }
   return Type::DynamicType();
 }
 
 
-intptr_t RelationalOpComp::ResultCid() const {
+intptr_t RelationalOpInstr::ResultCid() const {
   if ((operands_class_id() == kSmiCid) ||
       (operands_class_id() == kDoubleCid) ||
       (operands_class_id() == kNumberCid)) {
     // Known/library relational ops that are guaranteed to return Boolean.
     return kBoolCid;
   }
   return kDynamicCid;
 }
 
 
-RawAbstractType* NativeCallComp::CompileType() const {
+RawAbstractType* NativeCallInstr::CompileType() const {
   // The result type of the native function is identical to the result type of
   // the enclosing native Dart function. However, we prefer to check the type
   // of the value returned from the native call.
   return Type::DynamicType();
 }
 
 
-RawAbstractType* LoadIndexedComp::CompileType() const {
+RawAbstractType* LoadIndexedInstr::CompileType() const {
   return Type::DynamicType();
 }
 
 
-RawAbstractType* StoreIndexedComp::CompileType() const {
+RawAbstractType* StoreIndexedInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* LoadInstanceFieldComp::CompileType() const {
+RawAbstractType* LoadInstanceFieldInstr::CompileType() const {
   if (FLAG_enable_type_checks) {
     return field().type();
   }
   return Type::DynamicType();
 }
 
 
-RawAbstractType* StoreInstanceFieldComp::CompileType() const {
+RawAbstractType* StoreInstanceFieldInstr::CompileType() const {
   return value()->CompileType();
 }
 
 
-RawAbstractType* LoadStaticFieldComp::CompileType() const {
+RawAbstractType* LoadStaticFieldInstr::CompileType() const {
   if (FLAG_enable_type_checks) {
     return field().type();
   }
   return Type::DynamicType();
 }
 
 
-RawAbstractType* StoreStaticFieldComp::CompileType() const {
+RawAbstractType* StoreStaticFieldInstr::CompileType() const {
   return value()->CompileType();
 }
 
 
-RawAbstractType* BooleanNegateComp::CompileType() const {
+RawAbstractType* BooleanNegateInstr::CompileType() const {
   return Type::BoolType();
 }
 
 
-RawAbstractType* InstanceOfComp::CompileType() const {
+RawAbstractType* InstanceOfInstr::CompileType() const {
   return Type::BoolType();
 }
 
 
-RawAbstractType* CreateArrayComp::CompileType() const {
+RawAbstractType* CreateArrayInstr::CompileType() const {
   return type().raw();
 }
 
 
-RawAbstractType* CreateClosureComp::CompileType() const {
+RawAbstractType* CreateClosureInstr::CompileType() const {
   const Function& fun = function();
   const Class& signature_class = Class::Handle(fun.signature_class());
   return signature_class.SignatureType();
 }
 
 
-RawAbstractType* AllocateObjectComp::CompileType() const {
+RawAbstractType* AllocateObjectInstr::CompileType() const {
   // TODO(regis): Be more specific.
   return Type::DynamicType();
 }
 
 
-RawAbstractType* AllocateObjectWithBoundsCheckComp::CompileType() const {
+RawAbstractType* AllocateObjectWithBoundsCheckInstr::CompileType() const {
   // TODO(regis): Be more specific.
   return Type::DynamicType();
 }
 
 
-RawAbstractType* LoadVMFieldComp::CompileType() const {
+RawAbstractType* LoadVMFieldInstr::CompileType() const {
   // Type may be null if the field is a VM field, e.g. context parent.
   // Keep it as null for debug purposes and do not return Dynamic in production
   // mode, since misuse of the type would remain undetected.
   if (type().IsNull()) {
     return AbstractType::null();
   }
   if (FLAG_enable_type_checks) {
     return type().raw();
   }
   return Type::DynamicType();
 }
 
 
-RawAbstractType* StoreVMFieldComp::CompileType() const {
+RawAbstractType* StoreVMFieldInstr::CompileType() const {
   return value()->CompileType();
 }
 
 
-RawAbstractType* InstantiateTypeArgumentsComp::CompileType() const {
+RawAbstractType* InstantiateTypeArgumentsInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* ExtractConstructorTypeArgumentsComp::CompileType() const {
+RawAbstractType* ExtractConstructorTypeArgumentsInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* ExtractConstructorInstantiatorComp::CompileType() const {
+RawAbstractType* ExtractConstructorInstantiatorInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* AllocateContextComp::CompileType() const {
+RawAbstractType* AllocateContextInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* ChainContextComp::CompileType() const {
+RawAbstractType* ChainContextInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* CloneContextComp::CompileType() const {
+RawAbstractType* CloneContextInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* CatchEntryComp::CompileType() const {
+RawAbstractType* CatchEntryInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* CheckStackOverflowComp::CompileType() const {
+RawAbstractType* CheckStackOverflowInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* BinarySmiOpComp::CompileType() const {
+RawAbstractType* BinarySmiOpInstr::CompileType() const {
   return (op_kind() == Token::kSHL) ? Type::IntInterface() : Type::SmiType();
 }
 
 
-intptr_t BinarySmiOpComp::ResultCid() const {
+intptr_t BinarySmiOpInstr::ResultCid() const {
   return (op_kind() == Token::kSHL) ? kDynamicCid : kSmiCid;
 }
 
 
-bool BinarySmiOpComp::CanDeoptimize() const {
+bool BinarySmiOpInstr::CanDeoptimize() const {
   switch (op_kind()) {
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       return false;
     default:
       return true;
   }
 }
 
 
-RawAbstractType* BinaryMintOpComp::CompileType() const {
+RawAbstractType* BinaryMintOpInstr::CompileType() const {
   return Type::MintType();
 }
 
 
-intptr_t BinaryMintOpComp::ResultCid() const {
+intptr_t BinaryMintOpInstr::ResultCid() const {
   return kMintCid;
 }
 
 
-RawAbstractType* UnboxedDoubleBinaryOpComp::CompileType() const {
+RawAbstractType* UnboxedDoubleBinaryOpInstr::CompileType() const {
   return Type::Double();
 }
 
 
-RawAbstractType* UnboxDoubleComp::CompileType() const {
+RawAbstractType* UnboxDoubleInstr::CompileType() const {
   return Type::null();
 }
 
 
-intptr_t BoxDoubleComp::ResultCid() const {
+intptr_t BoxDoubleInstr::ResultCid() const {
   return kDoubleCid;
 }
 
 
-RawAbstractType* BoxDoubleComp::CompileType() const {
+RawAbstractType* BoxDoubleInstr::CompileType() const {
   return Type::Double();
 }
 
 
-RawAbstractType* UnarySmiOpComp::CompileType() const {
+RawAbstractType* UnarySmiOpInstr::CompileType() const {
   return Type::SmiType();
 }
 
 
-RawAbstractType* NumberNegateComp::CompileType() const {
+RawAbstractType* NumberNegateInstr::CompileType() const {
   // Implemented only for doubles.
   return Type::Double();
 }
 
 
-RawAbstractType* DoubleToDoubleComp::CompileType() const {
+RawAbstractType* DoubleToDoubleInstr::CompileType() const {
   return Type::Double();
 }
 
 
-RawAbstractType* SmiToDoubleComp::CompileType() const {
+RawAbstractType* SmiToDoubleInstr::CompileType() const {
   return Type::Double();
 }
 
 
-RawAbstractType* CheckClassComp::CompileType() const {
+RawAbstractType* CheckClassInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* CheckSmiComp::CompileType() const {
+RawAbstractType* CheckSmiInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* CheckArrayBoundComp::CompileType() const {
+RawAbstractType* CheckArrayBoundInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-RawAbstractType* CheckEitherNonSmiComp::CompileType() const {
+RawAbstractType* CheckEitherNonSmiInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
 // Optimizations that eliminate or simplify individual computations.
-Definition* Computation::TryReplace(BindInstr* instr) const {
-  return instr;
+Definition* Definition::Canonicalize() {
+  return this;
 }
 
 
-Definition* StrictCompareComp::TryReplace(BindInstr* instr) const {
-  if (!right()->BindsToConstant()) return instr;
+Definition* StrictCompareInstr::Canonicalize() {
+  if (!right()->BindsToConstant()) return this;
   const Object& right_constant = right()->BoundConstant();
   Definition* left_defn = left()->definition();
   // TODO(fschneider): Handle other cases: e === false and e !== true/false.
   // Handles e === true.
   if ((kind() == Token::kEQ_STRICT) &&
       (right_constant.raw() == Bool::True()) &&
       (left()->ResultCid() == kBoolCid)) {
     // Remove the constant from the graph.
-    BindInstr* right_defn = right()->definition()->AsBind();
-    if (right_defn != NULL) {
-      right_defn->RemoveFromGraph();
-    }
+    Definition* right_defn = right()->definition();
+    right_defn->RemoveFromGraph();
     // Return left subexpression as the replacement for this instruction.
     return left_defn;
   }
-  return instr;
+  return this;
 }
 
 
-Definition* CheckClassComp::TryReplace(BindInstr* instr) const {
+Definition* CheckClassInstr::Canonicalize() {
   const intptr_t v_cid = value()->ResultCid();
   const intptr_t num_checks = unary_checks().NumberOfChecks();
   if ((num_checks == 1) &&
       (v_cid == unary_checks().GetReceiverClassIdAt(0))) {
     // No checks needed.
     return NULL;
   }
-  return instr;
+  return this;
 }
 
 
-Definition* CheckSmiComp::TryReplace(BindInstr* instr) const {
-  return (value()->ResultCid() == kSmiCid) ?  NULL : instr;
+Definition* CheckSmiInstr::Canonicalize() {
+  return (value()->ResultCid() == kSmiCid) ?  NULL : this;
 }
 
 
-Definition* CheckEitherNonSmiComp::TryReplace(BindInstr* instr) const {
+Definition* CheckEitherNonSmiInstr::Canonicalize() {
   if ((left()->ResultCid() == kDoubleCid) ||
       (right()->ResultCid() == kDoubleCid)) {
     return NULL;  // Remove from the graph.
   }
-  return instr;
+  return this;
 }
 
 
 // Shared code generation methods (EmitNativeCode, MakeLocationSummary, and
 // PrepareEntry). Only assembly code that can be shared across all architectures
 // can be used. Machine specific register allocation and code generation
 // is located in intermediate_language_<arch>.cc
 
 #define __ compiler->assembler()->
 
@@ skipping 15 matching lines @@
   if (IsCatchEntry()) {
     compiler->AddExceptionHandler(catch_try_index(),
                                   compiler->assembler()->CodeSize());
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
+LocationSummary* GraphEntryInstr::MakeLocationSummary() const {
+  UNREACHABLE();
+  return NULL;
+}
+
+
+void GraphEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  UNREACHABLE();
+}
+
+
+LocationSummary* JoinEntryInstr::MakeLocationSummary() const {
+  UNREACHABLE();
+  return NULL;
+}
+
+
+void JoinEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  UNREACHABLE();
+}
+
+
+LocationSummary* TargetEntryInstr::MakeLocationSummary() const {
+  UNREACHABLE();
+  return NULL;
+}
+
+
+void TargetEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  UNREACHABLE();
+}
+
+
+LocationSummary* PhiInstr::MakeLocationSummary() const {
+  UNREACHABLE();
+  return NULL;
+}
+
+
+void PhiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  UNREACHABLE();
+}
+
+
+LocationSummary* ParameterInstr::MakeLocationSummary() const {
+  UNREACHABLE();
+  return NULL;
+}
+
+
+void ParameterInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  UNREACHABLE();
+}
+
+
+LocationSummary* ParallelMoveInstr::MakeLocationSummary() const {
+  return NULL;
+}
+
+
+void ParallelMoveInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  UNREACHABLE();
+}
+
+
 LocationSummary* ThrowInstr::MakeLocationSummary() const {
   return new LocationSummary(0, 0, LocationSummary::kCall);
 }
 
 
 
 void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->GenerateCallRuntime(token_pos(),
                                 kThrowRuntimeEntry,
                                 locs());
@@ skipping 60 matching lines @@
   } else {
     // If the next block is the true successor we negate comparison and fall
     // through to it.
     ASSERT(compiler->IsNextBlock(true_successor()));
     Condition false_condition = NegateCondition(true_condition);
     __ j(false_condition, compiler->GetBlockLabel(false_successor()));
   }
 }
 
 
-LocationSummary* CurrentContextComp::MakeLocationSummary() const {
+LocationSummary* CurrentContextInstr::MakeLocationSummary() const {
   return LocationSummary::Make(0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
-void CurrentContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CurrentContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ MoveRegister(locs()->out().reg(), CTX);
 }
 
 
-LocationSummary* StoreContextComp::MakeLocationSummary() const {
+LocationSummary* StoreContextInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RegisterLocation(CTX));
   return summary;
 }
 
 
-void StoreContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Nothing to do.  Context register were loaded by register allocator.
   ASSERT(locs()->in(0).reg() == CTX);
 }
 
 
-LocationSummary* StrictCompareComp::MakeLocationSummary() const {
+LocationSummary* StrictCompareInstr::MakeLocationSummary() const {
   return LocationSummary::Make(2,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
-void StrictCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StrictCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
 
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
   Condition true_condition = (kind() == Token::kEQ_STRICT) ? EQUAL : NOT_EQUAL;
   __ CompareRegisters(left, right);
 
   Register result = locs()->out().reg();
   Label load_true, done;
   __ j(true_condition, &load_true, Assembler::kNearJump);
   __ LoadObject(result, compiler->bool_false());
   __ jmp(&done, Assembler::kNearJump);
   __ Bind(&load_true);
   __ LoadObject(result, compiler->bool_true());
   __ Bind(&done);
 }
 
 
-void StrictCompareComp::EmitBranchCode(FlowGraphCompiler* compiler,
+void StrictCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                        BranchInstr* branch) {
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
   Condition true_condition = (kind() == Token::kEQ_STRICT) ? EQUAL : NOT_EQUAL;
   __ CompareRegisters(left, right);
   branch->EmitBranchOnCondition(compiler, true_condition);
 }
 
 
-void ClosureCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The arguments to the stub include the closure.  The arguments
   // descriptor describes the closure's arguments (and so does not include
   // the closure).
   Register temp_reg = locs()->temp(0).reg();
   int argument_count = ArgumentCount();
   const Array& arguments_descriptor =
       DartEntry::ArgumentsDescriptor(argument_count - 1,
                                          argument_names());
   __ LoadObject(temp_reg, arguments_descriptor);
   compiler->GenerateDartCall(deopt_id(),
                              token_pos(),
                              &StubCode::CallClosureFunctionLabel(),
                              PcDescriptors::kOther,
                              locs());
   __ Drop(argument_count);
 }
 
 
-LocationSummary* InstanceCallComp::MakeLocationSummary() const {
+LocationSummary* InstanceCallInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
-void InstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void InstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->AddCurrentDescriptor(PcDescriptors::kDeoptBefore,
                                  deopt_id(),
                                  token_pos());
   compiler->GenerateInstanceCall(deopt_id(),
                                  token_pos(),
                                  function_name(),
                                  ArgumentCount(),
                                  argument_names(),
                                  checked_argument_count(),
                                  locs());
 }
 
 
-LocationSummary* StaticCallComp::MakeLocationSummary() const {
+LocationSummary* StaticCallInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
-void StaticCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StaticCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label done;
   if (recognized() == MethodRecognizer::kMathSqrt) {
     compiler->GenerateInlinedMathSqrt(&done);
     // Falls through to static call when operand type is not double or smi.
   }
   compiler->GenerateStaticCall(deopt_id(),
                                token_pos(),
                                function(),
                                ArgumentCount(),
                                argument_names(),
                                locs());
   __ Bind(&done);
 }
 
 
-void AssertAssignableComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void AssertAssignableInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (!is_eliminated()) {
     compiler->GenerateAssertAssignable(token_pos(),
                                        dst_type(),
                                        dst_name(),
                                        locs());
   }
   ASSERT(locs()->in(0).reg() == locs()->out().reg());
 }
 
 
-LocationSummary* BooleanNegateComp::MakeLocationSummary() const {
+LocationSummary* BooleanNegateInstr::MakeLocationSummary() const {
   return LocationSummary::Make(1,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
-void BooleanNegateComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   Label done;
   __ LoadObject(result, compiler->bool_true());
   __ CompareRegisters(result, value);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
   __ LoadObject(result, compiler->bool_false());
   __ Bind(&done);
 }
 
 
-LocationSummary* ChainContextComp::MakeLocationSummary() const {
+LocationSummary* ChainContextInstr::MakeLocationSummary() const {
   return LocationSummary::Make(1,
                                Location::NoLocation(),
                                LocationSummary::kNoCall);
 }
 
 
-void ChainContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void ChainContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
 
   // Chain the new context in context_value to its parent in CTX.
   __ StoreIntoObject(context_value,
                      FieldAddress(context_value, Context::parent_offset()),
                      CTX);
   // Set new context as current context.
   __ MoveRegister(CTX, context_value);
 }
 
 
-LocationSummary* StoreVMFieldComp::MakeLocationSummary() const {
+LocationSummary* StoreVMFieldInstr::MakeLocationSummary() const {
   return LocationSummary::Make(2,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
-void StoreVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreVMFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value_reg = locs()->in(0).reg();
   Register dest_reg = locs()->in(1).reg();
   ASSERT(value_reg == locs()->out().reg());
 
   if (value()->NeedsStoreBuffer()) {
     __ StoreIntoObject(dest_reg, FieldAddress(dest_reg, offset_in_bytes()),
                        value_reg);
   } else {
     __ StoreIntoObjectNoBarrier(
         dest_reg, FieldAddress(dest_reg, offset_in_bytes()), value_reg);
   }
 }
 
 
-LocationSummary* AllocateObjectComp::MakeLocationSummary() const {
+LocationSummary* AllocateObjectInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
-void AllocateObjectComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Class& cls = Class::ZoneHandle(constructor().Owner());
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
   const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 
-LocationSummary* CreateClosureComp::MakeLocationSummary() const {
+LocationSummary* CreateClosureInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
-void CreateClosureComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CreateClosureInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Function& closure_function = function();
   const Code& stub = Code::Handle(
       StubCode::GetAllocationStubForClosure(closure_function));
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
@@ skipping 44 matching lines @@
     value->set_use_index(i);
     value->AddToEnvUseList();
   }
   instr->set_env(copy);
 }
 
 
 #undef __
 
 }  // namespace dart