Fix vm code base so that it can be built for --arch=simarm (no snapshot yet).

runtime/vm/intermediate_language_x64.cc

-// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2013, 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/dart_entry.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 {
@@ skipping 246 matching lines @@
 
 
 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_in(0, Location::RequiresFpuRegister());
+    locs->set_in(1, Location::RequiresFpuRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
   if (receiver_class_id() == kSmiCid) {
     const intptr_t kNumTemps = 0;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RegisterOrConstant(left()));
     // Only one input can be a constant operand. The case of two constant
     // operands should be handled by constant propagation.
@@ skipping 42 matching lines @@
                                        const ICData& original_ic_data) {
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeoptBefore,
                                    deopt_id,
                                    token_pos);
   }
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 2;
 
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label check_identity;
   __ cmpq(Address(RSP, 0 * kWordSize), raw_null);
   __ j(EQUAL, &check_identity);
   __ cmpq(Address(RSP, 1 * kWordSize), raw_null);
   __ j(EQUAL, &check_identity);
 
   ICData& equality_ic_data = ICData::ZoneHandle(original_ic_data.raw());
   if (compiler->is_optimizing() && FLAG_propagate_ic_data) {
     ASSERT(!original_ic_data.IsNull());
@@ skipping 166 matching lines @@
                                    BranchInstr* branch,
                                    intptr_t deopt_id) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
   Register temp = locs.temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id, kDeoptEquality);
   __ testq(left, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   // 'left' is not Smi.
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label identity_compare;
   __ cmpq(right, raw_null);
   __ j(EQUAL, &identity_compare);
   __ cmpq(left, raw_null);
   __ j(EQUAL, &identity_compare);
 
   __ LoadClassId(temp, left);
   const intptr_t len = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
@@ skipping 30 matching lines @@
                                        LocationSummary* locs,
                                        Token::Kind kind,
                                        BranchInstr* branch,
                                        const ICData& ic_data,
                                        intptr_t deopt_id,
                                        intptr_t token_pos) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
   Register left = locs->in(0).reg();
   Register right = locs->in(1).reg();
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label done, identity_compare, non_null_compare;
   __ cmpq(right, raw_null);
   __ j(EQUAL, &identity_compare, Assembler::kNearJump);
   __ cmpq(left, raw_null);
   __ j(NOT_EQUAL, &non_null_compare, Assembler::kNearJump);
   // Comparison with NULL is "===".
   __ Bind(&identity_compare);
   __ cmpq(left, right);
   Condition cond = TokenKindToSmiCondition(kind);
@@ skipping 64 matching lines @@
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 static void EmitDoubleComparisonOp(FlowGraphCompiler* compiler,
                                    const LocationSummary& locs,
                                    Token::Kind kind,
                                    BranchInstr* branch) {
-  XmmRegister left = locs.in(0).xmm_reg();
-  XmmRegister right = locs.in(1).xmm_reg();
+  XmmRegister left = locs.in(0).fpu_reg();
+  XmmRegister right = locs.in(1).fpu_reg();
 
   Condition true_condition = TokenKindToDoubleCondition(kind);
   if (branch != NULL) {
     compiler->EmitDoubleCompareBranch(
         true_condition, left, right, branch);
   } else {
     compiler->EmitDoubleCompareBool(
         true_condition, left, right, locs.out().reg());
   }
 }
@@ skipping 81 matching lines @@
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (operands_class_id() == kDoubleCid) {
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-    summary->set_in(0, Location::RequiresXmmRegister());
-    summary->set_in(1, Location::RequiresXmmRegister());
+    summary->set_in(0, Location::RequiresFpuRegister());
+    summary->set_in(1, Location::RequiresFpuRegister());
     summary->set_out(Location::RequiresRegister());
     return summary;
   } else if (operands_class_id() == kSmiCid) {
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RegisterOrConstant(left()));
     // Only one input can be a constant operand. The case of two constant
     // operands should be handled by constant propagation.
     summary->set_in(1, summary->in(0).IsConstant()
                            ? Location::RequiresRegister()
@@ skipping 229 matching lines @@
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   // The smi index is either untagged and tagged again at the end of the
   // operation (element size == 1), or it is left smi tagged (for all element
   // sizes > 1).
   locs->set_in(1, CanBeImmediateIndex(index(), class_id())
                     ? Location::RegisterOrSmiConstant(index())
                     : Location::RequiresRegister());
   if (representation() == kUnboxedDouble) {
-    locs->set_out(Location::RequiresXmmRegister());
+    locs->set_out(Location::RequiresFpuRegister());
   } else {
     locs->set_out(Location::RequiresRegister());
   }
   return locs;
 }
 
 
 void LoadIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register array = locs()->in(0).reg();
   Location index = locs()->in(1);
@@ skipping 20 matching lines @@
     return;
   }
 
   FieldAddress element_address = index.IsRegister() ?
       FlowGraphCompiler::ElementAddressForRegIndex(
           class_id(), array, index.reg()) :
       FlowGraphCompiler::ElementAddressForIntIndex(
           class_id(), array, Smi::Cast(index.constant()).Value());
 
   if (representation() == kUnboxedDouble) {
-    XmmRegister result = locs()->out().xmm_reg();
+    XmmRegister result = locs()->out().fpu_reg();
     if (class_id() == kFloat32ArrayCid) {
       // Load single precision float.
       __ movss(result, element_address);
       // Promote to double.
-      __ cvtss2sd(result, locs()->out().xmm_reg());
+      __ cvtss2sd(result, locs()->out().fpu_reg());
     } else {
       ASSERT(class_id() == kFloat64ArrayCid);
       __ movsd(result, element_address);
     }
     return;
   }
 
   Register result = locs()->out().reg();
   switch (class_id()) {
     case kInt8ArrayCid:
@@ skipping 53 matching lines @@
       // RBX, RCX, RDX) instead of using a fixed register.
       locs->set_in(2, Location::FixedRegisterOrSmiConstant(value(), RAX));
       break;
     case kInt16ArrayCid:
     case kUint16ArrayCid:
       // Writable register because the value must be untagged before storing.
       locs->set_in(2, Location::WritableRegister());
       break;
     case kFloat32ArrayCid:
       // Need temp register for float-to-double conversion.
-      locs->AddTemp(Location::RequiresXmmRegister());
+      locs->AddTemp(Location::RequiresFpuRegister());
       // Fall through.
     case kFloat64ArrayCid:
       // TODO(srdjan): Support Float64 constants.
-      locs->set_in(2, Location::RequiresXmmRegister());
+      locs->set_in(2, Location::RequiresFpuRegister());
       break;
     default:
       UNREACHABLE();
       return NULL;
   }
   return locs;
 }
 
 
 void StoreIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 74 matching lines @@
     }
     case kInt16ArrayCid:
     case kUint16ArrayCid: {
         Register value = locs()->in(2).reg();
         __ SmiUntag(value);
         __ movw(element_address, value);
         break;
       }
     case kFloat32ArrayCid:
       // Convert to single precision.
-      __ cvtsd2ss(locs()->temp(0).xmm_reg(), locs()->in(2).xmm_reg());
+      __ cvtsd2ss(locs()->temp(0).fpu_reg(), locs()->in(2).fpu_reg());
       // Store.
-      __ movss(element_address, locs()->temp(0).xmm_reg());
+      __ movss(element_address, locs()->temp(0).fpu_reg());
       break;
     case kFloat64ArrayCid:
-      __ movsd(element_address, locs()->in(2).xmm_reg());
+      __ movsd(element_address, locs()->in(2).fpu_reg());
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 LocationSummary* StoreInstanceFieldInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t num_temps = 0;
@@ skipping 184 matching lines @@
   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();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
-    const Immediate raw_null =
+    const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ cmpq(instantiator_reg, raw_null);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
   // Instantiate non-null type arguments.
   if (type_arguments().IsUninstantiatedIdentity()) {
     // Check if the instantiator type argument vector is a TypeArguments of a
     // matching length and, if so, use it as the instantiated type_arguments.
     // No need to check the instantiator ('instantiator_reg') for null here,
     // because a null instantiator will have the wrong class (Null instead of
@@ skipping 40 matching lines @@
   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;
   const intptr_t len = type_arguments().Length();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
-    const Immediate raw_null =
+    const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ cmpq(instantiator_reg, raw_null);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
   // Instantiate non-null type arguments.
   if (type_arguments().IsUninstantiatedIdentity()) {
     // Check if the instantiator type argument vector is a TypeArguments of a
     // matching length and, if so, use it as the instantiated type_arguments.
     // No need to check instantiator_reg for null here, because a null
     // instantiator will have the wrong class (Null instead of TypeArguments).
     Label type_arguments_uninstantiated;
     __ CompareClassId(instantiator_reg, kTypeArgumentsCid);
     __ j(NOT_EQUAL, &type_arguments_uninstantiated, Assembler::kNearJump);
-    Immediate arguments_length =
+    const Immediate& arguments_length =
         Immediate(Smi::RawValue(type_arguments().Length()));
     __ cmpq(FieldAddress(instantiator_reg, TypeArguments::length_offset()),
         arguments_length);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     __ Bind(&type_arguments_uninstantiated);
   }
   // 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.
@@ skipping 19 matching lines @@
   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();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
-    const Immediate raw_null =
+    const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     Label instantiator_not_null;
     __ cmpq(instantiator_reg, raw_null);
     __ j(NOT_EQUAL, &instantiator_not_null, Assembler::kNearJump);
     // Null was used in VisitExtractConstructorTypeArguments as the
     // instantiated type arguments, no proper instantiator needed.
     __ movq(instantiator_reg,
             Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
     __ jmp(&done);
     __ Bind(&instantiator_not_null);
   }
   // Instantiate non-null type arguments.
   if (type_arguments().IsUninstantiatedIdentity()) {
     // TODO(regis): The following emitted code is duplicated in
     // VisitExtractConstructorTypeArguments above. The reason is that the code
     // is split between two computations, so that each one produces a
     // single value, rather than producing a pair of values.
     // If this becomes an issue, we should expose these tests at the IL level.
 
     // Check if the instantiator type argument vector is a TypeArguments of a
     // matching length and, if so, use it as the instantiated type_arguments.
     // No need to check the instantiator (RAX) for null here, because a null
     // instantiator will have the wrong class (Null instead of TypeArguments).
     __ CompareClassId(instantiator_reg, kTypeArgumentsCid);
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
-    Immediate arguments_length =
+    const Immediate& arguments_length =
         Immediate(Smi::RawValue(type_arguments().Length()));
     __ cmpq(FieldAddress(instantiator_reg, TypeArguments::length_offset()),
         arguments_length);
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     // 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);
@@ skipping 439 matching lines @@
 }
 
 
 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_in(0, Location::RequiresFpuRegister());
   summary->set_out(Location::RequiresRegister());
   return summary;
 }
 
 
 class BoxDoubleSlowPath : public SlowPathCode {
  public:
   explicit BoxDoubleSlowPath(BoxDoubleInstr* instruction)
       : instruction_(instruction) { }
 
@@ skipping 22 matching lines @@
  private:
   BoxDoubleInstr* instruction_;
 };
 
 
 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();
+  XmmRegister value = locs()->in(0).fpu_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* UnboxDoubleInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = CanDeoptimize() ? 1 : 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   if (CanDeoptimize()) summary->set_temp(0, Location::RequiresRegister());
-  summary->set_out(Location::RequiresXmmRegister());
+  summary->set_out(Location::RequiresFpuRegister());
   return summary;
 }
 
 
 void UnboxDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->ResultCid();
   const Register value = locs()->in(0).reg();
-  const XmmRegister result = locs()->out().xmm_reg();
+  const XmmRegister result = locs()->out().fpu_reg();
 
   if (value_cid == kDoubleCid) {
     __ movsd(result, FieldAddress(value, Double::value_offset()));
   } else if (value_cid == kSmiCid) {
     __ SmiUntag(value);  // Untag input before conversion.
     __ cvtsi2sd(result, value);
     __ SmiTag(value);  // Restore input register.
   } else {
     Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptBinaryDoubleOp);
-    compiler->LoadDoubleOrSmiToXmm(result,
+    compiler->LoadDoubleOrSmiToFpu(result,
                                    value,
                                    locs()->temp(0).reg(),
                                    deopt);
   }
 }
 
 
 LocationSummary* BinaryDoubleOpInstr::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_in(0, Location::RequiresFpuRegister());
+  summary->set_in(1, Location::RequiresFpuRegister());
   summary->set_out(Location::SameAsFirstInput());
   return summary;
 }
 
 
 void BinaryDoubleOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  XmmRegister left = locs()->in(0).xmm_reg();
-  XmmRegister right = locs()->in(1).xmm_reg();
+  XmmRegister left = locs()->in(0).fpu_reg();
+  XmmRegister right = locs()->in(1).fpu_reg();
 
-  ASSERT(locs()->out().xmm_reg() == left);
+  ASSERT(locs()->out().fpu_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* MathSqrtInstr::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::RequiresXmmRegister());
-  summary->set_out(Location::RequiresXmmRegister());
+  summary->set_in(0, Location::RequiresFpuRegister());
+  summary->set_out(Location::RequiresFpuRegister());
   return summary;
 }
 
 
 void MathSqrtInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ sqrtsd(locs()->out().xmm_reg(), locs()->in(0).xmm_reg());
+  __ sqrtsd(locs()->out().fpu_reg(), locs()->in(0).fpu_reg());
 }
 
 
 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());
@@ skipping 104 matching lines @@
                                locs());
   __ Bind(&done);
 }
 
 
 LocationSummary* DoubleToSmiInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* result = new LocationSummary(
       kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  result->set_in(0, Location::RequiresXmmRegister());
+  result->set_in(0, Location::RequiresFpuRegister());
   result->set_out(Location:: Location::RequiresRegister());
   result->set_temp(0, Location::RequiresRegister());
   return result;
 }
 
 
 void DoubleToSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptDoubleToSmi);
   Register result = locs()->out().reg();
-  XmmRegister value = locs()->in(0).xmm_reg();
+  XmmRegister value = locs()->in(0).fpu_reg();
   Register temp = locs()->temp(0).reg();
 
   __ cvttsd2siq(result, value);
   // Overflow is signalled with minint.
   Label do_call, done;
   // Check for overflow and that it fits into Smi.
   __ movq(temp, result);
   __ shlq(temp, Immediate(1));
   __ j(OVERFLOW, deopt);
   __ SmiTag(result);
 }
 
 
 LocationSummary* DoubleToDoubleInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps =
       (recognized_kind() == MethodRecognizer::kDoubleRound) ? 1 : 0;
   LocationSummary* result =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  result->set_in(0, Location::RequiresXmmRegister());
-  result->set_out(Location::RequiresXmmRegister());
+  result->set_in(0, Location::RequiresFpuRegister());
+  result->set_out(Location::RequiresFpuRegister());
   if (recognized_kind() == MethodRecognizer::kDoubleRound) {
-    result->set_temp(0, Location::RequiresXmmRegister());
+    result->set_temp(0, Location::RequiresFpuRegister());
   }
   return result;
 }
 
 
 void DoubleToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  XmmRegister value = locs()->in(0).xmm_reg();
-  XmmRegister result = locs()->out().xmm_reg();
+  XmmRegister value = locs()->in(0).fpu_reg();
+  XmmRegister result = locs()->out().fpu_reg();
   if (recognized_kind() == MethodRecognizer::kDoubleTruncate) {
     __ roundsd(result, value,  Assembler::kRoundToZero);
   } else {
-    XmmRegister temp = locs()->temp(0).xmm_reg();
+    XmmRegister temp = locs()->temp(0).fpu_reg();
     __ DoubleRound(result, value, temp);
   }
 }
 
 
 LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
@@ skipping 218 matching lines @@
 LocationSummary* ShiftMintOpInstr::MakeLocationSummary() const {
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
+
+LocationSummary* ThrowInstr::MakeLocationSummary() const {
+  return new LocationSummary(0, 0, LocationSummary::kCall);
+}
+
+
+void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  compiler->GenerateCallRuntime(token_pos(),
+                                kThrowRuntimeEntry,
+                                locs());
+  __ int3();
+}
+
+
+LocationSummary* ReThrowInstr::MakeLocationSummary() const {
+  return new LocationSummary(0, 0, LocationSummary::kCall);
+}
+
+
+void ReThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  compiler->GenerateCallRuntime(token_pos(),
+                                kReThrowRuntimeEntry,
+                                locs());
+  __ int3();
+}
+
+
+LocationSummary* GotoInstr::MakeLocationSummary() const {
+  return new LocationSummary(0, 0, LocationSummary::kNoCall);
+}
+
+
+void GotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  // Add deoptimization descriptor for deoptimizing instructions
+  // that may be inserted before this instruction.
+  if (!compiler->is_optimizing()) {
+    compiler->AddCurrentDescriptor(PcDescriptors::kDeoptBefore,
+                                   GetDeoptId(),
+                                   0);  // No token position.
+  }
+
+  if (HasParallelMove()) {
+    compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
+  }
+
+  // We can fall through if the successor is the next block in the list.
+  // Otherwise, we need a jump.
+  if (!compiler->IsNextBlock(successor())) {
+    __ jmp(compiler->GetBlockLabel(successor()));
+  }
+}
+
+
+static Condition NegateCondition(Condition condition) {
+  switch (condition) {
+    case EQUAL:         return NOT_EQUAL;
+    case NOT_EQUAL:     return EQUAL;
+    case LESS:          return GREATER_EQUAL;
+    case LESS_EQUAL:    return GREATER;
+    case GREATER:       return LESS_EQUAL;
+    case GREATER_EQUAL: return LESS;
+    case BELOW:         return ABOVE_EQUAL;
+    case BELOW_EQUAL:   return ABOVE;
+    case ABOVE:         return BELOW_EQUAL;
+    case ABOVE_EQUAL:   return BELOW;
+    default:
+      OS::Print("Error %d\n", condition);
+      UNIMPLEMENTED();
+      return EQUAL;
+  }
+}
+
+
+void ControlInstruction::EmitBranchOnValue(FlowGraphCompiler* compiler,
+                                           bool value) {
+  if (value && compiler->IsNextBlock(false_successor())) {
+    __ jmp(compiler->GetBlockLabel(true_successor()));
+  } else if (!value && compiler->IsNextBlock(true_successor())) {
+    __ jmp(compiler->GetBlockLabel(false_successor()));
+  }
+}
+
+
+void ControlInstruction::EmitBranchOnCondition(FlowGraphCompiler* compiler,
+                                               Condition true_condition) {
+  if (compiler->IsNextBlock(false_successor())) {
+    // If the next block is the false successor we will fall through to it.
+    __ j(true_condition, compiler->GetBlockLabel(true_successor()));
+  } else {
+    // If the next block is the true successor we negate comparison and fall
+    // through to it.
+    ASSERT(compiler->IsNextBlock(true_successor()));
+    Condition false_condition = NegateCondition(true_condition);
+    __ j(false_condition, compiler->GetBlockLabel(false_successor()));
+  }
+}
+
+
+LocationSummary* CurrentContextInstr::MakeLocationSummary() const {
+  return LocationSummary::Make(0,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
+}
+
+
+void CurrentContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  __ MoveRegister(locs()->out().reg(), CTX);
+}
+
+
+LocationSummary* StrictCompareInstr::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::RegisterOrConstant(left()));
+  locs->set_in(1, Location::RegisterOrConstant(right()));
+  locs->set_out(Location::RequiresRegister());
+  return locs;
+}
+
+
+// Special code for numbers (compare values instead of references.)
+void StrictCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
+  Location left = locs()->in(0);
+  Location right = locs()->in(1);
+  if (left.IsConstant() && right.IsConstant()) {
+    // TODO(vegorov): should be eliminated earlier by constant propagation.
+    const bool result = (kind() == Token::kEQ_STRICT) ?
+        left.constant().raw() == right.constant().raw() :
+        left.constant().raw() != right.constant().raw();
+    __ LoadObject(locs()->out().reg(), result ? Bool::True() : Bool::False());
+    return;
+  }
+  if (left.IsConstant()) {
+    compiler->EmitEqualityRegConstCompare(right.reg(),
+                                          left.constant(),
+                                          needs_number_check());
+  } else if (right.IsConstant()) {
+    compiler->EmitEqualityRegConstCompare(left.reg(),
+                                          right.constant(),
+                                          needs_number_check());
+  } else {
+    compiler->EmitEqualityRegRegCompare(left.reg(),
+                                       right.reg(),
+                                       needs_number_check());
+  }
+
+  Register result = locs()->out().reg();
+  Label load_true, done;
+  Condition true_condition = (kind() == Token::kEQ_STRICT) ? EQUAL : NOT_EQUAL;
+  __ j(true_condition, &load_true, Assembler::kNearJump);
+  __ LoadObject(result, Bool::False());
+  __ jmp(&done, Assembler::kNearJump);
+  __ Bind(&load_true);
+  __ LoadObject(result, Bool::True());
+  __ Bind(&done);
+}
+
+
+void StrictCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
+                                        BranchInstr* branch) {
+  ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
+  Location left = locs()->in(0);
+  Location right = locs()->in(1);
+  if (left.IsConstant() && right.IsConstant()) {
+    // TODO(vegorov): should be eliminated earlier by constant propagation.
+    const bool result = (kind() == Token::kEQ_STRICT) ?
+        left.constant().raw() == right.constant().raw() :
+        left.constant().raw() != right.constant().raw();
+    branch->EmitBranchOnValue(compiler, result);
+    return;
+  }
+  if (left.IsConstant()) {
+    compiler->EmitEqualityRegConstCompare(right.reg(),
+                                          left.constant(),
+                                          needs_number_check());
+  } else if (right.IsConstant()) {
+    compiler->EmitEqualityRegConstCompare(left.reg(),
+                                          right.constant(),
+                                          needs_number_check());
+  } else {
+    compiler->EmitEqualityRegRegCompare(left.reg(),
+                                        right.reg(),
+                                        needs_number_check());
+  }
+
+  Condition true_condition = (kind() == Token::kEQ_STRICT) ? EQUAL : NOT_EQUAL;
+  branch->EmitBranchOnCondition(compiler, true_condition);
+}
+
+
+void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  // The arguments to the stub include the closure, as does the arguments
+  // descriptor.
+  Register temp_reg = locs()->temp(0).reg();
+  int argument_count = ArgumentCount();
+  const Array& arguments_descriptor =
+      Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,
+                                                 argument_names()));
+  __ LoadObject(temp_reg, arguments_descriptor);
+  compiler->GenerateDartCall(deopt_id(),
+                             token_pos(),
+                             &StubCode::CallClosureFunctionLabel(),
+                             PcDescriptors::kOther,
+                             locs());
+  __ Drop(argument_count);
+}
+
+
+LocationSummary* BooleanNegateInstr::MakeLocationSummary() const {
+  return LocationSummary::Make(1,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
+}
+
+
+void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register value = locs()->in(0).reg();
+  Register result = locs()->out().reg();
+
+  Label done;
+  __ LoadObject(result, Bool::True());
+  __ CompareRegisters(result, value);
+  __ j(NOT_EQUAL, &done, Assembler::kNearJump);
+  __ LoadObject(result, Bool::False());
+  __ Bind(&done);
+}
+
+
+LocationSummary* ChainContextInstr::MakeLocationSummary() const {
+  return LocationSummary::Make(1,
+                               Location::NoLocation(),
+                               LocationSummary::kNoCall);
+}
+
+
+void ChainContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register context_value = locs()->in(0).reg();
+
+  // Chain the new context in context_value to its parent in CTX.
+  __ StoreIntoObject(context_value,
+                     FieldAddress(context_value, Context::parent_offset()),
+                     CTX);
+  // Set new context as current context.
+  __ MoveRegister(CTX, context_value);
+}
+
+
+LocationSummary* StoreVMFieldInstr::MakeLocationSummary() const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  locs->set_in(0, value()->NeedsStoreBuffer() ? Location::WritableRegister()
+                                              : Location::RequiresRegister());
+  locs->set_in(1, Location::RequiresRegister());
+  return locs;
+}
+
+
+void StoreVMFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register value_reg = locs()->in(0).reg();
+  Register dest_reg = locs()->in(1).reg();
+
+  if (value()->NeedsStoreBuffer()) {
+    __ StoreIntoObject(dest_reg, FieldAddress(dest_reg, offset_in_bytes()),
+                       value_reg);
+  } else {
+    __ StoreIntoObjectNoBarrier(
+        dest_reg, FieldAddress(dest_reg, offset_in_bytes()), value_reg);
+  }
+}
+
+
+LocationSummary* AllocateObjectInstr::MakeLocationSummary() const {
+  return MakeCallSummary();
+}
+
+
+void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  const Class& cls = Class::ZoneHandle(constructor().Owner());
+  const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
+  const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
+  compiler->GenerateCall(token_pos(),
+                         &label,
+                         PcDescriptors::kOther,
+                         locs());
+  __ Drop(ArgumentCount());  // Discard arguments.
+}
+
+
+LocationSummary* CreateClosureInstr::MakeLocationSummary() const {
+  return MakeCallSummary();
+}
+
+
+void CreateClosureInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  const Function& closure_function = function();
+  ASSERT(!closure_function.IsImplicitStaticClosureFunction());
+  const Code& stub = Code::Handle(
+      StubCode::GetAllocationStubForClosure(closure_function));
+  const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
+  compiler->GenerateCall(token_pos(),
+                         &label,
+                         PcDescriptors::kOther,
+                         locs());
+  __ Drop(2);  // Discard type arguments and receiver.
+}
+
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64