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

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"
 
 #define __ compiler->assembler()->
 
 namespace dart {
 
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, trace_functions);
 
 
-void BindInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BindInstr::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   computation()->EmitNativeCode(compiler);
   __ pushq(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(RAX));
   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 == RAX);
   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 62 matching lines @@
   result->set_temp(0, Location::RegisterLocation(R10));  // 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();
   __ movq(result, Address(RBP, 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.
   __ movq(Address(RBP, 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()) {
     int64_t imm = reinterpret_cast<int64_t>(value().raw());
     __ movq(result, Immediate(imm));
   } else {
     __ LoadObject(result, value());
   }
 }
 
 
 LocationSummary* AssertAssignableComp::MakeLocationSummary() const {
   LocationSummary* summary = new LocationSummary(3, 0);
   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;
 }
 
 
-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(RAX));
   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() == RAX);
 
   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 31 matching lines @@
 LocationSummary* NativeCallComp::MakeLocationSummary() const {
   LocationSummary* locs = new LocationSummary(0, 3);
   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::RequiresRegister());
   return locs;
 }
 
 
-void NativeCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void NativeCallComp::EmitNativeCode(FlowGraphCompilerShared* 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.
   if (!has_optional_parameters()) {
     __ leaq(RAX, Address(RBP, (1 + argument_count()) * kWordSize));
@@ skipping 10 matching lines @@
   __ popq(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)));
 
   __ pushq(receiver);
   __ pushq(index);
   __ pushq(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.
@@ skipping 13 matching lines @@
   __ popq(result);
 }
 
 
 LocationSummary* StaticSetterComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(kNumInputs, Location::RequiresRegister());
 }
 
 
-void StaticSetterComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+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.
   __ pushq(value);
   __ pushq(value);
   compiler->GenerateStaticCall(cid(),
                                token_index(),
                                try_index(),
                                setter_function(),
                                1,
                                Array::ZoneHandle());
   __ popq(result);
 }
 
 
 LocationSummary* LoadInstanceFieldComp::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());
 }
 
 
-void LoadInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void LoadInstanceFieldComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register instance = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ movq(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());
   __ movq(result, FieldAddress(result, Field::value_offset()));
 }
 
 
 LocationSummary* InstanceOfComp::MakeLocationSummary() const {
   LocationSummary* summary = new LocationSummary(3, 0);
   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 InstanceOfComp::EmitNativeCode(FlowGraphCompilerShared* 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(cid(),
                                token_index(),
                                try_index(),
                                type(),
                                negate_result());
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
 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(RBX));
   locs->set_temp(0, Location::RegisterLocation(R10));
   locs->set_out(Location::RegisterLocation(RAX));
   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();
 
   // 1. Allocate the array.  R10 = length, RBX = element type.
   ASSERT(temp_reg == R10);
   ASSERT(locs()->in(0).reg() == RBX);
   __ movq(temp_reg, Immediate(Smi::RawValue(ElementCount())));
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &StubCode::AllocateArrayLabel(),
                          PcDescriptors::kOther);
   ASSERT(result_reg == RAX);
   // 2. Initialize the array in result_reg with the element values.
   __ leaq(temp_reg, FieldAddress(result_reg, Array::data_offset()));
   for (int i = ElementCount() - 1; i >= 0; --i) {
     ASSERT(ElementAt(i)->IsUse());
     __ popq(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();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ pushq(Immediate(Smi::RawValue(token_index())));
   __ PushObject(cls);
   __ pushq(type_arguments);
   __ pushq(instantiator_type_arguments);
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kAllocateObjectWithBoundsCheckRuntimeEntry);
   // Pop instantiator type arguments, type arguments, class, and
   // source location.
   __ Drop(4);
   __ popq(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();
 
   __ movq(result, FieldAddress(obj, offset_in_bytes()));
 }
 
 
 LocationSummary* InstantiateTypeArgumentsComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
-void InstantiateTypeArgumentsComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void InstantiateTypeArgumentsComp::EmitNativeCode(
+    FlowGraphCompilerShared* 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;
   const intptr_t len = type_arguments().Length();
@@ skipping 39 matching lines @@
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   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);
 
   // 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.
   Label type_arguments_instantiated;
@@ skipping 34 matching lines @@
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   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);
 
   // 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 42 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(R10));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
-void AllocateContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void AllocateContextComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   ASSERT(locs()->temp(0).reg() == R10);
 
   __ movq(R10, 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.
   __ pushq(context_value);
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kCloneContextRuntimeEntry);
   __ popq(result);  // Remove argument.
   __ popq(result);  // Get result (cloned context).
 }
 
 
 LocationSummary* CatchEntryComp::MakeLocationSummary() const {
   return LocationSummary::Make(0, Location::NoLocation());
 }
 
 
 // Restore stack and initialize the two exception variables:
 // exception and stack trace variables.
-void CatchEntryComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+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;
   __ leaq(RSP, Address(RBP, offset_size));
 
   ASSERT(!exception_var().is_captured());
   ASSERT(!stacktrace_var().is_captured());
@@ skipping 40 matching lines @@
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
 }
 
 
 // TODO(srdjan): Implement variations.
-static bool TryEmitSmiBinaryOp(FlowGraphCompiler* compiler,
+static bool TryEmitSmiBinaryOp(FlowGraphCompilerShared* compiler,
                                BinaryOpComp* comp) {
   ASSERT((comp->ic_data() != NULL));
   const ICData& ic_data = *comp->ic_data();
   if (ic_data.IsNull()) return false;
   if (ic_data.num_args_tested() != 2) return false;
   if (ic_data.NumberOfChecks() != 1) return false;
   Function& target = Function::Handle();
   GrowableArray<const Class*> classes;
   ic_data.GetCheckAt(0, &classes, &target);
   const Class& smi_class =
@@ skipping 124 matching lines @@
       UNREACHABLE();
       return false;
     }
     default:
       UNREACHABLE();
       return false;
   }
   return true;
 }
 
-void BinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BinaryOpComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   if (TryEmitSmiBinaryOp(compiler, this)) {
     // Operation inlined.
     return;
   }
   // 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();
   __ pushq(left);
   __ pushq(right);
   InstanceCallComp* instance_call_comp = instance_call();
   instance_call_comp->EmitNativeCode(compiler);
   if (locs()->out().reg() != RAX) {
     __ movq(locs()->out().reg(), RAX);
   }
 }
 
 
 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 33 matching lines @@
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64