Add unboxed Mint for X64

runtime/vm/intermediate_language_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 355 matching lines @@
     default:
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 LocationSummary* EqualityCompareInstr::MakeLocationSummary(Isolate* isolate,
                                                            bool opt) const {
   const intptr_t kNumInputs = 2;
+  if (operation_cid() == kMintCid) {
+    const intptr_t kNumTemps = 0;
+    LocationSummary* locs = new(isolate) LocationSummary(
+        isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+    locs->set_in(0, Location::RequiresRegister());
+    locs->set_in(1, Location::RequiresRegister());
+    locs->set_out(0, Location::RequiresRegister());
+    return locs;
+  }
   if (operation_cid() == kDoubleCid) {
     const intptr_t kNumTemps =  0;
     LocationSummary* locs = new(isolate) LocationSummary(
         isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresFpuRegister());
     locs->set_in(1, Location::RequiresFpuRegister());
     locs->set_out(0, Location::RequiresRegister());
     return locs;
   }
   if (operation_cid() == kSmiCid) {
@@ skipping 89 matching lines @@
     __ CompareObject(left.reg(), right.constant(), PP);
   } else if (right.IsStackSlot()) {
     __ cmpq(left.reg(), right.ToStackSlotAddress());
   } else {
     __ cmpq(left.reg(), right.reg());
   }
   return true_condition;
 }
 
 
+static Condition TokenKindToMintCondition(Token::Kind kind) {

[Vyacheslav Egorov (Google), 2014/10/05 18:46:59]

I don't think there is a need to have this duplicated. Just
s/SmiCondition/IntCondition/ and use that function.

[Cutch, 2014/10/06 23:55:25]

Done.

+  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 EmitMintComparisonOp(FlowGraphCompiler* compiler,

[Vyacheslav Egorov (Google), 2014/10/05 18:47:00]

This is essentially the same as EmitSmiComparisonOp. Can we use that?

[Cutch, 2014/10/06 23:55:25]

Done.

+                                      const LocationSummary& locs,
+                                      Token::Kind kind,
+                                      BranchLabels labels) {
+  const Location left = locs.in(0);
+  const Location right = locs.in(1);
+
+  ASSERT(!left.IsConstant() || !right.IsConstant());
+
+  Condition true_condition = TokenKindToMintCondition(kind);
+
+  __ cmpq(left.reg(), right.reg());
+
+  return true_condition;
+}
+
 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;
     case Token::kLTE: return BELOW_EQUAL;
     case Token::kGTE: return ABOVE_EQUAL;
     default:
       UNREACHABLE();
@@ skipping 16 matching lines @@
       ? labels.true_label : labels.false_label;
   __ j(PARITY_EVEN, nan_result);
   return true_condition;
 }
 
 
 Condition EqualityCompareInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                                    BranchLabels labels) {
   if (operation_cid() == kSmiCid) {
     return EmitSmiComparisonOp(compiler, *locs(), kind(), labels);
+  } else if (operation_cid() == kMintCid) {
+    return EmitMintComparisonOp(compiler, *locs(), kind(), labels);
   } else {
     ASSERT(operation_cid() == kDoubleCid);
     return EmitDoubleComparisonOp(compiler, *locs(), kind(), labels);
   }
 }
 
 
 void EqualityCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT((kind() == Token::kEQ) || (kind() == Token::kNE));
 
@@ skipping 145 matching lines @@
                                                         bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (operation_cid() == kDoubleCid) {
     LocationSummary* summary = new(isolate) LocationSummary(
         isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresFpuRegister());
     summary->set_in(1, Location::RequiresFpuRegister());
     summary->set_out(0, Location::RequiresRegister());
     return summary;
+  } else if (operation_cid() == kMintCid) {
+    LocationSummary* summary = new(isolate) LocationSummary(
+        isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+    summary->set_in(0, Location::RequiresRegister());
+    summary->set_in(1, Location::RequiresRegister());
+    summary->set_out(0, Location::RequiresRegister());
+    return summary;
   }
   ASSERT(operation_cid() == kSmiCid);
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, 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()
                          : Location::RegisterOrConstant(right()));
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 Condition RelationalOpInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                                 BranchLabels labels) {
   if (operation_cid() == kSmiCid) {
     return EmitSmiComparisonOp(compiler, *locs(), kind(), labels);
+  } else if (operation_cid() == kMintCid) {
+    return EmitMintComparisonOp(compiler, *locs(), kind(), labels);
   } else {
     ASSERT(operation_cid() == kDoubleCid);
     return EmitDoubleComparisonOp(compiler, *locs(), kind(), labels);
   }
 }
 
 
 void RelationalOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label is_true, is_false;
   BranchLabels labels = { &is_true, &is_false, &is_false };
@@ skipping 226 matching lines @@
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
     case kOneByteStringCid:
     case kTwoByteStringCid:
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
       return CompileType::FromCid(kSmiCid);
 
+    case kTypedDataInt64ArrayCid:
+      return CompileType::Int();
+
     default:
       UNIMPLEMENTED();
       return CompileType::Dynamic();
   }
 }
 
 
 Representation LoadIndexedInstr::representation() const {
   switch (class_id_) {
     case kArrayCid:
     case kImmutableArrayCid:
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
     case kOneByteStringCid:
     case kTwoByteStringCid:
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
       return kTagged;
+    case kTypedDataInt64ArrayCid:
+      return kUnboxedMint;
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
       return kUnboxedDouble;
     case kTypedDataInt32x4ArrayCid:
       return kUnboxedInt32x4;
     case kTypedDataFloat32x4ArrayCid:
       return kUnboxedFloat32x4;
     case kTypedDataFloat64x2ArrayCid:
       return kUnboxedFloat64x2;
     default:
@@ skipping 95 matching lines @@
       __ SmiTag(result);
       break;
     case kTypedDataInt32ArrayCid:
       __ movsxd(result, element_address);
       __ SmiTag(result);
       break;
     case kTypedDataUint32ArrayCid:
       __ movl(result, element_address);
       __ SmiTag(result);
       break;
+    case kTypedDataInt64ArrayCid:
+      __ movq(result, element_address);
+      break;
     default:
       ASSERT((class_id() == kArrayCid) || (class_id() == kImmutableArrayCid));
       __ movq(result, element_address);
       break;
   }
 }
 
 
 Representation StoreIndexedInstr::RequiredInputRepresentation(
     intptr_t idx) const {
   if (idx == 0) return kNoRepresentation;
   if (idx == 1) return kTagged;
   ASSERT(idx == 2);
   switch (class_id_) {
     case kArrayCid:
     case kOneByteStringCid:
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
       return kTagged;
     case kTypedDataInt32ArrayCid:
       return kUnboxedInt32;
     case kTypedDataUint32ArrayCid:
       return kUnboxedUint32;
+    case kTypedDataInt64ArrayCid:
+      return kUnboxedMint;
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
       return kUnboxedDouble;
     case kTypedDataFloat32x4ArrayCid:
       return kUnboxedFloat32x4;
     case kTypedDataInt32x4ArrayCid:
       return kUnboxedInt32x4;
     case kTypedDataFloat64x2ArrayCid:
       return kUnboxedFloat64x2;
     default:
@@ skipping 37 matching lines @@
       // RBX, RCX, RDX) instead of using a fixed register.
       locs->set_in(2, Location::FixedRegisterOrSmiConstant(value(), RAX));
       break;
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
       // Writable register because the value must be untagged before storing.
       locs->set_in(2, Location::WritableRegister());
       break;
+    case kTypedDataInt64ArrayCid:
+      locs->set_in(2, Location::RequiresRegister());
+      break;
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
       // TODO(srdjan): Support Float64 constants.
       locs->set_in(2, Location::RequiresFpuRegister());
       break;
     case kTypedDataInt32x4ArrayCid:
     case kTypedDataFloat64x2ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
       locs->set_in(2, Location::RequiresFpuRegister());
       break;
@@ skipping 81 matching lines @@
     case kTypedDataUint16ArrayCid: {
       Register value = locs()->in(2).reg();
       __ SmiUntag(value);
       __ movw(element_address, value);
       break;
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid: {
       Register value = locs()->in(2).reg();
       __ movl(element_address, value);
-        break;
+      break;
+    }
+    case kTypedDataInt64ArrayCid: {
+      Register value = locs()->in(2).reg();
+      __ movq(element_address, value);
+      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 kTypedDataFloat64x2ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
@@ skipping 4147 matching lines @@
     Register length = length_loc.reg();
     Register index = index_loc.reg();
     __ cmpq(index, length);
     __ j(ABOVE_EQUAL, deopt);
   }
 }
 
 
 LocationSummary* UnboxIntegerInstr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  locs->set_in(0, Location::RequiresRegister());
+  locs->set_out(0, Location::RequiresRegister());
+  return locs;
 }
 
 
 void UnboxIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  const intptr_t value_cid = value()->Type()->ToCid();
+  const Register value = locs()->in(0).reg();
+  const Register result = locs()->out(0).reg();
+
+  if (value_cid == kMintCid) {
+    __ movq(result, FieldAddress(value, Mint::value_offset()));
+  } else if (value_cid == kSmiCid) {
+    __ movq(result, value);
+    __ SmiUntag(result);
+  } else {
+    Label* deopt = compiler->AddDeoptStub(deopt_id_,
+                                          ICData::kDeoptUnboxInteger);
+    Label is_smi, done;
+    __ testq(value, Immediate(kSmiTagMask));

[Vyacheslav Egorov (Google), 2014/10/05 18:46:59]

You can produce much smaller instruction sequence with (assuming out has
SameAsFirstInput policy).

    __ SmiUntagOrCheckClass(value, kMintCid, &done);
    __ j(NOT_EQUAL, deopt);
    // Undo untagging by multiplying value with 2.
    __ movq(value, Address(value, TIMES_2, Mint::value_offset()));
    __ Bind(&done);

See UnboxIntNInstr 

[Cutch, 2014/10/06 23:55:26]

Done.

+    __ j(ZERO, &is_smi);
+    __ CompareClassId(value, kMintCid);
+    __ j(NOT_EQUAL, deopt);
+    __ movq(result, FieldAddress(value, Mint::value_offset()));
+    __ jmp(&done);
+    __ Bind(&is_smi);
+    __ movq(result, value);
+    __ SmiUntag(result);
+    __ Bind(&done);
+  }
 }
 
 
 LocationSummary* BoxIntegerInstr::MakeLocationSummary(Isolate* isolate,
                                                       bool opt) const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, is_smi()
+                                          ? LocationSummary::kNoCall
+                                          : LocationSummary::kCallOnSlowPath);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_out(0, Location::RequiresRegister());
+  return summary;
 }
 
 
 void BoxIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  const Register out = locs()->out(0).reg();
+  const Register value = locs()->in(0).reg();
+
+  if (is_smi()) {
+    __ movq(out, value);
+    __ SmiTag(out);
+    return;
+  }
+
+  Label is_smi;
+  Label done;
+  // Tag, Untag, and then compare with original value.
+  __ movq(out, value);
+  __ SmiTag(out);
+  __ SmiUntag(out);

[Vyacheslav Egorov (Google), 2014/10/05 18:46:59]

__ movq(out, value);
__ SmiTag(out);   // shrl sets OF := SF ^ CF on 1 bit shifts
__ j(NOT_OVERFLOW, &done);
BoxAllocationSlowPath::Allocate(
    compiler, this, compiler->mint_class(), out);
__ movq(FieldAddress(out, Mint::value_offset()), value);
__ Bind(&done);

[Cutch, 2014/10/06 23:55:25]

Done.

+  __ cmpq(out, value);
+  __ j(EQUAL, &is_smi);
+  BoxAllocationSlowPath::Allocate(
+      compiler, this, compiler->mint_class(), out);
+  __ movq(FieldAddress(out, Mint::value_offset()), value);
+  __ jmp(&done);
+  __ Bind(&is_smi);
+  __ movq(out, value);
+  __ SmiTag(out);
+  __ Bind(&done);
 }
 
 
 LocationSummary* BinaryMintOpInstr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_in(1, Location::RequiresRegister());
+  summary->set_out(0, Location::SameAsFirstInput());
+  return summary;
 }
 
 
 void BinaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  const Register left = locs()->in(0).reg();
+  const Register right = locs()->in(1).reg();
+  const Register out = locs()->out(0).reg();
+
+  ASSERT(out == left);
+
+  Label* deopt = NULL;
+  if (CanDeoptimize()) {
+    deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryMintOp);
+  }
+
+  switch (op_kind()) {

[Vyacheslav Egorov (Google), 2014/10/05 18:46:59]

use EmitIntegerArithmetic

[Cutch, 2014/10/06 23:55:25]

EmitIntegerArithmetic does 32-bit operations, these are 64-it operations. I've
split this out into an EmitInteger64Arithmetic utility function.

[Vyacheslav Egorov (Google), 2014/10/07 12:03:50]

Ack, true, shame on me! 

I was dwelling in ia32-thinking where Smi/(U)Int32 arithmetic can be unified. 

Here Mint/Smi can be unified instead.

[Cutch, 2014/10/21 17:42:11]

Done.

+    case Token::kBIT_AND:
+      __ andq(left, right);
+      break;
+    case Token::kBIT_OR:
+      __ orq(left, right);
+      break;
+    case Token::kBIT_XOR:
+      __ xorq(left, right);
+      break;
+    case Token::kADD:
+    case Token::kSUB: {
+      if (op_kind() == Token::kADD) {
+        __ addq(left, right);
+      } else {
+        __ subq(left, right);
+      }
+      if (can_overflow()) {
+        ASSERT(deopt != NULL);
+        __ j(OVERFLOW, deopt);
+      }
+      break;
+    }
+    case Token::kMUL:
+      __ imulq(left, right);
+      ASSERT(deopt != NULL);
+      __ j(OVERFLOW, deopt);
+    break;
+    default:
+      UNREACHABLE();
+    break;
+  }
+  if (FLAG_throw_on_javascript_int_overflow) {
+    EmitJavascriptOverflowCheck(compiler, range(), deopt, out);
+  }
 }
 
 
 LocationSummary* UnaryMintOpInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_out(0, Location::SameAsFirstInput());
+  return summary;
 }
 
 
 void UnaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
-}
-
+  ASSERT(op_kind() == Token::kBIT_NOT);
+  const Register left = locs()->in(0).reg();
+  const Register out = locs()->out(0).reg();
+  ASSERT(out == left);
+
+  Label* deopt = NULL;
+  if (FLAG_throw_on_javascript_int_overflow) {
+    deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnaryMintOp);
+  }
+
+  __ notq(left);
+
+  if (FLAG_throw_on_javascript_int_overflow) {
+    EmitJavascriptOverflowCheck(compiler, range(), deopt, out);
+  }
+}
+
+
+static const intptr_t kMintShiftCountLimit = 63;
 
 bool ShiftMintOpInstr::has_shift_count_check() const {
-  UNREACHABLE();
-  return false;
+  return !RangeUtils::IsWithin(
+      right()->definition()->range(), 0, kMintShiftCountLimit);
 }
 
 
 LocationSummary* ShiftMintOpInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = can_overflow() ? 1 : 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_in(1, Location::FixedRegisterOrSmiConstant(right(), RCX));
+  if (kNumTemps > 0) {
+    summary->set_temp(0, Location::RequiresRegister());
+  }
+  summary->set_out(0, Location::SameAsFirstInput());
+  return summary;
 }
 
 
 void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
-}
-
-
+  const Register left = locs()->in(0).reg();
+  const Register out = locs()->out(0).reg();
+  ASSERT(left == out);
+
+  Label* deopt = NULL;
+  if (CanDeoptimize()) {
+    deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptShiftMintOp);
+  }
+  if (locs()->in(1).IsConstant()) {
+    // Code for a constant shift amount.
+    ASSERT(locs()->in(1).constant().IsSmi());
+    const int64_t shift =
+        reinterpret_cast<int64_t>(locs()->in(1).constant().raw()) >> 1;
+    if ((shift < 0) || (shift > kMintShiftCountLimit)) {

[Vyacheslav Egorov (Google), 2014/10/05 18:47:00]

These cases should be handled in the Canonicalize already. 

[Cutch, 2014/10/06 23:55:26]

Done.

+      __ jmp(deopt);
+      return;
+    } else if (shift == 0) {
+      // Nothing to do for zero shift amount.
+      return;
+    }
+    switch (op_kind()) {
+      case Token::kSHR:
+        __ sarq(left, Immediate(shift));
+        break;
+      case Token::kSHL: {
+        if (can_overflow()) {
+          // Check for overflow.
+          Register temp = locs()->temp(0).reg();
+          __ movq(temp, left);
+          __ shlq(left, Immediate(shift));
+          __ sarq(left, Immediate(shift));
+          __ cmpq(left, temp);
+          __ j(NOT_EQUAL, deopt);  // Overflow.
+        }
+        // Shift for result now we know there is no overflow.
+        __ shlq(left, Immediate(shift));
+        break;
+      }
+      default:
+        UNREACHABLE();
+    }
+  } else {
+    // Code for a variable shift amount.
+    // Deoptimize if shift count is > 63.
+    // sarl operation masks the count to 5 bits and
+    // shrd is undefined with count > operand size (32)
+    __ SmiUntag(RCX);
+    if (has_shift_count_check()) {
+      __ cmpq(RCX, Immediate(kMintShiftCountLimit));
+      __ j(ABOVE, deopt);
+    }
+    Label done, large_shift;
+    switch (op_kind()) {
+      case Token::kSHR: {
+        __ sarq(left, RCX);
+        break;
+      }
+      case Token::kSHL: {
+        if (can_overflow()) {
+          // Check for overflow.
+          Register temp = locs()->temp(0).reg();
+          __ movq(temp, left);
+          __ shlq(left, RCX);
+          __ sarq(left, RCX);
+          __ cmpq(left, temp);
+          __ j(NOT_EQUAL, deopt);  // Overflow.
+        }
+        // Shift for result now we know there is no overflow.
+        __ shlq(left, RCX);
+        break;
+      }
+      default:
+        UNREACHABLE();
+    }
+  }
+  if (FLAG_throw_on_javascript_int_overflow) {
+    EmitJavascriptOverflowCheck(compiler, range(), deopt, out);
+  }
+}
+
+
 CompileType BinaryUint32OpInstr::ComputeType() const {
   return CompileType::FromCid(kSmiCid);
 }
 
 
 CompileType ShiftUint32OpInstr::ComputeType() const {
   return CompileType::FromCid(kSmiCid);
 }
 
 
 CompileType UnaryUint32OpInstr::ComputeType() const {
   return CompileType::FromCid(kSmiCid);
 }
 
 
-DEFINE_UNIMPLEMENTED_INSTRUCTION(BinaryUint32OpInstr)
-DEFINE_UNIMPLEMENTED_INSTRUCTION(ShiftUint32OpInstr)
-DEFINE_UNIMPLEMENTED_INSTRUCTION(UnaryUint32OpInstr)
+LocationSummary* BinaryUint32OpInstr::MakeLocationSummary(Isolate* isolate,
+                                                          bool opt) const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = (op_kind() == Token::kMUL) ? 1 : 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_in(1, Location::RequiresRegister());
+  summary->set_out(0, Location::SameAsFirstInput());
+  return summary;
+}
+
+
+template<typename OperandType>
+static void EmitIntegerArithmetic(FlowGraphCompiler* compiler,
+                                  Token::Kind op_kind,
+                                  Register left,
+                                  const OperandType& right,
+                                  Label* deopt) {
+  switch (op_kind) {
+    case Token::kADD:
+      __ addl(left, right);
+      break;
+    case Token::kSUB:
+      __ subl(left, right);
+      break;
+    case Token::kBIT_AND:
+      __ andl(left, right);
+      break;
+    case Token::kBIT_OR:
+      __ orl(left, right);
+      break;
+    case Token::kBIT_XOR:
+      __ xorl(left, right);
+      break;
+    case Token::kMUL:
+      __ imull(left, right);
+      break;
+    default:
+      UNREACHABLE();
+  }
+  if (deopt != NULL) __ j(OVERFLOW, deopt);
+}
+
+
+void BinaryUint32OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register left = locs()->in(0).reg();
+  Register right = locs()->in(1).reg();
+  Register out = locs()->out(0).reg();
+  ASSERT(out == left);
+  switch (op_kind()) {
+    case Token::kBIT_AND:
+    case Token::kBIT_OR:
+    case Token::kBIT_XOR:
+    case Token::kADD:
+    case Token::kSUB:
+    case Token::kMUL:
+      EmitIntegerArithmetic(compiler, op_kind(), left, right, NULL);
+      return;
+    default:
+      UNREACHABLE();
+  }
+}
+
+
+LocationSummary* ShiftUint32OpInstr::MakeLocationSummary(Isolate* isolate,
+                                                         bool opt) const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_in(1, Location::FixedRegisterOrSmiConstant(right(), RCX));
+  summary->set_out(0, Location::SameAsFirstInput());
+  return summary;
+}
+
+
+void ShiftUint32OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  const intptr_t kShifterLimit = 31;
+
+  Register left = locs()->in(0).reg();
+  Register out = locs()->out(0).reg();
+  ASSERT(left == out);
+
+
+  Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptShiftMintOp);
+
+  if (locs()->in(1).IsConstant()) {
+    // Shifter is constant.
+
+    const Object& constant = locs()->in(1).constant();
+    ASSERT(constant.IsSmi());
+    const intptr_t shift_value = Smi::Cast(constant).Value();
+
+    // Check constant shift value.
+    if (shift_value == 0) {

[Vyacheslav Egorov (Google), 2014/10/05 18:46:59]

Should be handled in the Canonicalize

[Cutch, 2014/10/06 23:55:25]

Done.

+      // Nothing to do.
+    } else if (shift_value < 0) {
+      // Invalid shift value.
+      __ jmp(deopt);
+    } else if (shift_value > kShifterLimit) {
+      // Result is 0.
+      __ xorq(left, left);
+    } else {
+      // Do the shift: (shift_value > 0) && (shift_value <= kShifterLimit).
+      switch (op_kind()) {
+        case Token::kSHR:
+          __ shrl(left, Immediate(shift_value));
+        break;
+        case Token::kSHL:
+          __ shll(left, Immediate(shift_value));
+        break;
+        default:
+          UNREACHABLE();
+      }
+    }
+    return;
+  }
+
+  // Non constant shift value.
+
+  Register shifter = locs()->in(1).reg();
+  ASSERT(shifter == RCX);
+
+  Label done;
+  Label zero;
+
+  // TODO(johnmccutchan): Use range information to avoid these checks.
+  __ SmiUntag(shifter);
+  __ cmpq(shifter, Immediate(0));
+  // If shift value is < 0, deoptimize.
+  __ j(NEGATIVE, deopt);
+  __ cmpq(shifter, Immediate(kShifterLimit));
+  // If shift value is >= 32, return zero.
+  __ j(ABOVE, &zero);
+
+  // Do the shift.
+  switch (op_kind()) {
+    case Token::kSHR:
+      __ shrl(left, shifter);
+      __ jmp(&done);
+    break;
+    case Token::kSHL:
+      __ shll(left, shifter);
+      __ jmp(&done);
+    break;
+    default:
+      UNREACHABLE();
+  }
+
+  __ Bind(&zero);
+  // Shift was greater than 31 bits, just return zero.
+  __ xorq(left, left);
+
+  // Exit path.
+  __ Bind(&done);
+}
+
+
+LocationSummary* UnaryUint32OpInstr::MakeLocationSummary(Isolate* isolate,
+                                                         bool opt) const {
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_out(0, Location::SameAsFirstInput());
+  return summary;
+}
+
+
+void UnaryUint32OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register out = locs()->out(0).reg();
+  ASSERT(locs()->in(0).reg() == out);
+
+  ASSERT(op_kind() == Token::kBIT_NOT);
+
+  __ notl(out);
+}
+
+
 DEFINE_UNIMPLEMENTED_INSTRUCTION(BinaryInt32OpInstr)
 
 
 LocationSummary* UnboxIntNInstr::MakeLocationSummary(Isolate* isolate,
                                                      bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = (!is_truncating() && CanDeoptimize()) ? 1 : 0;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
@@ skipping 71 matching lines @@
 }
 
 
 LocationSummary* UnboxedIntConverterInstr::MakeLocationSummary(Isolate* isolate,
                                                                bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   if (from() == kUnboxedMint) {
-    UNREACHABLE();
+    ASSERT((to() == kUnboxedUint32) || (to() == kUnboxedInt32));
+    summary->set_in(0, Location::RequiresRegister());
+    summary->set_out(0, Location::SameAsFirstInput());
   } else if (to() == kUnboxedMint) {
-    UNREACHABLE();
+    ASSERT((from() == kUnboxedInt32) || (from() == kUnboxedUint32));
+    summary->set_in(0, Location::RequiresRegister());
+    summary->set_out(0, Location::SameAsFirstInput());
   } else {
     ASSERT((to() == kUnboxedUint32) || (to() == kUnboxedInt32));
     ASSERT((from() == kUnboxedUint32) || (from() == kUnboxedInt32));
     summary->set_in(0, Location::RequiresRegister());
     summary->set_out(0, Location::SameAsFirstInput());
   }
   return summary;
 }
 
 
@@ skipping 11 matching lines @@
     const Register value = locs()->in(0).reg();
     const Register out = locs()->out(0).reg();
     __ movsxd(out, value);
     if (CanDeoptimize()) {
       Label* deopt =
           compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnboxInteger);
       __ testl(out, out);
       __ j(NEGATIVE, deopt);
     }
   } else if (from() == kUnboxedMint) {
-    UNREACHABLE();
+    ASSERT((to() == kUnboxedUint32) || (to() == kUnboxedInt32));
+    const Register value = locs()->in(0).reg();
+    const Register out = locs()->out(0).reg();
+    // Copy low.
+    __ movl(out, value);
+    if (CanDeoptimize()) {
+      Label* deopt =
+          compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnboxInteger);
+      // Sign extend.
+      __ movsxd(out, out);

[Vyacheslav Egorov (Google), 2014/10/05 18:47:00]

you could do __ movsxd(out, value) to begin with.

if (!CanDeoptimize()) {
  __ movl(out, value);
} else {
  __ movsxd(out, value);
  __ cmpq(...);
  ...
}

[Cutch, 2014/10/06 23:55:26]

Done.

+      // Compare with original value.
+      __ cmpq(out, value);
+      // Value cannot be held in Int32, deopt.
+      __ j(NOT_EQUAL, deopt);
+    }
   } else if (to() == kUnboxedMint) {
     ASSERT((from() == kUnboxedUint32) || (from() == kUnboxedInt32));
-    UNREACHABLE();
+    const Register value = locs()->in(0).reg();
+    const Register out = locs()->out(0).reg();
+    if (from() == kUnboxedUint32) {
+      // Zero extend.
+      __ movl(out, value);
+    } else {
+      // Sign extend.
+      ASSERT(from() == kUnboxedInt32);
+      __ movsxd(out, value);
+    }
   } else {
     UNREACHABLE();
   }
 }
 
 
 LocationSummary* ThrowInstr::MakeLocationSummary(Isolate* isolate,
                                                  bool opt) const {
   return new(isolate) LocationSummary(isolate, 0, 0, LocationSummary::kCall);
 }
@@ skipping 263 matching lines @@
   __ movq(R10, Immediate(kInvalidObjectPointer));
   __ movq(RBX, Immediate(kInvalidObjectPointer));
 #endif
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64