Implemented missing instructions in ia32, more sharing, removed bailouts, enable optimiziations on …

runtime/vm/intermediate_language_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 12 matching lines @@
 
 // Generic summary for call instructions that have all arguments pushed
 // on the stack and return the result in a fixed register EAX.
 LocationSummary* Computation::MakeCallSummary() {
   LocationSummary* result = new LocationSummary(0, 0);
   result->set_out(Location::RegisterLocation(EAX));
   return result;
 }
 
 
-void BindInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BindInstr::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   computation()->EmitNativeCode(compiler);
   __ pushl(locs()->out().reg());
 }
 
 
 LocationSummary* ReturnInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RegisterLocation(EAX));
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
-void ReturnInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void ReturnInstr::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register result = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   ASSERT(result == EAX);
   if (!compiler->is_optimizing()) {
     // Count only in unoptimized code.
     // TODO(srdjan): Replace the counting code with a type feedback
     // collection and counting stub.
     const Function& function =
           Function::ZoneHandle(compiler->parsed_function().function().raw());
     __ LoadObject(temp, function);
@@ skipping 45 matching lines @@
   result->set_temp(0, Location::RegisterLocation(EDX));  // Arg. descriptor.
   return result;
 }
 
 
 LocationSummary* LoadLocalComp::MakeLocationSummary() const {
   return LocationSummary::Make(0, Location::RequiresRegister());
 }
 
 
-void LoadLocalComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void LoadLocalComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register result = locs()->out().reg();
   __ movl(result, Address(EBP, local().index() * kWordSize));
 }
 
 
 LocationSummary* StoreLocalComp::MakeLocationSummary() const {
   return LocationSummary::Make(1, Location::SameAsFirstInput());
 }
 
 
-void StoreLocalComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreLocalComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
   ASSERT(result == value);  // Assert that register assignment is correct.
   __ movl(Address(EBP, local().index() * kWordSize), value);
 }
 
 
 LocationSummary* ConstantVal::MakeLocationSummary() const {
   return LocationSummary::Make(0, Location::RequiresRegister());
 }
 
 
-void ConstantVal::EmitNativeCode(FlowGraphCompiler* compiler) {
+void ConstantVal::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register result = locs()->out().reg();
   if (value().IsSmi()) {
     int32_t imm = reinterpret_cast<int32_t>(value().raw());
     __ movl(result, Immediate(imm));
   } else {
     __ LoadObject(result, value());
   }
 }
 
 
 LocationSummary* AssertAssignableComp::MakeLocationSummary() const {
   LocationSummary* summary = new LocationSummary(3, 0);
   summary->set_in(0, Location::RegisterLocation(EAX));  // Value.
   summary->set_in(1, Location::RegisterLocation(ECX));  // Instantiator.
   summary->set_in(2, Location::RegisterLocation(EDX));  // Type arguments.
   summary->set_out(Location::RegisterLocation(EAX));
   return summary;
 }
 
 
-void AssertBooleanComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void AssertBooleanComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register obj = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   // 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, Bool::ZoneHandle(Bool::True()));
   __ j(EQUAL, &done, Assembler::kNearJump);
   __ CompareObject(obj, Bool::ZoneHandle(Bool::False()));
   __ j(EQUAL, &done, Assembler::kNearJump);
@@ skipping 14 matching lines @@
 
 LocationSummary* EqualityCompareComp::MakeLocationSummary() const {
   LocationSummary* locs = new LocationSummary(2, 0);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_in(1, Location::RequiresRegister());
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
-void EqualityCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void EqualityCompareComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   Register result = locs()->out().reg();
   ASSERT(locs()->out().reg() == EAX);
 
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label done, load_true, non_null_compare;
@@ skipping 30 matching lines @@
 LocationSummary* NativeCallComp::MakeLocationSummary() const {
   LocationSummary* locs = new LocationSummary(0, 3);
   locs->set_temp(0, Location::RegisterLocation(EAX));
   locs->set_temp(1, Location::RegisterLocation(ECX));
   locs->set_temp(2, Location::RegisterLocation(EDX));
   locs->set_out(Location::RequiresRegister());
   return locs;
 }
 
 
-void NativeCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void NativeCallComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   ASSERT(locs()->temp(0).reg() == EAX);
   ASSERT(locs()->temp(1).reg() == ECX);
   ASSERT(locs()->temp(2).reg() == EDX);
   Register result = locs()->out().reg();
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   // Pass a pointer to the first argument in EAX.
   if (!has_optional_parameters()) {
     __ leal(EAX, Address(EBP, (1 + argument_count()) * kWordSize));
   } else {
     __ leal(EAX,
             Address(EBP, ParsedFunction::kFirstLocalSlotIndex * kWordSize));
   }
   __ movl(ECX, Immediate(reinterpret_cast<uword>(native_c_function())));
   __ movl(EDX, Immediate(argument_count()));
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &StubCode::CallNativeCFunctionLabel(),
                          PcDescriptors::kOther);
   __ popl(result);
 }
 
 
 LocationSummary* StoreIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   return LocationSummary::Make(kNumInputs, Location::NoLocation());
 }
 
 
-void StoreIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreIndexedComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register value = locs()->in(2).reg();
 
   const String& function_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
 
   __ pushl(receiver);
   __ pushl(index);
   __ pushl(value);
   const intptr_t kNumArguments = 3;
   const intptr_t kNumArgsChecked = 1;  // Type-feedback.
   compiler->GenerateInstanceCall(cid(),
                                  token_index(),
                                  try_index(),
                                  function_name,
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No optional arguments.
                                  kNumArgsChecked);
 }
 
 
 LocationSummary* InstanceSetterComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   return LocationSummary::Make(kNumInputs, Location::RequiresRegister());
-  return NULL;
 }
 
 
-void InstanceSetterComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void InstanceSetterComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register receiver = locs()->in(0).reg();
   Register value = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   // Preserve the value (second argument) under the arguments as the result
   // of the computation, then call the setter.
   const String& function_name =
       String::ZoneHandle(Field::SetterSymbol(field_name()));
 
   // Insert a copy of the second (last) argument under the arguments.
   // TODO(fschneider): Avoid preserving the value if the result is not used.
   __ pushl(value);
   __ pushl(receiver);
   __ pushl(value);
   const intptr_t kArgumentCount = 2;
   const intptr_t kCheckedArgumentCount = 1;
   compiler->GenerateInstanceCall(cid(),
                                  token_index(),
                                  try_index(),
                                  function_name,
                                  kArgumentCount,
                                  Array::ZoneHandle(),
                                  kCheckedArgumentCount);
   __ popl(result);
 }
 
 
 LocationSummary* StaticSetterComp::MakeLocationSummary() const {
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  return LocationSummary::Make(kNumInputs, Location::RequiresRegister());
 }
 
 
-void StaticSetterComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+void StaticSetterComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
+  Register value = locs()->in(0).reg();
+  Register result = locs()->out().reg();
+
+  // Preserve the argument as the result of the computation,
+  // then call the setter.
+
+  // Duplicate the argument.
+  // TODO(fschneider): Avoid preserving the value if the result is not used.
+  __ pushl(value);
+  __ pushl(value);
+  compiler->GenerateStaticCall(cid(),
+                               token_index(),
+                               try_index(),
+                               setter_function(),
+                               1,
+                               Array::ZoneHandle());
+  __ popl(result);
 }
 
 
 LocationSummary* LoadInstanceFieldComp::MakeLocationSummary() const {
-  return NULL;
+  // 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());
 }
 
 
-void LoadInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+void LoadInstanceFieldComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
+  Register instance = locs()->in(0).reg();
+  Register result = locs()->out().reg();
+
+  __ movl(result, FieldAddress(instance, field().Offset()));
 }
 
 
 LocationSummary* LoadStaticFieldComp::MakeLocationSummary() const {
   return LocationSummary::Make(0, Location::RequiresRegister());
 }
 
 
-void LoadStaticFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void LoadStaticFieldComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register result = locs()->out().reg();
   __ LoadObject(result, field());
   __ movl(result, FieldAddress(result, Field::value_offset()));
 }
 
 
 LocationSummary* InstanceOfComp::MakeLocationSummary() const {
   LocationSummary* summary = new LocationSummary(3, 0);
   summary->set_in(0, Location::RegisterLocation(EAX));
   summary->set_in(1, Location::RegisterLocation(ECX));
   summary->set_in(2, Location::RegisterLocation(EDX));
   summary->set_out(Location::RegisterLocation(EAX));
   return summary;
 }
 
 
-void InstanceOfComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void InstanceOfComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   ASSERT(locs()->in(0).reg() == EAX);  // Value.
   ASSERT(locs()->in(1).reg() == ECX);  // Instantiator.
   ASSERT(locs()->in(2).reg() == EDX);  // Instantiator type arguments.
 
   compiler->GenerateInstanceOf(cid(),
                                token_index(),
                                try_index(),
                                type(),
                                negate_result());
   ASSERT(locs()->out().reg() == EAX);
 }
 
 
 LocationSummary* CreateArrayComp::MakeLocationSummary() const {
   // TODO(regis): The elements of the array could be considered as arguments to
   // CreateArrayComp, thereby making CreateArrayComp a call.
   // For VerifyCallComputation to work, CreateArrayComp would need an
   // ArgumentCount getter and an ArgumentAt getter.
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RegisterLocation(ECX));
   locs->set_temp(0, Location::RegisterLocation(EDX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
-void CreateArrayComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CreateArrayComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register temp_reg = locs()->temp(0).reg();
   Register result_reg = locs()->out().reg();
   ASSERT(temp_reg == EDX);
   ASSERT(locs()->in(0).reg() == ECX);
   // 1. Allocate the array.  EDX = length, ECX = element type.
   __ movl(EDX,  Immediate(Smi::RawValue(ElementCount())));
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &StubCode::AllocateArrayLabel(),
                          PcDescriptors::kOther);
   ASSERT(result_reg == EAX);
   // Pop the element values from the stack into the array.
   __ leal(temp_reg, FieldAddress(result_reg, Array::data_offset()));
   for (int i = ElementCount() - 1; i >= 0; --i) {
     ASSERT(ElementAt(i)->IsUse());
     __ popl(Address(temp_reg, i * kWordSize));
   }
 }
 
 
 LocationSummary*
 AllocateObjectWithBoundsCheckComp::MakeLocationSummary() const {
   return LocationSummary::Make(2, Location::RequiresRegister());
 }
 
 
 void AllocateObjectWithBoundsCheckComp::EmitNativeCode(
-    FlowGraphCompiler* compiler) {
+    FlowGraphCompilerShared* 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();
 
   __ PushObject(Object::ZoneHandle());
   __ pushl(Immediate(Smi::RawValue(token_index())));
   __ PushObject(cls);
   __ pushl(type_arguments);
   __ pushl(instantiator_type_arguments);
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kAllocateObjectWithBoundsCheckRuntimeEntry);
   // Pop instantiator type arguments, type arguments, class, and
   // source location.
   __ Drop(4);
   __ popl(result);  // Pop new instance.
 }
 
 
 LocationSummary* LoadVMFieldComp::MakeLocationSummary() const {
   return LocationSummary::Make(1, Location::RequiresRegister());
 }
 
 
-void LoadVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void LoadVMFieldComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register obj = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ movl(result, FieldAddress(obj, offset_in_bytes()));
 }
 
 
 LocationSummary* InstantiateTypeArgumentsComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
 void InstantiateTypeArgumentsComp::EmitNativeCode(
-    FlowGraphCompiler* compiler) {
+    FlowGraphCompilerShared* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
   Register temp = locs()->temp(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 39 matching lines @@
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void ExtractConstructorTypeArgumentsComp::EmitNativeCode(
-    FlowGraphCompiler* compiler) {
+    FlowGraphCompilerShared* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
   ASSERT(instantiator_reg == result_reg);
   Register temp_reg = locs()->temp(0).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 36 matching lines @@
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void ExtractConstructorInstantiatorComp::EmitNativeCode(
-    FlowGraphCompiler* compiler) {
+    FlowGraphCompilerShared* compiler) {
   ASSERT(instantiator()->IsUse());
   Register instantiator_reg = locs()->in(0).reg();
   ASSERT(locs()->out().reg() == instantiator_reg);
   Register temp_reg = locs()->temp(0).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;
@@ skipping 43 matching lines @@
 LocationSummary* AllocateContextComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_temp(0, Location::RegisterLocation(EDX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
-void AllocateContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void AllocateContextComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   ASSERT(locs()->temp(0).reg() == EDX);
   ASSERT(locs()->out().reg() == EAX);
 
   __ movl(EDX, Immediate(num_context_variables()));
   const ExternalLabel label("alloc_context",
                             StubCode::AllocateContextEntryPoint());
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &label,
                          PcDescriptors::kOther);
 }
 
 
 LocationSummary* CloneContextComp::MakeLocationSummary() const {
   return LocationSummary::Make(1, Location::RequiresRegister());
 }
 
 
-void CloneContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CloneContextComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register context_value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushl(context_value);
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kCloneContextRuntimeEntry);
   __ popl(result);  // Remove argument.
   __ popl(result);  // Get result (cloned context).
 }
 
 
 LocationSummary* CatchEntryComp::MakeLocationSummary() const {
-  return NULL;
+  return LocationSummary::Make(0, Location::NoLocation());
 }
 
 
-void CatchEntryComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+// Restore stack and initialize the two exception variables:
+// exception and stack trace variables.
+void CatchEntryComp::EmitNativeCode(FlowGraphCompilerShared* 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;
+  __ leal(ESP, Address(EBP, offset_size));
+
+  ASSERT(!exception_var().is_captured());
+  ASSERT(!stacktrace_var().is_captured());
+  __ movl(Address(EBP, exception_var().index() * kWordSize),
+          kExceptionObjectReg);
+  __ movl(Address(EBP, stacktrace_var().index() * kWordSize),
+          kStackTraceObjectReg);
 }
 
 
 LocationSummary* BinaryOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_in(1, Location::RequiresRegister());
   summary->set_out(Location::SameAsFirstInput());
   return summary;
 }
 
 
-void BinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BinaryOpComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   // TODO(srdjan): Remove this code once BinaryOpComp has been implemeneted
   // for all intended operations.
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   __ pushl(left);
   __ pushl(right);
   InstanceCallComp* instance_call_comp = instance_call();
   instance_call_comp->EmitNativeCode(compiler);
   if (locs()->out().reg() != EAX) {
     __ movl(locs()->out().reg(), EAX);
   }
 }
 
 
 LocationSummary* UnarySmiOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_out(Location::SameAsFirstInput());
   return summary;
 }
 
 
-void UnarySmiOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void UnarySmiOpComp::EmitNativeCode(FlowGraphCompilerShared* 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);
   Class& test_class = Class::Handle();
   Function& target = Function::Handle();
   ic_data.GetOneClassCheckAt(0, &test_class, &target);
 
   Register value = locs()->in(0).reg();
@@ skipping 30 matching lines @@
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;  // Needed for doubles.
   LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_out(Location::SameAsFirstInput());
   summary->set_temp(0, Location::RequiresRegister());
   return summary;
 }
 
 
-void NumberNegateComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void NumberNegateComp::EmitNativeCode(FlowGraphCompilerShared* 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);
   Class& test_class = Class::Handle();
   Function& target = Function::Handle();
   ic_data.GetOneClassCheckAt(0, &test_class, &target);
 
@@ skipping 34 matching lines @@
     UNREACHABLE();
   }
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64