Remove classes Computation and BindInstr.

runtime/vm/intermediate_language_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 #define __ compiler->assembler()->
 
 namespace dart {
 
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, trace_functions);
 
 // Generic summary for call instructions that have all arguments pushed
 // on the stack and return the result in a fixed register RAX.
-LocationSummary* Computation::MakeCallSummary() {
+LocationSummary* Instruction::MakeCallSummary() {
   LocationSummary* result = new LocationSummary(0, 0, LocationSummary::kCall);
   result->set_out(Location::RegisterLocation(RAX));
   return result;
 }
 
 
-void BindInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  computation()->EmitNativeCode(compiler);
-  if (is_used() && !compiler->is_optimizing()) {
-    __ pushq(locs()->out().reg());
-  }
-}
-
-
 LocationSummary* ReturnInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
@@ skipping 68 matching lines @@
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
                                  deopt_id(),
                                  token_pos());
 }
 
 
-LocationSummary* ClosureCallComp::MakeLocationSummary() const {
+LocationSummary* ClosureCallInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* result =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   result->set_out(Location::RegisterLocation(RAX));
   result->set_temp(0, Location::RegisterLocation(R10));  // Arg. descriptor.
   return result;
 }
 
 
-LocationSummary* LoadLocalComp::MakeLocationSummary() const {
+LocationSummary* LoadLocalInstr::MakeLocationSummary() const {
   return LocationSummary::Make(0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
-void LoadLocalComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void LoadLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
   __ movq(result, Address(RBP, local().index() * kWordSize));
 }
 
 
-LocationSummary* StoreLocalComp::MakeLocationSummary() const {
+LocationSummary* StoreLocalInstr::MakeLocationSummary() const {
   return LocationSummary::Make(1,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
-void StoreLocalComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
   ASSERT(result == value);  // Assert that register assignment is correct.
   __ movq(Address(RBP, local().index() * kWordSize), value);
 }
 
 
-LocationSummary* ConstantComp::MakeLocationSummary() const {
+LocationSummary* ConstantInstr::MakeLocationSummary() const {
   return LocationSummary::Make(0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
-void ConstantComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  // Register allocator drops constant definitions that have no uses.
+void ConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  // The register allocator drops constant definitions that have no uses.
   if (!locs()->out().IsInvalid()) {
     Register result = locs()->out().reg();
     __ LoadObject(result, value());
   }
 }
 
 
-LocationSummary* AssertAssignableComp::MakeLocationSummary() const {
+LocationSummary* AssertAssignableInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(RAX));  // Value.
   summary->set_in(1, Location::RegisterLocation(RCX));  // Instantiator.
   summary->set_in(2, Location::RegisterLocation(RDX));  // Type arguments.
   summary->set_out(Location::RegisterLocation(RAX));
   return summary;
 }
 
 
-LocationSummary* AssertBooleanComp::MakeLocationSummary() const {
+LocationSummary* AssertBooleanInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
-void AssertBooleanComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void AssertBooleanInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register obj = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   if (!is_eliminated()) {
     // Check that the type of the value is allowed in conditional context.
     // Call the runtime if the object is not bool::true or bool::false.
     Label done;
     __ CompareObject(obj, compiler->bool_true());
     __ j(EQUAL, &done, Assembler::kNearJump);
     __ CompareObject(obj, compiler->bool_false());
     __ j(EQUAL, &done, Assembler::kNearJump);
 
     __ pushq(obj);  // Push the source object.
     compiler->GenerateCallRuntime(token_pos(),
                                   kConditionTypeErrorRuntimeEntry,
                                   locs());
     // We should never return here.
     __ int3();
     __ Bind(&done);
   }
   ASSERT(obj == result);
 }
 
 
-LocationSummary* ArgumentDefinitionTestComp::MakeLocationSummary() const {
+LocationSummary* ArgumentDefinitionTestInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
-void ArgumentDefinitionTestComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void ArgumentDefinitionTestInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register saved_args_desc = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ pushq(Immediate(Smi::RawValue(formal_parameter_index())));
   __ PushObject(formal_parameter_name());
   __ pushq(saved_args_desc);
   compiler->GenerateCallRuntime(token_pos(),
                                 kArgumentDefinitionTestRuntimeEntry,
@@ skipping 11 matching lines @@
     case Token::kGT: return GREATER;
     case Token::kLTE: return LESS_EQUAL;
     case Token::kGTE: return  GREATER_EQUAL;
     default:
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
-LocationSummary* EqualityCompareComp::MakeLocationSummary() const {
+LocationSummary* EqualityCompareInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const bool is_checked_strict_equal =
       HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
   if (receiver_class_id() == kDoubleCid) {
     const intptr_t kNumTemps =  0;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresXmmRegister());
     locs->set_in(1, Location::RequiresXmmRegister());
     locs->set_out(Location::RequiresRegister());
@@ skipping 332 matching lines @@
   if (branch != NULL) {
     compiler->EmitDoubleCompareBranch(
         true_condition, left, right, branch);
   } else {
     compiler->EmitDoubleCompareBool(
         true_condition, left, right, locs.out().reg());
   }
 }
 
 
-void EqualityCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void EqualityCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT((kind() == Token::kEQ) || (kind() == Token::kNE));
   BranchInstr* kNoBranch = NULL;
   if (receiver_class_id() == kSmiCid) {
     // Deoptimizes if both arguments not Smi.
     EmitSmiComparisonOp(compiler, *locs(), kind(), kNoBranch);
     return;
   }
   if (receiver_class_id() == kDoubleCid) {
     // Deoptimizes if both arguments are Smi, or if none is Double or Smi.
     EmitDoubleComparisonOp(compiler, *locs(), kind(), kNoBranch);
@@ skipping 17 matching lines @@
   __ pushq(right);
   EmitEqualityAsInstanceCall(compiler,
                              deopt_id(),
                              token_pos(),
                              kind(),
                              locs());
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
-void EqualityCompareComp::EmitBranchCode(FlowGraphCompiler* compiler,
-                                         BranchInstr* branch) {
+void EqualityCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
+                                          BranchInstr* branch) {
   ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
   if (receiver_class_id() == kSmiCid) {
     // Deoptimizes if both arguments not Smi.
     EmitSmiComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   if (receiver_class_id() == kDoubleCid) {
     // Deoptimizes if both arguments are Smi, or if none is Double or Smi.
     EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
@@ skipping 18 matching lines @@
                              deopt_id(),
                              token_pos(),
                              Token::kEQ,  // kNE reverse occurs at branch.
                              locs());
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
   __ CompareObject(RAX, compiler->bool_true());
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
-LocationSummary* RelationalOpComp::MakeLocationSummary() const {
+LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (operands_class_id() == kDoubleCid) {
     const intptr_t kNumTemps = 0;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresXmmRegister());
     summary->set_in(1, Location::RequiresXmmRegister());
     summary->set_out(Location::RequiresRegister());
     return summary;
   } else if (operands_class_id() == kSmiCid) {
@@ skipping 10 matching lines @@
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   // Pick arbitrary fixed input registers because this is a call.
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_in(1, Location::RegisterLocation(RCX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
-void RelationalOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void RelationalOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (operands_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL);
     return;
   }
   if (operands_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL);
     return;
   }
 
   // Push arguments for the call.
@@ skipping 36 matching lines @@
   compiler->GenerateInstanceCall(deopt_id(),
                                  token_pos(),
                                  function_name,
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No optional arguments.
                                  kNumArgsChecked,
                                  locs());
 }
 
 
-void RelationalOpComp::EmitBranchCode(FlowGraphCompiler* compiler,
-                                      BranchInstr* branch) {
+void RelationalOpInstr::EmitBranchCode(FlowGraphCompiler* compiler,
+                                       BranchInstr* branch) {
   if (operands_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   if (operands_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   EmitNativeCode(compiler);
   __ CompareObject(RAX, compiler->bool_true());
   branch->EmitBranchOnCondition(compiler, EQUAL);
 }
 
 
-LocationSummary* NativeCallComp::MakeLocationSummary() const {
+LocationSummary* NativeCallInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 3;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(RAX));
   locs->set_temp(1, Location::RegisterLocation(RBX));
   locs->set_temp(2, Location::RegisterLocation(R10));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
-void NativeCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void NativeCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == RAX);
   ASSERT(locs()->temp(1).reg() == RBX);
   ASSERT(locs()->temp(2).reg() == R10);
   Register result = locs()->out().reg();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   // Pass a pointer to the first argument in RAX.
   intptr_t arg_count = argument_count();
   if (is_native_instance_closure()) {
     arg_count += 1;
   }
   if (!has_optional_parameters() && !is_native_instance_closure()) {
     __ leaq(RAX, Address(RBP, (1 + arg_count) * kWordSize));
   } else {
     __ leaq(RAX,
             Address(RBP, ParsedFunction::kFirstLocalSlotIndex * kWordSize));
   }
   __ movq(RBX, Immediate(reinterpret_cast<uword>(native_c_function())));
   __ movq(R10, Immediate(arg_count));
   compiler->GenerateCall(token_pos(),
                          &StubCode::CallNativeCFunctionLabel(),
                          PcDescriptors::kOther,
                          locs());
   __ popq(result);
 }
 
 
-LocationSummary* LoadIndexedComp::MakeLocationSummary() const {
+LocationSummary* LoadIndexedInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (receiver_type() == kGrowableObjectArrayCid) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   } else  {
     ASSERT((receiver_type() == kArrayCid) ||
            (receiver_type() == kImmutableArrayCid));
     return LocationSummary::Make(kNumInputs,
                                  Location::RequiresRegister(),
                                  LocationSummary::kNoCall);
   }
 }
 
 
-void LoadIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void LoadIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   switch (receiver_type()) {
     case kArrayCid:
     case kImmutableArrayCid:
       // Note that index is Smi, i.e, times 4.
       ASSERT(kSmiTagShift == 1);
       __ movq(result, FieldAddress(receiver, index, TIMES_4, sizeof(RawArray)));
       break;
 
     case kGrowableObjectArrayCid: {
       Register temp = locs()->temp(0).reg();
       __ movq(temp, FieldAddress(receiver, GrowableObjectArray::data_offset()));
       // Note that index is Smi, i.e, times 4.
       ASSERT(kSmiTagShift == 1);
       __ movq(result, FieldAddress(temp, index, TIMES_4, sizeof(RawArray)));
       break;
     }
 
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
-LocationSummary* StoreIndexedComp::MakeLocationSummary() const {
+LocationSummary* StoreIndexedInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   if (receiver_type() == kGrowableObjectArrayCid) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_in(2, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     return locs;
   } else  {
     ASSERT(receiver_type() == kArrayCid);
     return LocationSummary::Make(kNumInputs,
                                  Location::NoLocation(),
                                  LocationSummary::kNoCall);
   }
 }
 
 
-void StoreIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register value = locs()->in(2).reg();
 
   switch (receiver_type()) {
     case kArrayCid:
     case kImmutableArrayCid:
       // Note that index is Smi, i.e, times 4.
       ASSERT(kSmiTagShift == 1);
       if (this->value()->NeedsStoreBuffer()) {
@@ skipping 24 matching lines @@
       break;
     }
 
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
-LocationSummary* LoadInstanceFieldComp::MakeLocationSummary() const {
+LocationSummary* LoadInstanceFieldInstr::MakeLocationSummary() const {
   // TODO(fschneider): For this instruction the input register may be
   // reused for the result (but is not required to) because the input
   // is not used after the result is defined.  We should consider adding
   // this information to the input policy.
   return LocationSummary::Make(1,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
-void LoadInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void LoadInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instance_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
   __ movq(result_reg, FieldAddress(instance_reg, field().Offset()));
 }
 
 
-LocationSummary* StoreInstanceFieldComp::MakeLocationSummary() const {
+LocationSummary* StoreInstanceFieldInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t num_temps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, num_temps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_in(1, Location::RequiresRegister());
   return summary;
 }
 
 
-void StoreInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instance_reg = locs()->in(0).reg();
   Register value_reg = locs()->in(1).reg();
   if (this->value()->NeedsStoreBuffer()) {
     __ StoreIntoObject(instance_reg,
         FieldAddress(instance_reg, field().Offset()), value_reg);
   } else {
     __ StoreIntoObjectNoBarrier(instance_reg,
         FieldAddress(instance_reg, field().Offset()), value_reg);
   }
 }
 
 
-LocationSummary* LoadStaticFieldComp::MakeLocationSummary() const {
+LocationSummary* LoadStaticFieldInstr::MakeLocationSummary() const {
   return LocationSummary::Make(0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
-void LoadStaticFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void LoadStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
   __ LoadObject(result, field());
   __ movq(result, FieldAddress(result, Field::value_offset()));
 }
 
 
-LocationSummary* StoreStaticFieldComp::MakeLocationSummary() const {
+LocationSummary* StoreStaticFieldInstr::MakeLocationSummary() const {
   LocationSummary* locs = new LocationSummary(1, 1, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
-void StoreStaticFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   ASSERT(locs()->out().reg() == value);
 
   __ LoadObject(temp, field());
   if (this->value()->NeedsStoreBuffer()) {
     __ StoreIntoObject(temp, FieldAddress(temp, Field::value_offset()), value);
   } else {
     __ StoreIntoObjectNoBarrier(
         temp, FieldAddress(temp, Field::value_offset()), value);
   }
 }
 
 
-LocationSummary* InstanceOfComp::MakeLocationSummary() const {
+LocationSummary* InstanceOfInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(RAX));
   summary->set_in(1, Location::RegisterLocation(RCX));
   summary->set_in(2, Location::RegisterLocation(RDX));
   summary->set_out(Location::RegisterLocation(RAX));
   return summary;
 }
 
 
-void InstanceOfComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void InstanceOfInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->in(0).reg() == RAX);  // Value.
   ASSERT(locs()->in(1).reg() == RCX);  // Instantiator.
   ASSERT(locs()->in(2).reg() == RDX);  // Instantiator type arguments.
 
   compiler->GenerateInstanceOf(token_pos(),
                                type(),
                                negate_result(),
                                locs());
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
-LocationSummary* CreateArrayComp::MakeLocationSummary() const {
+LocationSummary* CreateArrayInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RBX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
-void CreateArrayComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CreateArrayInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Allocate the array.  R10 = length, RBX = element type.
   ASSERT(locs()->in(0).reg() == RBX);
   __ movq(R10, Immediate(Smi::RawValue(ArgumentCount())));
   compiler->GenerateCall(token_pos(),
                          &StubCode::AllocateArrayLabel(),
                          PcDescriptors::kOther,
                          locs());
   ASSERT(locs()->out().reg() == RAX);
 
   // Pop the element values from the stack into the array.
   __ leaq(R10, FieldAddress(RAX, Array::data_offset()));
   for (int i = ArgumentCount() - 1; i >= 0; --i) {
     __ popq(Address(R10, i * kWordSize));
   }
 }
 
 
 LocationSummary*
-    AllocateObjectWithBoundsCheckComp::MakeLocationSummary() const {
+AllocateObjectWithBoundsCheckInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_in(1, Location::RegisterLocation(RCX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
-void AllocateObjectWithBoundsCheckComp::EmitNativeCode(
+void AllocateObjectWithBoundsCheckInstr::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   const Class& cls = Class::ZoneHandle(constructor().Owner());
   Register type_arguments = locs()->in(0).reg();
   Register instantiator_type_arguments = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ PushObject(cls);
   __ pushq(type_arguments);
   __ pushq(instantiator_type_arguments);
   compiler->GenerateCallRuntime(token_pos(),
                                 kAllocateObjectWithBoundsCheckRuntimeEntry,
                                 locs());
   // Pop instantiator type arguments, type arguments, and class.
   __ Drop(3);
   __ popq(result);  // Pop new instance.
 }
 
 
-LocationSummary* LoadVMFieldComp::MakeLocationSummary() const {
+LocationSummary* LoadVMFieldInstr::MakeLocationSummary() const {
   return LocationSummary::Make(1,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
-void LoadVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void LoadVMFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instance_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
 
   __ movq(result_reg, FieldAddress(instance_reg, offset_in_bytes()));
 }
 
 
-LocationSummary* InstantiateTypeArgumentsComp::MakeLocationSummary() const {
+LocationSummary* InstantiateTypeArgumentsInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
-void InstantiateTypeArgumentsComp::EmitNativeCode(
+void InstantiateTypeArgumentsInstr::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
 
   // 'instantiator_reg' is the instantiator AbstractTypeArguments object
   // (or null).
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of Dynamic, then use null as
   // the type arguments.
   Label type_arguments_instantiated;
@@ skipping 28 matching lines @@
                                 locs());
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ popq(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
   // 'result_reg': Instantiated type arguments.
 }
 
 
 LocationSummary*
-    ExtractConstructorTypeArgumentsComp::MakeLocationSummary() const {
+ExtractConstructorTypeArgumentsInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
-void ExtractConstructorTypeArgumentsComp::EmitNativeCode(
+void ExtractConstructorTypeArgumentsInstr::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
   ASSERT(instantiator_reg == result_reg);
 
   // instantiator_reg is the instantiator type argument vector, i.e. an
   // AbstractTypeArguments object (or null).
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of Dynamic, then use null as
   // the type arguments.
@@ skipping 24 matching lines @@
   // In the non-factory case, we rely on the allocation stub to
   // instantiate the type arguments.
   __ LoadObject(result_reg, type_arguments());
   // result_reg: uninstantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   // result_reg: uninstantiated or instantiated type arguments.
 }
 
 
 LocationSummary*
-    ExtractConstructorInstantiatorComp::MakeLocationSummary() const {
+ExtractConstructorInstantiatorInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
-void ExtractConstructorInstantiatorComp::EmitNativeCode(
+void ExtractConstructorInstantiatorInstr::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
   ASSERT(locs()->out().reg() == instantiator_reg);
 
   // instantiator_reg is the instantiator AbstractTypeArguments object
   // (or null).  If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of Dynamic, then use null as
   // the type arguments and do not pass the instantiator.
   Label done;
   const intptr_t len = type_arguments().Length();
@@ skipping 32 matching lines @@
     // The instantiator was used in VisitExtractConstructorTypeArguments as the
     // instantiated type arguments, no proper instantiator needed.
     __ movq(instantiator_reg,
             Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
   __ Bind(&done);
   // instantiator_reg: instantiator or kNoInstantiator.
 }
 
 
-LocationSummary* AllocateContextComp::MakeLocationSummary() const {
+LocationSummary* AllocateContextInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(R10));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
-void AllocateContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == R10);
   ASSERT(locs()->out().reg() == RAX);
 
   __ movq(R10, Immediate(num_context_variables()));
   const ExternalLabel label("alloc_context",
                             StubCode::AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
 }
 
 
-LocationSummary* CloneContextComp::MakeLocationSummary() const {
+LocationSummary* CloneContextInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
-void CloneContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushq(context_value);
   compiler->GenerateCallRuntime(token_pos(),
                                 kCloneContextRuntimeEntry,
                                 locs());
   __ popq(result);  // Remove argument.
   __ popq(result);  // Get result (cloned context).
 }
 
 
-LocationSummary* CatchEntryComp::MakeLocationSummary() const {
+LocationSummary* CatchEntryInstr::MakeLocationSummary() const {
   return LocationSummary::Make(0,
                                Location::NoLocation(),
                                LocationSummary::kNoCall);
 }
 
 
 // Restore stack and initialize the two exception variables:
 // exception and stack trace variables.
-void CatchEntryComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CatchEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Restore RSP from RBP as we are coming from a throw and the code for
   // popping arguments has not been run.
   const intptr_t locals_space_size = compiler->StackSize() * kWordSize;
   ASSERT(locals_space_size >= 0);
   const intptr_t offset_size =
       -locals_space_size + FlowGraphCompiler::kLocalsOffsetFromFP;
   __ leaq(RSP, Address(RBP, offset_size));
 
   ASSERT(!exception_var().is_captured());
   ASSERT(!stacktrace_var().is_captured());
   __ movq(Address(RBP, exception_var().index() * kWordSize),
           kExceptionObjectReg);
   __ movq(Address(RBP, stacktrace_var().index() * kWordSize),
           kStackTraceObjectReg);
 }
 
 
-LocationSummary* CheckStackOverflowComp::MakeLocationSummary() const {
+LocationSummary* CheckStackOverflowInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs,
                           kNumTemps,
                           LocationSummary::kCallOnSlowPath);
   summary->set_temp(0, Location::RequiresRegister());
   return summary;
 }
 
 
 class CheckStackOverflowSlowPath : public SlowPathCode {
  public:
-  explicit CheckStackOverflowSlowPath(CheckStackOverflowComp* computation)
-      : computation_(computation) { }
+  explicit CheckStackOverflowSlowPath(CheckStackOverflowInstr* instruction)
+      : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Bind(entry_label());
-    compiler->SaveLiveRegisters(computation_->locs());
-    compiler->GenerateCallRuntime(computation_->token_pos(),
+    compiler->SaveLiveRegisters(instruction_->locs());
+    compiler->GenerateCallRuntime(instruction_->token_pos(),
                                   kStackOverflowRuntimeEntry,
-                                  computation_->locs());
-    compiler->RestoreLiveRegisters(computation_->locs());
+                                  instruction_->locs());
+    compiler->RestoreLiveRegisters(instruction_->locs());
     __ jmp(exit_label());
   }
 
  private:
-  CheckStackOverflowComp* computation_;
+  CheckStackOverflowInstr* instruction_;
 };
 
 
-void CheckStackOverflowComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   CheckStackOverflowSlowPath* slow_path = new CheckStackOverflowSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   Register temp = locs()->temp(0).reg();
   // Generate stack overflow check.
   __ movq(temp, Immediate(Isolate::Current()->stack_limit_address()));
   __ cmpq(RSP, Address(temp, 0));
   __ j(BELOW_EQUAL, slow_path->entry_label());
   __ Bind(slow_path->exit_label());
 }
 
 
 static bool CanBeImmediate(const Object& constant) {
   return constant.IsSmi() &&
     Immediate(reinterpret_cast<int64_t>(constant.raw())).is_int32();
 }
 
-LocationSummary* BinarySmiOpComp::MakeLocationSummary() const {
+LocationSummary* BinarySmiOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
 
-  ConstantComp* right_constant = right()->definition()->AsConstant();
+  ConstantInstr* right_constant = right()->definition()->AsConstant();
   if ((right_constant != NULL) &&
       (op_kind() != Token::kTRUNCDIV) &&
       (op_kind() != Token::kSHL) &&
       (op_kind() != Token::kMUL) &&
       CanBeImmediate(right_constant->value())) {
     const intptr_t kNumTemps = 0;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::Constant(right_constant->value()));
@@ skipping 37 matching lines @@
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
     summary->set_out(Location::SameAsFirstInput());
     return summary;
   }
 }
 
 
-void BinarySmiOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = locs()->in(0).reg();
   Register result = locs()->out().reg();
   ASSERT(left == result);
   Label* deopt = NULL;
   switch (op_kind()) {
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       // Can't deoptimize. Arguments are already checked for smi.
       break;
@@ skipping 194 matching lines @@
       UNREACHABLE();
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
-LocationSummary* BinaryMintOpComp::MakeLocationSummary() const {
+LocationSummary* BinaryMintOpInstr::MakeLocationSummary() const {
   ASSERT(op_kind() == Token::kBIT_AND);
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(RAX));
   summary->set_in(1, Location::RegisterLocation(RCX));
   summary->set_out(Location::RegisterLocation(RAX));
   return summary;
 }
 
 
-void BinaryMintOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BinaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // TODO(regis): For now, we only support Token::kBIT_AND for a Mint or Smi
   // receiver and a Mint or Smi argument. We fall back to the run time call if
   // both receiver and argument are Mint or if one of them is Mint and the other
   // is a negative Smi.
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   Register result = locs()->out().reg();
   ASSERT(left == result);
   ASSERT(op_kind() == Token::kBIT_AND);
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
@@ skipping 68 matching lines @@
           instance_call()->ArgumentCount(),
           instance_call()->argument_names(),
           locs());
       ASSERT(result == RAX);
     }
   }
   __ Bind(&done);
 }
 
 
-LocationSummary* CheckEitherNonSmiComp::MakeLocationSummary() const {
+LocationSummary* CheckEitherNonSmiInstr::MakeLocationSummary() const {
   ASSERT((left()->ResultCid() != kDoubleCid) &&
          (right()->ResultCid() != kDoubleCid));
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary =
     new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_in(1, Location::RequiresRegister());
   summary->set_temp(0, Location::RequiresRegister());
   return summary;
 }
 
 
-void CheckEitherNonSmiComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Label* deopt = compiler->AddDeoptStub(instance_call_->deopt_id(),
-                                        kDeoptBinaryDoubleOp);
-
+void CheckEitherNonSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptBinaryDoubleOp);
   Register temp = locs()->temp(0).reg();
   __ movq(temp, locs()->in(0).reg());
   __ orq(temp, locs()->in(1).reg());
   __ testl(temp, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
 }
 
 
-LocationSummary* BoxDoubleComp::MakeLocationSummary() const {
+LocationSummary* BoxDoubleInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs,
                           kNumTemps,
                           LocationSummary::kCallOnSlowPath);
   summary->set_in(0, Location::RequiresXmmRegister());
   summary->set_out(Location::RequiresRegister());
   return summary;
 }
 
 
 class BoxDoubleSlowPath : public SlowPathCode {
  public:
-  explicit BoxDoubleSlowPath(BoxDoubleComp* computation)
-      : computation_(computation) { }
+  explicit BoxDoubleSlowPath(BoxDoubleInstr* instruction)
+      : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Bind(entry_label());
     const Class& double_class = compiler->double_class();
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(double_class));
     const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
 
-    LocationSummary* locs = computation_->locs();
+    LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out());
 
     compiler->SaveLiveRegisters(locs);
-    compiler->GenerateCall(computation_->token_pos(),
+    compiler->GenerateCall(instruction_->token_pos(),
                            &label,
                            PcDescriptors::kOther,
                            locs);
     if (RAX != locs->out().reg()) __ movq(locs->out().reg(), RAX);
     compiler->RestoreLiveRegisters(locs);
 
     __ jmp(exit_label());
   }
 
  private:
-  BoxDoubleComp* computation_;
+  BoxDoubleInstr* instruction_;
 };
 
 
-void BoxDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BoxDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   BoxDoubleSlowPath* slow_path = new BoxDoubleSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   Register out_reg = locs()->out().reg();
   XmmRegister value = locs()->in(0).xmm_reg();
 
   AssemblerMacros::TryAllocate(compiler->assembler(),
                                compiler->double_class(),
                                slow_path->entry_label(),
                                Assembler::kFarJump,
                                out_reg);
   __ Bind(slow_path->exit_label());
   __ movsd(FieldAddress(out_reg, Double::value_offset()), value);
 }
 
 
-LocationSummary* UnboxDoubleComp::MakeLocationSummary() const {
+LocationSummary* UnboxDoubleInstr::MakeLocationSummary() const {
   const intptr_t v_cid = value()->ResultCid();
 
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = (v_cid != kDoubleCid) ? 1 : 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   if (v_cid != kDoubleCid) summary->set_temp(0, Location::RequiresRegister());
   summary->set_out(Location::RequiresXmmRegister());
   return summary;
 }
 
 
-void UnboxDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void UnboxDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t v_cid = value()->ResultCid();
 
   const Register value = locs()->in(0).reg();
   const XmmRegister result = locs()->out().xmm_reg();
   if (v_cid != kDoubleCid) {
     Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptBinaryDoubleOp);
     compiler->LoadDoubleOrSmiToXmm(result,
                                    value,
                                    locs()->temp(0).reg(),
                                    deopt);
   } else {
     __ movsd(result, FieldAddress(value, Double::value_offset()));
   }
 }
 
 
-LocationSummary* UnboxedDoubleBinaryOpComp::MakeLocationSummary() const {
+LocationSummary* UnboxedDoubleBinaryOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresXmmRegister());
   summary->set_in(1, Location::RequiresXmmRegister());
   summary->set_out(Location::SameAsFirstInput());
   return summary;
 }
 
 
-void UnboxedDoubleBinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void UnboxedDoubleBinaryOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister left = locs()->in(0).xmm_reg();
   XmmRegister right = locs()->in(1).xmm_reg();
 
   ASSERT(locs()->out().xmm_reg() == left);
 
   switch (op_kind()) {
     case Token::kADD: __ addsd(left, right); break;
     case Token::kSUB: __ subsd(left, right); break;
     case Token::kMUL: __ mulsd(left, right); break;
     case Token::kDIV: __ divsd(left, right); break;
     default: UNREACHABLE();
   }
 }
 
 
-LocationSummary* UnarySmiOpComp::MakeLocationSummary() const {
+LocationSummary* UnarySmiOpInstr::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::RequiresRegister());
   summary->set_out(Location::SameAsFirstInput());
   return summary;
 }
 
 
-void UnarySmiOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void UnarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   ASSERT(value == locs()->out().reg());
   switch (op_kind()) {
     case Token::kNEGATE: {
       Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                             kDeoptUnaryOp);
       __ negq(value);
       __ j(OVERFLOW, deopt);
       break;
     }
     case Token::kBIT_NOT:
       __ notq(value);
       __ andq(value, Immediate(~kSmiTagMask));  // Remove inverted smi-tag.
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
-LocationSummary* NumberNegateComp::MakeLocationSummary() const {
+LocationSummary* NumberNegateInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;  // Needed for doubles.
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(RAX));
   summary->set_out(Location::RegisterLocation(RAX));
   summary->set_temp(0, Location::RegisterLocation(RCX));
   return summary;
 }
 
 
-void NumberNegateComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void NumberNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const ICData& ic_data = *instance_call()->ic_data();
   ASSERT(!ic_data.IsNull());
   ASSERT(ic_data.num_args_tested() == 1);
 
   // TODO(srdjan): Implement for more checks.
   ASSERT(ic_data.NumberOfChecks() == 1);
   intptr_t test_class_id;
   Function& target = Function::Handle();
   ic_data.GetOneClassCheckAt(0, &test_class_id, &target);
 
@@ skipping 25 matching lines @@
     __ movsd(XMM0, FieldAddress(temp, Double::value_offset()));
     __ DoubleNegate(XMM0);
     __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
   } else {
     UNREACHABLE();
   }
   ASSERT(ResultCid() == kDoubleCid);
 }
 
 
-LocationSummary* DoubleToDoubleComp::MakeLocationSummary() const {
+LocationSummary* DoubleToDoubleInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
-void DoubleToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void DoubleToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         kDeoptDoubleToDouble);
 
   __ testq(value, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);  // Deoptimize if Smi.
   __ CompareClassId(value, kDoubleCid);
   __ j(NOT_EQUAL, deopt);  // Deoptimize if not Double.
   ASSERT(value == result);
 }
 
 
-LocationSummary* SmiToDoubleComp::MakeLocationSummary() const {
+LocationSummary* SmiToDoubleInstr::MakeLocationSummary() const {
   return MakeCallSummary();  // Calls a stub to allocate result.
 }
 
 
-void SmiToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void SmiToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
 
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         kDeoptIntegerToDouble);
 
   const Class& double_class = compiler->double_class();
   const Code& stub =
     Code::Handle(StubCode::GetAllocationStubForClass(double_class));
   const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
 
@@ skipping 10 matching lines @@
 
   __ testq(value, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);  // Deoptimize if not Smi.
   __ SmiUntag(value);
   __ cvtsi2sd(XMM0, value);
   __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
   __ Drop(1);
 }
 
 
-LocationSummary* PolymorphicInstanceCallComp::MakeLocationSummary() const {
+LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
-void PolymorphicInstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         kDeoptPolymorphicInstanceCallTestFail);
   if (ic_data().NumberOfChecks() == 0) {
     __ jmp(deopt);
     return;
   }
   ASSERT(ic_data().num_args_tested() == 1);
   if (!with_checks()) {
     const Function& target = Function::ZoneHandle(ic_data().GetTargetAt(0));
     compiler->GenerateStaticCall(instance_call()->deopt_id(),
@@ skipping 18 matching lines @@
                             RDI,  // Class id register.
                             instance_call()->ArgumentCount(),
                             instance_call()->argument_names(),
                             deopt,
                             instance_call()->deopt_id(),
                             instance_call()->token_pos(),
                             locs());
 }
 
 
+LocationSummary* BranchInstr::MakeLocationSummary() const {
+  UNREACHABLE();
+  return NULL;
+}
+
+
 void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  computation()->EmitBranchCode(compiler, this);
+  comparison()->EmitBranchCode(compiler, this);
 }
 
 
-LocationSummary* CheckClassComp::MakeLocationSummary() const {
+LocationSummary* CheckClassInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_temp(0, Location::RequiresRegister());
   return summary;
 }
 
 
-void CheckClassComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         kDeoptCheckClass);
   ASSERT(unary_checks().GetReceiverClassIdAt(0) != kSmiCid);
   __ testq(value, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   __ LoadClassId(temp, value);
   Label is_ok;
   const intptr_t num_checks = unary_checks().NumberOfChecks();
   const bool use_near_jump = num_checks < 5;
   for (intptr_t i = 0; i < num_checks; i++) {
     __ cmpl(temp, Immediate(unary_checks().GetReceiverClassIdAt(i)));
     if (i == (num_checks - 1)) {
       __ j(NOT_EQUAL, deopt);
     } else {
       if (use_near_jump) {
         __ j(EQUAL, &is_ok, Assembler::kNearJump);
       } else {
         __ j(EQUAL, &is_ok);
       }
     }
   }
   __ Bind(&is_ok);
 }
 
 
-LocationSummary* CheckSmiComp::MakeLocationSummary() const {
+LocationSummary* CheckSmiInstr::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::RequiresRegister());
   return summary;
 }
 
 
-void CheckSmiComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CheckSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         kDeoptCheckSmi);
   __ testq(value, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 }
 
 
-LocationSummary* CheckArrayBoundComp::MakeLocationSummary() const {
+LocationSummary* CheckArrayBoundInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_in(1, Location::RegisterOrConstant(index()));
   return locs;
 }
 
 
-void CheckArrayBoundComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CheckArrayBoundInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register receiver = locs()->in(0).reg();
 
   const DeoptReasonId deopt_reason =
       (array_type() == kGrowableObjectArrayCid) ?
       kDeoptLoadIndexedGrowableArray : kDeoptLoadIndexedFixedArray;
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         deopt_reason);
   ASSERT(array_type() == kArrayCid ||
          array_type() == kImmutableArrayCid ||
          array_type() == kGrowableObjectArrayCid);
@@ skipping 14 matching lines @@
     __ j(ABOVE_EQUAL, deopt);
   }
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64