Use GPRs for mints

runtime/vm/intermediate_language_ia32.cc

 // 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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 235 matching lines @@
     default:
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 LocationSummary* EqualityCompareInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 2;
   if (operation_cid() == kMintCid) {
-    const intptr_t kNumTemps = 1;
+    const intptr_t kNumTemps = 0;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-    locs->set_in(0, Location::RequiresFpuRegister());
-    locs->set_in(1, Location::RequiresFpuRegister());
-    locs->set_temp(0, Location::RequiresRegister());
+    locs->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                   Location::RequiresRegister()));
+    locs->set_in(1, Location::Pair(Location::RequiresRegister(),
+                                   Location::RequiresRegister()));
     locs->set_out(0, Location::RequiresRegister());
     return locs;
   }
   if (operation_cid() == kDoubleCid) {
     const intptr_t kNumTemps = 0;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresFpuRegister());
     locs->set_in(1, Location::RequiresFpuRegister());
     locs->set_out(0, Location::RequiresRegister());
@@ skipping 113 matching lines @@
     __ cmpl(left.reg(), right.ToStackSlotAddress());
   } else {
     __ cmpl(left.reg(), right.reg());
   }
   return true_condition;
 }
 
 
 static void EmitJavascriptIntOverflowCheck(FlowGraphCompiler* compiler,
                                            Label* overflow,
-                                           XmmRegister result,
-                                           Register tmp) {
+                                           Register result_lo,
+                                           Register result_hi) {
   // Compare upper half.
   Label check_lower;
-  __ pextrd(tmp, result, Immediate(1));
-  __ cmpl(tmp, Immediate(0x00200000));
+  __ cmpl(result_hi, Immediate(0x00200000));
   __ j(GREATER, overflow);
   __ j(NOT_EQUAL, &check_lower);
 
-  __ pextrd(tmp, result, Immediate(0));
-  __ cmpl(tmp, Immediate(0));
+  __ cmpl(result_lo, Immediate(0));
   __ j(ABOVE, overflow);
 
   __ Bind(&check_lower);
-  __ pextrd(tmp, result, Immediate(1));
-  __ cmpl(tmp, Immediate(-0x00200000));
+  __ cmpl(result_hi, Immediate(-0x00200000));
   __ j(LESS, overflow);
   // Anything in the lower part would make the number bigger than the lower
   // bound, so we are done.
 }
 
 
 static Condition TokenKindToMintCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kNE: return NOT_EQUAL;
     case Token::kLT: return LESS;
     case Token::kGT: return GREATER;
     case Token::kLTE: return LESS_EQUAL;
     case Token::kGTE: return GREATER_EQUAL;
     default:
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 static Condition EmitUnboxedMintEqualityOp(FlowGraphCompiler* compiler,
                                            const LocationSummary& locs,
                                            Token::Kind kind,
                                            BranchLabels labels) {
   ASSERT(Token::IsEqualityOperator(kind));
-  XmmRegister left = locs.in(0).fpu_reg();
-  XmmRegister right = locs.in(1).fpu_reg();
-  Register temp = locs.temp(0).reg();
-  __ movaps(XMM0, left);
-  __ pcmpeqq(XMM0, right);
-  __ movd(temp, XMM0);
-
+  PairLocation* left_pair = locs.in(0).AsPairLocation();
+  Register left1 = left_pair->At(0).reg();
+  Register left2 = left_pair->At(1).reg();
+  PairLocation* right_pair = locs.in(1).AsPairLocation();
+  Register right1 = right_pair->At(0).reg();
+  Register right2 = right_pair->At(1).reg();
+  Label done;
+  // Compare lower.
+  __ cmpl(left1, right1);
+  __ j(NOT_EQUAL, &done);
+  // Lower is equal, compare upper.
+  __ cmpl(left2, right2);
+  __ Bind(&done);
   Condition true_condition = TokenKindToMintCondition(kind);
-  __ cmpl(temp, Immediate(-1));
   return true_condition;
 }
 
 
 static Condition EmitUnboxedMintComparisonOp(FlowGraphCompiler* compiler,
                                              const LocationSummary& locs,
                                              Token::Kind kind,
                                              BranchLabels labels) {
-  XmmRegister left = locs.in(0).fpu_reg();
-  XmmRegister right = locs.in(1).fpu_reg();
-  Register left_tmp = locs.temp(0).reg();
-  Register right_tmp = locs.temp(1).reg();
+  PairLocation* left_pair = locs.in(0).AsPairLocation();
+  Register left1 = left_pair->At(0).reg();
+  Register left2 = left_pair->At(1).reg();
+  PairLocation* right_pair = locs.in(1).AsPairLocation();
+  Register right1 = right_pair->At(0).reg();
+  Register right2 = right_pair->At(1).reg();
 
   Condition hi_cond = OVERFLOW, lo_cond = OVERFLOW;
   switch (kind) {
     case Token::kLT:
       hi_cond = LESS;
       lo_cond = BELOW;
       break;
     case Token::kGT:
       hi_cond = GREATER;
       lo_cond = ABOVE;
       break;
     case Token::kLTE:
       hi_cond = LESS;
       lo_cond = BELOW_EQUAL;
       break;
     case Token::kGTE:
       hi_cond = GREATER;
       lo_cond = ABOVE_EQUAL;
       break;
     default:
       break;
   }
   ASSERT(hi_cond != OVERFLOW && lo_cond != OVERFLOW);
   Label is_true, is_false;
   // Compare upper halves first.
-  __ pextrd(left_tmp, left, Immediate(1));
-  __ pextrd(right_tmp, right, Immediate(1));
-  __ cmpl(left_tmp, right_tmp);
+  __ cmpl(left2, right2);
   __ j(hi_cond, labels.true_label);
   __ j(FlipCondition(hi_cond), labels.false_label);
 
   // If upper is equal, compare lower half.
-  __ pextrd(left_tmp, left, Immediate(0));
-  __ pextrd(right_tmp, right, Immediate(0));
-  __ cmpl(left_tmp, right_tmp);
+  __ cmpl(left1, right1);
   return lo_cond;
 }
 
 
 static Condition TokenKindToDoubleCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kNE: return NOT_EQUAL;
     case Token::kLT: return BELOW;
     case Token::kGT: return ABOVE;
@@ skipping 178 matching lines @@
   __ Bind(&is_true);
   __ LoadObject(result_reg, Bool::True());
   __ Bind(&done);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (operation_cid() == kMintCid) {
-    const intptr_t kNumTemps = 2;
+    const intptr_t kNumTemps = 0;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-    locs->set_in(0, Location::RequiresFpuRegister());
-    locs->set_in(1, Location::RequiresFpuRegister());
-    locs->set_temp(0, Location::RequiresRegister());
-    locs->set_temp(1, Location::RequiresRegister());
+    locs->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                   Location::RequiresRegister()));
+    locs->set_in(1, Location::Pair(Location::RequiresRegister(),
+                                   Location::RequiresRegister()));
     locs->set_out(0, Location::RequiresRegister());
     return locs;
   }
   if (operation_cid() == kDoubleCid) {
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresFpuRegister());
     summary->set_in(1, Location::RequiresFpuRegister());
     summary->set_out(0, Location::RequiresRegister());
     return summary;
@@ skipping 305 matching lines @@
     // element sizes > 1).
     locs->set_in(1, (index_scale() == 1)
                         ? Location::WritableRegister()
                         : Location::RequiresRegister());
   }
   if ((representation() == kUnboxedDouble) ||
       (representation() == kUnboxedFloat32x4) ||
       (representation() == kUnboxedInt32x4) ||
       (representation() == kUnboxedFloat64x2)) {
     locs->set_out(0, Location::RequiresFpuRegister());
+  } else if (representation() == kUnboxedMint) {
+    locs->set_out(0, Location::Pair(Location::RegisterLocation(EAX),
+                                    Location::RegisterLocation(EDX)));

[Florian Schneider, 2014/05/21 12:50:59]

For the case of Uint32Array you don't actually need fixed registers.

[Cutch, 2014/05/21 17:00:03]

Done.

   } else {
+    ASSERT(representation() == kTagged);
     locs->set_out(0, Location::RequiresRegister());
   }
   return locs;
 }
 
 
 void LoadIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register array = locs()->in(0).reg();
   Location index = locs()->in(1);
 
   Address element_address(kNoRegister, 0);
   if (IsExternal()) {
     element_address = index.IsRegister()
         ? FlowGraphCompiler::ExternalElementAddressForRegIndex(
             index_scale(), array, index.reg())
         : FlowGraphCompiler::ExternalElementAddressForIntIndex(
             index_scale(), array, Smi::Cast(index.constant()).Value());
   } else {
     ASSERT(this->array()->definition()->representation() == kTagged);
     element_address = index.IsRegister()
         ? FlowGraphCompiler::ElementAddressForRegIndex(
             class_id(), index_scale(), array, index.reg())
         : FlowGraphCompiler::ElementAddressForIntIndex(
             class_id(), index_scale(), array,
             Smi::Cast(index.constant()).Value());
   }
 
   if ((representation() == kUnboxedDouble) ||
-      (representation() == kUnboxedMint) ||
       (representation() == kUnboxedFloat32x4) ||
       (representation() == kUnboxedInt32x4) ||
       (representation() == kUnboxedFloat64x2)) {
     XmmRegister result = locs()->out(0).fpu_reg();
     if ((index_scale() == 1) && index.IsRegister()) {
       __ SmiUntag(index.reg());
     }
     switch (class_id()) {
-      case kTypedDataInt32ArrayCid:
-        __ movss(result, element_address);
-        __ pmovsxdq(result, result);
-        break;
-      case kTypedDataUint32ArrayCid:
-        __ xorpd(result, result);
-        __ movss(result, element_address);
-        break;
       case kTypedDataFloat32ArrayCid:
         __ movss(result, element_address);
         break;
       case kTypedDataFloat64ArrayCid:
         __ movsd(result, element_address);
         break;
       case kTypedDataInt32x4ArrayCid:
       case kTypedDataFloat32x4ArrayCid:
       case kTypedDataFloat64x2ArrayCid:
         __ movups(result, element_address);
         break;
+      default:
+        UNREACHABLE();
     }
     return;
   }
 
+  if (representation() == kUnboxedMint) {
+    ASSERT(locs()->out(0).IsPairLocation());
+    PairLocation* result_pair = locs()->out(0).AsPairLocation();
+    Register result1 = result_pair->At(0).reg();
+    Register result2 = result_pair->At(1).reg();
+    ASSERT(result1 == EAX);
+    ASSERT(result2 == EDX);

[Florian Schneider, 2014/05/21 12:50:59]

Move these two ASSERTs into the Int32Array case (where you need it because of
using cdq)

[Cutch, 2014/05/21 17:00:03]

Done.

+    if ((index_scale() == 1) && index.IsRegister()) {
+      __ SmiUntag(index.reg());
+    }
+    switch (class_id()) {
+      case kTypedDataInt32ArrayCid:
+        __ movl(result1, element_address);
+        __ cdq();
+        break;
+      case kTypedDataUint32ArrayCid:
+        __ movl(result1, element_address);
+        __ xorl(result2, result2);
+        break;
+      default:
+        UNREACHABLE();
+    }
+    return;
+  }
+
+  ASSERT(representation() == kTagged);
+
   Register result = locs()->out(0).reg();
   if ((index_scale() == 1) && index.IsRegister()) {
     __ SmiUntag(index.reg());
   }
   switch (class_id()) {
     case kTypedDataInt8ArrayCid:
       ASSERT(index_scale() == 1);
       __ movsxb(result, element_address);
       __ SmiTag(result);
       break;
@@ skipping 111 matching lines @@
       // EBX, ECX, EDX) instead of using a fixed register.
       locs->set_in(2, Location::FixedRegisterOrSmiConstant(value(), EAX));
       break;
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
       // Writable register because the value must be untagged before storing.
       locs->set_in(2, Location::WritableRegister());
       break;
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
-      // Mints are stored in XMM registers. For smis, use a writable register
-      // because the value must be untagged before storing.
-      locs->set_in(2, value()->IsSmiValue()
-                      ? Location::WritableRegister()
-                      : Location::RequiresFpuRegister());
+      // For smis, use a writable register because the value must be untagged
+      // before storing. Mints are stored in registers pairs.
+      if (value()->IsSmiValue()) {
+        locs->set_in(2, Location::WritableRegister());
+      } else {
+        // We only move the lower 32-bits so we don't care where the high bits
+        // are located.
+        locs->set_in(2, Location::Pair(Location::RequiresRegister(),
+                                       Location::Any()));
+      }
       break;
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
       // TODO(srdjan): Support Float64 constants.
       locs->set_in(2, Location::RequiresFpuRegister());
       break;
     case kTypedDataInt32x4ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
     case kTypedDataFloat64x2ArrayCid:
       locs->set_in(2, Location::RequiresFpuRegister());
@@ skipping 96 matching lines @@
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
       if (value()->IsSmiValue()) {
         ASSERT(RequiredInputRepresentation(2) == kTagged);
         Register value = locs()->in(2).reg();
         __ SmiUntag(value);
         __ movl(element_address, value);
       } else {
         ASSERT(RequiredInputRepresentation(2) == kUnboxedMint);
-      __ movss(element_address, locs()->in(2).fpu_reg());
+        PairLocation* value_pair = locs()->in(2).AsPairLocation();
+        Register value1 = value_pair->At(0).reg();
+        __ movl(element_address, value1);
       }
       break;
     case kTypedDataFloat32ArrayCid:
       __ movss(element_address, locs()->in(2).fpu_reg());
       break;
     case kTypedDataFloat64ArrayCid:
       __ movsd(element_address, locs()->in(2).fpu_reg());
       break;
     case kTypedDataInt32x4ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
@@ skipping 4182 matching lines @@
     Register length = length_loc.reg();
     Register index = index_loc.reg();
     __ cmpl(index, length);
     __ j(ABOVE_EQUAL, deopt);
   }
 }
 
 
 LocationSummary* UnboxIntegerInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
-  const intptr_t value_cid = value()->Type()->ToCid();
-  const bool needs_temp = ((value_cid != kSmiCid) && (value_cid != kMintCid));
-  const bool needs_writable_input = (value_cid == kSmiCid);
-  const intptr_t kNumTemps = needs_temp ? 1 : 0;
+  const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  summary->set_in(0, needs_writable_input
-                     ? Location::WritableRegister()
-                     : Location::RequiresRegister());
-  if (needs_temp) {
-    summary->set_temp(0, Location::RequiresRegister());
-  }
-  summary->set_out(0, Location::RequiresFpuRegister());
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_out(0, Location::Pair(Location::RegisterLocation(EAX),
+                                     Location::RegisterLocation(EDX)));
   return summary;
 }
 
 
 void UnboxIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
-  const XmmRegister result = locs()->out(0).fpu_reg();
+  PairLocation* result_pair = locs()->out(0).AsPairLocation();
+  Register result_lo = result_pair->At(0).reg();
+  Register result_hi = result_pair->At(1).reg();
+
+  ASSERT(value != result_lo);
+  ASSERT(value != result_hi);
+  ASSERT(result_lo == EAX);
+  ASSERT(result_hi == EDX);
 
   if (value_cid == kMintCid) {
-    __ movsd(result, FieldAddress(value, Mint::value_offset()));
+    __ movl(result_lo, FieldAddress(value, Mint::value_offset()));
+    __ movl(result_hi, FieldAddress(value, Mint::value_offset() + kWordSize));
   } else if (value_cid == kSmiCid) {
-    __ SmiUntag(value);  // Untag input before conversion.
-    __ movd(result, value);
-    __ pmovsxdq(result, result);
+    __ movl(result_lo, value);
+    __ SmiUntag(result_lo);
+    // Sign extend into result_hi.
+    __ cdq();
   } else {
-    Register temp = locs()->temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(deopt_id_,
                                           ICData::kDeoptUnboxInteger);
     Label is_smi, done;
     __ testl(value, Immediate(kSmiTagMask));
     __ j(ZERO, &is_smi);
-    __ CompareClassId(value, kMintCid, temp);
+    __ CompareClassId(value, kMintCid, result_lo);
     __ j(NOT_EQUAL, deopt);
-    __ movsd(result, FieldAddress(value, Mint::value_offset()));
+    __ movl(result_lo, FieldAddress(value, Mint::value_offset()));
+    __ movl(result_hi, FieldAddress(value, Mint::value_offset() + kWordSize));
     __ jmp(&done);
     __ Bind(&is_smi);
-    __ movl(temp, value);
-    __ SmiUntag(temp);
-    __ movd(result, temp);
-    __ pmovsxdq(result, result);
+    __ movl(result_lo, value);
+    __ SmiUntag(result_lo);
+    // Sign extend into result_hi.
+    __ cdq();
     __ Bind(&done);
   }
 }
 
 
 LocationSummary* BoxIntegerInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
-  const intptr_t kNumTemps = 2;
+  const intptr_t kNumTemps = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs,
                           kNumTemps,
                           LocationSummary::kCallOnSlowPath);
-  summary->set_in(0, Location::RequiresFpuRegister());
-  summary->set_temp(0, Location::RegisterLocation(EAX));
-  summary->set_temp(1, Location::RegisterLocation(EDX));
-  // TODO(fschneider): Save one temp by using result register as a temp.
+  summary->set_in(0, Location::Pair(Location::RegisterLocation(EAX),
+                                    Location::RegisterLocation(EDX)));
+  summary->set_temp(0, Location::RequiresRegister());
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 class BoxIntegerSlowPath : public SlowPathCode {
  public:
   explicit BoxIntegerSlowPath(BoxIntegerInstr* instruction)
       : instruction_(instruction) { }
 
@@ skipping 21 matching lines @@
   }
 
  private:
   BoxIntegerInstr* instruction_;
 };
 
 
 void BoxIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   BoxIntegerSlowPath* slow_path = new BoxIntegerSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
+  PairLocation* value_pair = locs()->in(0).AsPairLocation();
+  Register value_lo = value_pair->At(0).reg();
+  Register value_hi = value_pair->At(1).reg();
+  Register out_reg = locs()->out(0).reg();
 
-  Register out_reg = locs()->out(0).reg();
-  XmmRegister value = locs()->in(0).fpu_reg();
+  ASSERT(value_lo == EAX);

[Florian Schneider, 2014/05/21 12:50:59]

Where is it assumed that value_lo must be EAX? It seems that you can change it
to an arbitrary register.

[Cutch, 2014/05/21 17:00:03]

Done.

+  ASSERT(value_hi == EDX);

[Florian Schneider, 2014/05/21 12:50:59]

Same for value_hi.

[Cutch, 2014/05/21 17:00:03]

Done.

+
+  // Copy value_hi into out_reg as a temporary.
+  // We modify value_lo but restore it before using it.
+  __ movl(out_reg, value_hi);
 
   // Unboxed operations produce smis or mint-sized values.
   // Check if value fits into a smi.
   Label not_smi, done;
-  __ pextrd(EDX, value, Immediate(1));  // Upper half.
-  __ pextrd(EAX, value, Immediate(0));  // Lower half.
+
   // 1. Compute (x + -kMinSmi) which has to be in the range
   //    0 .. -kMinSmi+kMaxSmi for x to fit into a smi.
-  __ addl(EAX, Immediate(0x40000000));
-  __ adcl(EDX, Immediate(0));
+  __ addl(value_lo, Immediate(0x40000000));
+  __ adcl(out_reg, Immediate(0));
   // 2. Unsigned compare to -kMinSmi+kMaxSmi.
-  __ cmpl(EAX, Immediate(0x80000000));
-  __ sbbl(EDX, Immediate(0));
+  __ cmpl(value_lo, Immediate(0x80000000));
+  __ sbbl(out_reg, Immediate(0));
   __ j(ABOVE_EQUAL, &not_smi);
   // 3. Restore lower half if result is a smi.
-  __ subl(EAX, Immediate(0x40000000));
-
-  __ SmiTag(EAX);
-  __ movl(out_reg, EAX);
+  __ subl(value_lo, Immediate(0x40000000));
+  __ movl(out_reg, value_lo);
+  __ SmiTag(out_reg);
   __ jmp(&done);
-
   __ Bind(&not_smi);
   __ TryAllocate(
       Class::ZoneHandle(Isolate::Current()->object_store()->mint_class()),
       slow_path->entry_label(),
       Assembler::kFarJump,
       out_reg,
       kNoRegister);
   __ Bind(slow_path->exit_label());
-  __ movsd(FieldAddress(out_reg, Mint::value_offset()), value);
+  // 3. Restore lower half of input before using it.
+  __ subl(value_lo, Immediate(0x40000000));
+  __ movl(FieldAddress(out_reg, Mint::value_offset()), value_lo);
+  __ movl(FieldAddress(out_reg, Mint::value_offset() + kWordSize), value_hi);
   __ Bind(&done);
 }
 
 
 LocationSummary* BinaryMintOpInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 2;
   switch (op_kind()) {
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR: {
-      const intptr_t kNumTemps =
-          FLAG_throw_on_javascript_int_overflow ? 1 : 0;
+      const intptr_t kNumTemps = 0;
       LocationSummary* summary =
           new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-      summary->set_in(0, Location::RequiresFpuRegister());
-      summary->set_in(1, Location::RequiresFpuRegister());
-      if (FLAG_throw_on_javascript_int_overflow) {
-        summary->set_temp(0, Location::RequiresRegister());
-      }
+      summary->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                        Location::RequiresRegister()));
+      summary->set_in(1, Location::Pair(Location::RequiresRegister(),
+                                        Location::RequiresRegister()));
       summary->set_out(0, Location::SameAsFirstInput());
       return summary;
     }
     case Token::kADD:
     case Token::kSUB: {
-      const intptr_t kNumTemps = 2;
+      const intptr_t kNumTemps = 0;
       LocationSummary* summary =
           new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-      summary->set_in(0, Location::RequiresFpuRegister());
-      summary->set_in(1, Location::RequiresFpuRegister());
-      summary->set_temp(0, Location::RequiresRegister());
-      summary->set_temp(1, Location::RequiresRegister());
+      summary->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                        Location::RequiresRegister()));
+      summary->set_in(1, Location::Pair(Location::RequiresRegister(),
+                                        Location::RequiresRegister()));
       summary->set_out(0, Location::SameAsFirstInput());
       return summary;
     }
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 void BinaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  XmmRegister left = locs()->in(0).fpu_reg();
-  XmmRegister right = locs()->in(1).fpu_reg();
-
-  ASSERT(locs()->out(0).fpu_reg() == left);
+  PairLocation* left_pair = locs()->in(0).AsPairLocation();
+  Register left_lo = left_pair->At(0).reg();
+  Register left_hi = left_pair->At(1).reg();
+  PairLocation* right_pair = locs()->in(1).AsPairLocation();
+  Register right_lo = right_pair->At(0).reg();
+  Register right_hi = right_pair->At(1).reg();
+  PairLocation* out_pair = locs()->out(0).AsPairLocation();
+  Register out_lo = out_pair->At(0).reg();
+  Register out_hi = out_pair->At(1).reg();
+  ASSERT(out_lo == left_lo);
+  ASSERT(out_hi == left_hi);
 
   Label* deopt = NULL;
   if (FLAG_throw_on_javascript_int_overflow) {
     deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryMintOp);
   }
   switch (op_kind()) {
-    case Token::kBIT_AND: __ andpd(left, right); break;
-    case Token::kBIT_OR:  __ orpd(left, right); break;
-    case Token::kBIT_XOR: __ xorpd(left, right); break;
+    case Token::kBIT_AND:
+      __ andl(left_lo, right_lo);
+      __ andl(left_hi, right_hi);
+      break;
+    case Token::kBIT_OR:
+      __ orl(left_lo, right_lo);
+      __ orl(left_hi, right_hi);
+      break;
+    case Token::kBIT_XOR:
+      __ xorl(left_lo, right_lo);
+      __ xorl(left_hi, right_hi);
+      break;
     case Token::kADD:
     case Token::kSUB: {
-      Register lo = locs()->temp(0).reg();
-      Register hi = locs()->temp(1).reg();
       if (!FLAG_throw_on_javascript_int_overflow) {
         deopt  = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryMintOp);
       }
-
-      Label done, overflow;
-      __ pextrd(lo, right, Immediate(0));  // Lower half
-      __ pextrd(hi, right, Immediate(1));  // Upper half
-      __ subl(ESP, Immediate(2 * kWordSize));
-      __ movq(Address(ESP, 0), left);
       if (op_kind() == Token::kADD) {
-        __ addl(Address(ESP, 0), lo);
-        __ adcl(Address(ESP, 1 * kWordSize), hi);
+        __ addl(left_lo, right_lo);
+        __ adcl(left_hi, right_hi);
       } else {
-        __ subl(Address(ESP, 0), lo);
-        __ sbbl(Address(ESP, 1 * kWordSize), hi);
+        __ subl(left_lo, right_lo);
+        __ sbbl(left_hi, right_hi);
       }
-      __ j(OVERFLOW, &overflow);
-      __ movq(left, Address(ESP, 0));
-      __ addl(ESP, Immediate(2 * kWordSize));
-      __ jmp(&done);
-      __ Bind(&overflow);
-      __ addl(ESP, Immediate(2 * kWordSize));
-      __ jmp(deopt);
-      __ Bind(&done);
+      __ j(OVERFLOW, deopt);
       break;
     }
     default: UNREACHABLE();
   }
   if (FLAG_throw_on_javascript_int_overflow) {
-    Register tmp = locs()->temp(0).reg();
-    EmitJavascriptIntOverflowCheck(compiler, deopt, left, tmp);
+    EmitJavascriptIntOverflowCheck(compiler, deopt, left_lo, left_hi);
   }
 }
 
 
 LocationSummary* ShiftMintOpInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 2;
-  const intptr_t kNumTemps = op_kind() == Token::kSHL ? 2 : 1;
+  const intptr_t kNumTemps = op_kind() == Token::kSHL ? 2 : 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  summary->set_in(0, Location::RequiresFpuRegister());
+  summary->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                    Location::RequiresRegister()));
   summary->set_in(1, Location::RegisterLocation(ECX));
-  summary->set_temp(0, Location::RequiresRegister());
   if (op_kind() == Token::kSHL) {
+    summary->set_temp(0, Location::RequiresRegister());
     summary->set_temp(1, Location::RequiresRegister());
   }
   summary->set_out(0, Location::SameAsFirstInput());
   return summary;
 }
 
 
 void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  XmmRegister left = locs()->in(0).fpu_reg();
-  ASSERT(locs()->in(1).reg() == ECX);
-  ASSERT(locs()->out(0).fpu_reg() == left);
+  PairLocation* left_pair = locs()->in(0).AsPairLocation();
+  Register left_lo = left_pair->At(0).reg();
+  Register left_hi = left_pair->At(1).reg();
+  PairLocation* out_pair = locs()->out(0).AsPairLocation();
+  Register out_lo = out_pair->At(0).reg();
+  Register out_hi = out_pair->At(1).reg();
+  ASSERT(out_lo == left_lo);
+  ASSERT(out_hi == left_hi);
 
   Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptShiftMintOp);
   Label done;
   __ testl(ECX, ECX);
   __ j(ZERO, &done);  // Shift by 0 is a nop.
-  __ subl(ESP, Immediate(2 * kWordSize));
-  __ movq(Address(ESP, 0), left);
   // Deoptimize if shift count is > 31.
   // sarl operation masks the count to 5 bits and
   // shrd is undefined with count > operand size (32)
   // TODO(fschneider): Support shift counts > 31 without deoptimization.
   __ SmiUntag(ECX);
   const Immediate& kCountLimit = Immediate(31);
   __ cmpl(ECX, kCountLimit);
   __ j(ABOVE, deopt);
   switch (op_kind()) {
     case Token::kSHR: {
-      Register temp = locs()->temp(0).reg();
-      __ movl(temp, Address(ESP, 1 * kWordSize));  // High half.
-      __ shrd(Address(ESP, 0), temp);  // Shift count in CL.
-      __ sarl(Address(ESP, 1 * kWordSize), ECX);  // Shift count in CL.
+      __ shrd(left_lo, left_hi);  // Shift count in CL.
+      __ sarl(left_hi, ECX);  // Shift count in CL.
       break;
     }
     case Token::kSHL: {
       Register temp1 = locs()->temp(0).reg();
       Register temp2 = locs()->temp(1).reg();
-      __ movl(temp1, Address(ESP, 0 * kWordSize));  // Low 32 bits.
-      __ movl(temp2, Address(ESP, 1 * kWordSize));  // High 32 bits.
-      __ shll(Address(ESP, 0 * kWordSize), ECX);  // Shift count in CL.
-      __ shld(Address(ESP, 1 * kWordSize), temp1);  // Shift count in CL.
+      __ movl(temp1, left_lo);  // Low 32 bits.
+      __ movl(temp2, left_hi);  // High 32 bits.
+      __ shll(left_lo, ECX);  // Shift count in CL.
+      __ shld(left_hi, temp1);  // Shift count in CL.
       // Check for overflow by shifting back the high 32 bits
       // and comparing with the input.
       __ movl(temp1, temp2);
-      __ movl(temp2, Address(ESP, 1 * kWordSize));
+      __ movl(temp2, left_hi);
       __ sarl(temp2, ECX);
       __ cmpl(temp1, temp2);
       __ j(NOT_EQUAL, deopt);
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
-  __ movq(left, Address(ESP, 0));
-  __ addl(ESP, Immediate(2 * kWordSize));
   __ Bind(&done);
   if (FLAG_throw_on_javascript_int_overflow) {
-    Register tmp = locs()->temp(0).reg();
-    EmitJavascriptIntOverflowCheck(compiler, deopt, left, tmp);
+    EmitJavascriptIntOverflowCheck(compiler, deopt, left_lo, left_hi);
   }
 }
 
 
 LocationSummary* UnaryMintOpInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
-  const intptr_t kNumTemps =
-      FLAG_throw_on_javascript_int_overflow ? 1 : 0;
+  const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  summary->set_in(0, Location::RequiresFpuRegister());
+  summary->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                    Location::RequiresRegister()));
   summary->set_out(0, Location::SameAsFirstInput());
   if (FLAG_throw_on_javascript_int_overflow) {
     summary->set_temp(0, Location::RequiresRegister());
   }
   return summary;
 }
 
 
 void UnaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(op_kind() == Token::kBIT_NOT);
-  XmmRegister value = locs()->in(0).fpu_reg();
-  ASSERT(value == locs()->out(0).fpu_reg());
+  PairLocation* left_pair = locs()->in(0).AsPairLocation();
+  Register left_lo = left_pair->At(0).reg();
+  Register left_hi = left_pair->At(1).reg();
+  PairLocation* out_pair = locs()->out(0).AsPairLocation();
+  Register out_lo = out_pair->At(0).reg();
+  Register out_hi = out_pair->At(1).reg();
+  ASSERT(out_lo == left_lo);
+  ASSERT(out_hi == left_hi);
+
   Label* deopt = NULL;
   if (FLAG_throw_on_javascript_int_overflow) {
     deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnaryMintOp);
   }
-  __ pcmpeqq(XMM0, XMM0);  // Generate all 1's.
-  __ pxor(value, XMM0);
+
+  __ notl(left_lo);
+  __ notl(left_hi);
+
   if (FLAG_throw_on_javascript_int_overflow) {
-    Register tmp = locs()->temp(0).reg();
-    EmitJavascriptIntOverflowCheck(compiler, deopt, value, tmp);
+    EmitJavascriptIntOverflowCheck(compiler, deopt, left_lo, left_hi);
   }
 }
 
 
 LocationSummary* ThrowInstr::MakeLocationSummary(bool opt) const {
   return new LocationSummary(0, 0, LocationSummary::kCall);
 }
 
 
 
@@ skipping 314 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32