Implement mint unboxing on MIPS.

runtime/vm/intermediate_language_mips.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_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 52 matching lines @@
       ASSERT(value.IsStackSlot());
       const intptr_t value_offset = value.ToStackSlotOffset();
       __ LoadFromOffset(TMP, FP, value_offset);
       __ Push(TMP);
     }
   }
 }
 
 
 LocationSummary* ReturnInstr::MakeLocationSummary(Isolate* isolate,
-                                                         bool opt) const {
+                                                  bool opt) const {
   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::RegisterLocation(V0));
   return locs;
 }
 
 
 // Attempt optimized compilation at return instruction instead of at the entry.
@@ skipping 30 matching lines @@
 
 static Condition NegateCondition(Condition condition) {
   switch (condition) {
     case EQ: return NE;
     case NE: return EQ;
     case LT: return GE;
     case LE: return GT;
     case GT: return LE;
     case GE: return LT;
     default:
-      OS::Print("Error: Condition not recognized: %d\n", condition);
-      UNIMPLEMENTED();
+      UNREACHABLE();
       return EQ;
   }
 }
 
 
 // Detect pattern when one value is zero and another is a power of 2.
 static bool IsPowerOfTwoKind(intptr_t v1, intptr_t v2) {
   return (Utils::IsPowerOfTwo(v1) && (v2 == 0)) ||
          (Utils::IsPowerOfTwo(v2) && (v1 == 0));
 }
@@ skipping 135 matching lines @@
   return LocationSummary::Make(isolate,
                                0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("LoadLocalInstr");
   Register result = locs()->out(0).reg();
-  __ lw(result, Address(FP, local().index() * kWordSize));
+  __ LoadFromOffset(result, FP, local().index() * kWordSize);
 }
 
 
 LocationSummary* StoreLocalInstr::MakeLocationSummary(Isolate* isolate,
                                                       bool opt) const {
   return LocationSummary::Make(isolate,
                                1,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
 void StoreLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("StoreLocalInstr");
   Register value = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   ASSERT(result == value);  // Assert that register assignment is correct.
-  __ sw(value, Address(FP, local().index() * kWordSize));
+  __ StoreToOffset(value, FP, local().index() * kWordSize);
 }
 
 
 LocationSummary* ConstantInstr::MakeLocationSummary(Isolate* isolate,
                                                     bool opt) const {
   return LocationSummary::Make(isolate,
                                0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
@@ skipping 111 matching lines @@
   __ TraceSimMsg("AssertBooleanInstr");
   EmitAssertBoolean(obj, token_pos(), deopt_id(), locs(), compiler);
   ASSERT(obj == result);
 }
 
 
 LocationSummary* EqualityCompareInstr::MakeLocationSummary(Isolate* isolate,
                                                            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(isolate) LocationSummary(
         isolate, 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(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());
@@ skipping 99 matching lines @@
     // Fall through or jump to the true successor.
     if (labels.fall_through != labels.true_label) {
       __ b(labels.true_label);
     }
   }
 }
 
 
 static Condition EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                      const LocationSummary& locs,
-                                     Token::Kind kind,
-                                     BranchLabels labels) {
+                                     Token::Kind kind) {
   __ TraceSimMsg("EmitSmiComparisonOp");
   __ Comment("EmitSmiComparisonOp");
   Location left = locs.in(0);
   Location right = locs.in(1);
   ASSERT(!left.IsConstant() || !right.IsConstant());
 
   Condition true_condition = TokenKindToSmiCondition(kind);
 
   if (left.IsConstant()) {
     __ CompareObject(CMPRES1, CMPRES2, right.reg(), left.constant());
     true_condition = FlipCondition(true_condition);
   } else if (right.IsConstant()) {
     __ CompareObject(CMPRES1, CMPRES2, left.reg(), right.constant());
   } else {
     __ slt(CMPRES1, left.reg(), right.reg());
     __ slt(CMPRES2, right.reg(), left.reg());
   }
   return true_condition;
 }
 
 
+static Condition TokenKindToMintCondition(Token::Kind kind) {
+  switch (kind) {
+    case Token::kEQ: return EQ;
+    case Token::kNE: return NE;
+    case Token::kLT: return LT;
+    case Token::kGT: return GT;
+    case Token::kLTE: return LE;
+    case Token::kGTE: return GE;
+    default:
+      UNREACHABLE();
+      return VS;
+  }
+}
+
+
+static Condition EmitUnboxedMintEqualityOp(FlowGraphCompiler* compiler,
+                                           const LocationSummary& locs,
+                                           Token::Kind kind) {
+  __ TraceSimMsg("EmitUnboxedMintEqualityOp");
+  __ Comment("EmitUnboxedMintEqualityOp");
+  ASSERT(Token::IsEqualityOperator(kind));
+  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();
+
+  __ xor_(CMPRES1, left_lo, right_lo);
+  __ xor_(CMPRES2, left_hi, right_hi);
+  __ or_(CMPRES1, CMPRES1, CMPRES2);
+  __ mov(CMPRES2, ZR);
+  return TokenKindToMintCondition(kind);
+}
+
+
+static Condition EmitUnboxedMintComparisonOp(FlowGraphCompiler* compiler,
+                                             const LocationSummary& locs,
+                                             Token::Kind kind) {
+  __ TraceSimMsg("EmitUnboxedMintComparisonOp");
+  __ Comment("EmitUnboxedMintComparisonOp");
+  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();
+
+  Label done;
+  // Compare upper halves first.
+  __ slt(CMPRES1, left_hi, right_hi);
+  __ slt(CMPRES2, right_hi, left_hi);
+  // If higher words aren't equal, skip comparing lower words.
+  __ bne(CMPRES1, CMPRES2, &done);
+
+  __ sltu(CMPRES1, left_lo, right_lo);
+  __ sltu(CMPRES2, right_lo, left_lo);
+  __ Bind(&done);
+
+  return TokenKindToMintCondition(kind);
+}
+
+
 static Condition TokenKindToDoubleCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQ;
     case Token::kNE: return NE;
     case Token::kLT: return LT;
     case Token::kGT: return GT;
     case Token::kLTE: return LE;
     case Token::kGTE: return GE;
     default:
       UNREACHABLE();
@@ skipping 41 matching lines @@
     __ movt(CMPRES1, ZR);
   }
   __ mov(CMPRES2, ZR);
   return EQ;
 }
 
 
 Condition EqualityCompareInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                                    BranchLabels labels) {
   if (operation_cid() == kSmiCid) {
-    return EmitSmiComparisonOp(compiler, *locs(), kind(), labels);
+    return EmitSmiComparisonOp(compiler, *locs(), kind());
+  } else if (operation_cid() == kMintCid) {
+    return EmitUnboxedMintEqualityOp(compiler, *locs(), kind());
   } else {
     ASSERT(operation_cid() == kDoubleCid);
     return EmitDoubleComparisonOp(compiler, *locs(), kind(), labels);
   }
 }
 
 
 void EqualityCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
   __ Comment("EqualityCompareInstr");
@@ skipping 143 matching lines @@
   __ LoadObject(result_reg, Bool::True());
   __ Bind(&done);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary(Isolate* isolate,
                                                         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(isolate) LocationSummary(
         isolate, 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(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;
   }
   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);
+    return EmitSmiComparisonOp(compiler, *locs(), kind());
+  } else if (operation_cid() == kMintCid) {
+    return EmitUnboxedMintComparisonOp(compiler, *locs(), kind());
   } else {
     ASSERT(operation_cid() == kDoubleCid);
     return EmitDoubleComparisonOp(compiler, *locs(), kind(), labels);
   }
 }
 
 
 void RelationalOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("RelationalOpInstr");
 
@@ skipping 339 matching lines @@
       case kTypedDataFloat32x4ArrayCid:
         UNIMPLEMENTED();
         break;
     }
     return;
   }
 
   if ((representation() == kUnboxedUint32) ||
       (representation() == kUnboxedInt32)) {
     const Register result = locs()->out(0).reg();
+    if ((index_scale() == 1) && index.IsRegister()) {
+      __ SmiUntag(index.reg());
+    }
     switch (class_id()) {
       case kTypedDataInt32ArrayCid:
+        ASSERT(representation() == kUnboxedInt32);
+        __ lw(result, element_address);
+        break;
+      case kTypedDataUint32ArrayCid:
         ASSERT(representation() == kUnboxedUint32);
         __ lw(result, element_address);
         break;
-      case kTypedDataUint32ArrayCid:
-        ASSERT(representation() == kUnboxedInt32);
-        __ lw(result, element_address);
-        break;
       default:
         UNREACHABLE();
     }
     return;
   }
 
   ASSERT(representation() == kTagged);
 
   const Register result = locs()->out(0).reg();
   switch (class_id()) {
@@ skipping 168 matching lines @@
   const Register array = locs()->in(0).reg();
   const Location index = locs()->in(1);
 
   Address element_address = index.IsRegister()
       ? __ ElementAddressForRegIndex(false,  // Store.
                                      IsExternal(), class_id(), index_scale(),
                                      array, index.reg())
       : __ ElementAddressForIntIndex(
             IsExternal(), class_id(), index_scale(),
             array, Smi::Cast(index.constant()).Value());
+  ASSERT(element_address.base() != TMP);  // Allowed for load only.
 
   switch (class_id()) {
     case kArrayCid:
       if (ShouldEmitStoreBarrier()) {
         Register value = locs()->in(2).reg();
         __ StoreIntoObject(array, element_address, value);
       } else if (locs()->in(2).IsConstant()) {
         const Object& constant = locs()->in(2).constant();
         __ StoreIntoObjectNoBarrier(array, element_address, constant);
       } else {
@@ skipping 575 matching lines @@
 
 // When the parser is building an implicit static getter for optimization,
 // it can generate a function body where deoptimization ids do not line up
 // with the unoptimized code.
 //
 // This is safe only so long as LoadStaticFieldInstr cannot deoptimize.
 void LoadStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("LoadStaticFieldInstr");
   Register field = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
-  __ lw(result, FieldAddress(field, Field::value_offset()));
+  __ LoadFromOffset(result, field, Field::value_offset() - kHeapObjectTag);
 }
 
 
 LocationSummary* StoreStaticFieldInstr::MakeLocationSummary(Isolate* isolate,
                                                             bool opt) const {
   LocationSummary* locs = new(isolate) LocationSummary(
       isolate, 1, 1, LocationSummary::kNoCall);
   locs->set_in(0, value()->NeedsStoreBuffer() ? Location::WritableRegister()
                                               : Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
@@ skipping 568 matching lines @@
 
   // Restore SP from FP as we are coming from a throw and the code for
   // popping arguments has not been run.
   const intptr_t fp_sp_dist =
       (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
   ASSERT(fp_sp_dist <= 0);
   __ AddImmediate(SP, FP, fp_sp_dist);
 
   // Restore stack and initialize the two exception variables:
   // exception and stack trace variables.
-  __ sw(kExceptionObjectReg,
-        Address(FP, exception_var().index() * kWordSize));
-  __ sw(kStackTraceObjectReg,
-        Address(FP, stacktrace_var().index() * kWordSize));
+  __ StoreToOffset(kExceptionObjectReg,
+                   FP, exception_var().index() * kWordSize);
+  __ StoreToOffset(kStackTraceObjectReg,
+                   FP, stacktrace_var().index() * kWordSize);
 }
 
 
 LocationSummary* CheckStackOverflowInstr::MakeLocationSummary(Isolate* isolate,
                                                               bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs,
                           kNumTemps,
@@ skipping 555 matching lines @@
 }
 
 
 LocationSummary* UnboxInstr::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::RequiresFpuRegister());
+  if (representation() == kUnboxedMint) {
+    summary->set_out(0, Location::Pair(Location::RequiresRegister(),
+                                       Location::RequiresRegister()));
+  } else {
+    summary->set_out(0, Location::RequiresFpuRegister());
+  }
   return summary;
 }
 
 
 void UnboxInstr::EmitLoadFromBox(FlowGraphCompiler* compiler) {
   const Register box = locs()->in(0).reg();
 
   switch (representation()) {
     case kUnboxedMint: {
-      UNIMPLEMENTED();
+      PairLocation* result = locs()->out(0).AsPairLocation();
+      __ LoadFromOffset(result->At(0).reg(),
+                        box,
+                        ValueOffset() - kHeapObjectTag);
+      __ LoadFromOffset(result->At(1).reg(),
+                        box,
+                        ValueOffset() - kHeapObjectTag + kWordSize);
       break;
     }
 
     case kUnboxedDouble: {
       const DRegister result = locs()->out(0).fpu_reg();
       __ LoadDFromOffset(result, box, Double::value_offset() - kHeapObjectTag);
       break;
     }
 
     case kUnboxedFloat32x4:
     case kUnboxedFloat64x2:
     case kUnboxedInt32x4: {
       UNIMPLEMENTED();
       break;
     }
 
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 void UnboxInstr::EmitSmiConversion(FlowGraphCompiler* compiler) {
   const Register box = locs()->in(0).reg();
 
   switch (representation()) {
     case kUnboxedMint: {
-      UNIMPLEMENTED();
+      PairLocation* result = locs()->out(0).AsPairLocation();
+      __ SmiUntag(result->At(0).reg(), box);
+      __ sra(result->At(1).reg(), result->At(0).reg(), 31);
       break;
     }
 
     case kUnboxedDouble: {
       const DRegister result = locs()->out(0).fpu_reg();
       __ SmiUntag(TMP, box);
       __ mtc1(TMP, STMP1);
       __ cvtdw(result, STMP1);
       break;
     }
@@ skipping 55 matching lines @@
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void BoxInteger32Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register out = locs()->out(0).reg();
   ASSERT(value != out);
 
-  Label done;
   __ SmiTag(out, value);
   if (!ValueFitsSmi()) {
     Register temp = locs()->temp(0).reg();
+    Label done;
     if (from_representation() == kUnboxedInt32) {
       __ SmiUntag(CMPRES1, out);
       __ BranchEqual(CMPRES1, value, &done);
     } else {
       ASSERT(from_representation() == kUnboxedUint32);
       __ AndImmediate(CMPRES1, value, 0xC0000000);
       __ BranchEqual(CMPRES1, ZR, &done);
     }
     BoxAllocationSlowPath::Allocate(
         compiler,
@@ skipping 13 matching lines @@
                      out,
                      Mint::value_offset() - kHeapObjectTag);
     __ StoreToOffset(hi,
                      out,
                      Mint::value_offset() - kHeapObjectTag + kWordSize);
     __ Bind(&done);
   }
 }
 
 
-DEFINE_UNIMPLEMENTED_INSTRUCTION(BoxInt64Instr);
+LocationSummary* BoxInt64Instr::MakeLocationSummary(Isolate* isolate,
+                                                    bool opt) const {
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = ValueFitsSmi() ? 0 : 1;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate,
+      kNumInputs,
+      kNumTemps,
+      ValueFitsSmi() ? LocationSummary::kNoCall
+                     : LocationSummary::kCallOnSlowPath);
+  summary->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                    Location::RequiresRegister()));
+  if (!ValueFitsSmi()) {
+    summary->set_temp(0, Location::RequiresRegister());
+  }
+  summary->set_out(0, Location::RequiresRegister());
+  return summary;
+}
+
+
+void BoxInt64Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  if (ValueFitsSmi()) {
+    PairLocation* value_pair = locs()->in(0).AsPairLocation();
+    Register value_lo = value_pair->At(0).reg();
+    Register out_reg = locs()->out(0).reg();
+    __ SmiTag(out_reg, value_lo);
+    return;
+  }
+
+  PairLocation* value_pair = locs()->in(0).AsPairLocation();
+  Register value_lo = value_pair->At(0).reg();
+  Register value_hi = value_pair->At(1).reg();
+  Register tmp = locs()->temp(0).reg();
+  Register out_reg = locs()->out(0).reg();
+
+  Label not_smi, done;
+  __ SmiTag(out_reg, value_lo);
+  __ SmiUntag(tmp, out_reg);
+  __ bne(tmp, value_lo, &not_smi);
+  __ delay_slot()->sra(tmp, out_reg, 31);
+  __ beq(tmp, value_hi, &done);
+
+  __ Bind(&not_smi);
+  BoxAllocationSlowPath::Allocate(
+      compiler,
+      this,
+      compiler->mint_class(),
+      out_reg,
+      tmp);
+  __ StoreToOffset(value_lo, out_reg, Mint::value_offset() - kHeapObjectTag);
+  __ StoreToOffset(value_hi,
+                   out_reg,
+                   Mint::value_offset() - kHeapObjectTag + kWordSize);
+  __ Bind(&done);
+}
+
 
 LocationSummary* UnboxInteger32Instr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
   ASSERT((representation() == kUnboxedInt32) ||
          (representation() == kUnboxedUint32));
   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());
@@ skipping 1124 matching lines @@
                                  instance_call()->token_pos(),
                                  target,
                                  instance_call()->ArgumentCount(),
                                  instance_call()->argument_names(),
                                  locs(),
                                  ICData::Handle());
     return;
   }
 
   // Load receiver into T0.
-  __ lw(T0, Address(SP, (instance_call()->ArgumentCount() - 1) * kWordSize));
+  __ LoadFromOffset(T0, SP, (instance_call()->ArgumentCount() - 1) * kWordSize);
 
   Label* deopt = compiler->AddDeoptStub(
       deopt_id(), ICData::kDeoptPolymorphicInstanceCallTestFail);
   LoadValueCid(compiler, T2, T0,
                (ic_data().GetReceiverClassIdAt(0) == kSmiCid) ? NULL : deopt);
 
   compiler->EmitTestAndCall(ic_data(),
                             T2,  // Class id register.
                             instance_call()->ArgumentCount(),
                             instance_call()->argument_names(),
@@ skipping 183 matching lines @@
       __ BranchUnsignedGreaterEqual(
           index, Immediate(reinterpret_cast<int32_t>(length.raw())), deopt);
     }
   } else {
     Register length = length_loc.reg();
     Register index = index_loc.reg();
     __ BranchUnsignedGreaterEqual(index, length, deopt);
   }
 }
 
-DEFINE_UNIMPLEMENTED_INSTRUCTION(BinaryMintOpInstr);
+LocationSummary* BinaryMintOpInstr::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::Pair(Location::RequiresRegister(),
+                                    Location::RequiresRegister()));
+  summary->set_in(1, Location::Pair(Location::RequiresRegister(),
+                                    Location::RequiresRegister()));
+  summary->set_out(0, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+  return summary;
+}
+
+
+void BinaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  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();
+
+  Label* deopt = NULL;
+  if (CanDeoptimize()) {
+    deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryMintOp);
+  }
+  switch (op_kind()) {
+    case Token::kBIT_AND: {
+      __ and_(out_lo, left_lo, right_lo);
+      __ and_(out_hi, left_hi, right_hi);
+      break;
+    }
+    case Token::kBIT_OR: {
+      __ or_(out_lo, left_lo, right_lo);
+      __ or_(out_hi, left_hi, right_hi);
+      break;
+    }
+    case Token::kBIT_XOR: {
+     __ xor_(out_lo, left_lo, right_lo);
+     __ xor_(out_hi, left_hi, right_hi);
+     break;
+    }
+    case Token::kADD:
+    case Token::kSUB: {
+      if (op_kind() == Token::kADD) {
+        __ addu(out_lo, left_lo, right_lo);
+        __ sltu(TMP, out_lo, left_lo);  // TMP = carry of left_lo + right_lo.
+        __ addu(out_hi, left_hi, right_hi);
+        __ addu(out_hi, out_hi, TMP);
+        if (can_overflow()) {
+          __ xor_(CMPRES1, out_hi, left_hi);
+          __ xor_(TMP, out_hi, right_hi);
+          __ and_(CMPRES1, TMP, CMPRES1);
+          __ bltz(CMPRES1, deopt);
+        }
+      } else {
+        __ subu(out_lo, left_lo, right_lo);
+        __ sltu(TMP, left_lo, out_lo);  // TMP = borrow of left_lo - right_lo.
+        __ subu(out_hi, left_hi, right_hi);
+        __ subu(out_hi, out_hi, TMP);
+        if (can_overflow()) {
+          __ xor_(CMPRES1, out_hi, left_hi);
+          __ xor_(TMP, left_hi, right_hi);
+          __ and_(CMPRES1, TMP, CMPRES1);
+          __ bltz(CMPRES1, deopt);
+        }
+      }
+      break;
+    }
+    case Token::kMUL: {
+      // The product of two signed 32-bit integers fits in a signed 64-bit
+      // result without causing overflow.
+      // We deopt on larger inputs.
+      // TODO(regis): Range analysis may eliminate the deopt check.
+      __ sra(CMPRES1, left_lo, 31);
+      __ bne(CMPRES1, left_hi, deopt);
+      __ delay_slot()->sra(CMPRES2, right_lo, 31);
+      __ bne(CMPRES2, right_hi, deopt);
+      __ delay_slot()->mult(left_lo, right_lo);
+      __ mflo(out_lo);
+      __ mfhi(out_hi);
+      break;
+    }
+    default:
+      UNREACHABLE();
+  }
+}
+
+
+LocationSummary* ShiftMintOpInstr::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::Pair(Location::RequiresRegister(),
+                                    Location::RequiresRegister()));
+  summary->set_in(1, Location::WritableRegisterOrSmiConstant(right()));
+  summary->set_out(0, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+  return summary;
+}
+
+
+static const intptr_t kMintShiftCountLimit = 63;
 
 bool ShiftMintOpInstr::has_shift_count_check() const {
-  UNREACHABLE();
-  return false;
-}
-
-DEFINE_UNIMPLEMENTED_INSTRUCTION(ShiftMintOpInstr);
-DEFINE_UNIMPLEMENTED_INSTRUCTION(UnaryMintOpInstr);
+  return !RangeUtils::IsWithin(
+      right()->definition()->range(), 0, kMintShiftCountLimit);
+}
+
+
+void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  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();
+
+  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 int32_t shift =
+        reinterpret_cast<int32_t>(locs()->in(1).constant().raw()) >> 1;
+    switch (op_kind()) {
+      case Token::kSHR: {
+        if (shift < 32) {
+          __ sll(out_lo, left_hi, 32 - shift);
+          __ srl(TMP, left_lo, shift);
+          __ or_(out_lo, out_lo, TMP);
+          __ sra(out_hi, left_hi, shift);
+        } else {
+          __ sra(out_lo, left_hi, shift - 32);
+          __ sra(out_hi, left_hi, 31);
+        }
+        break;
+      }
+      case Token::kSHL: {
+        if (shift < 32) {
+          __ srl(out_hi, left_lo, 32 - shift);
+          __ sll(TMP, left_hi, shift);
+          __ or_(out_hi, out_hi, TMP);
+          __ sll(out_lo, left_lo, shift);
+        } else {
+          __ sll(out_hi, left_lo, shift - 32);
+          __ mov(out_lo, ZR);
+        }
+        // Check for overflow.
+        if (can_overflow()) {
+          // Compare high word from input with shifted high word from output.
+          // Overflow if they aren't equal.
+          // If shift > 32, also compare low word from input with high word from
+          // output shifted back shift - 32.
+          if (shift > 32) {
+            __ sra(TMP, out_hi, shift - 32);
+            __ bne(left_lo, TMP, deopt);
+            __ delay_slot()->sra(TMP, out_hi, 31);
+          } else if (shift == 32) {
+            __ sra(TMP, out_hi, 31);
+          } else {
+            __ sra(TMP, out_hi, shift);
+          }
+          __ bne(left_hi, TMP, deopt);
+        }
+        break;
+      }
+      default:
+        UNREACHABLE();
+    }
+  } else {
+    // Code for a variable shift amount.
+    Register shift = locs()->in(1).reg();
+
+    // Deopt if shift is larger than 63 or less than 0.
+    if (has_shift_count_check()) {
+      __ sltiu(CMPRES1, shift, Immediate(2*(kMintShiftCountLimit + 1)));
+      __ beq(CMPRES1, ZR, deopt);
+      // Untag shift count.
+      __ delay_slot()->SmiUntag(shift);
+    } else {
+      // Untag shift count.
+      __ SmiUntag(shift);
+    }
+
+    switch (op_kind()) {
+      case Token::kSHR: {
+        Label large_shift, done;
+        __ sltiu(CMPRES1, shift, Immediate(32));
+        __ beq(CMPRES1, ZR, &large_shift);
+
+        // shift < 32.
+        __ delay_slot()->ori(TMP, ZR, Immediate(32));
+        __ subu(TMP, TMP, shift);  // TMP = 32 - shift; 0 < TMP <= 31.
+        __ sllv(out_lo, left_hi, TMP);
+        __ srlv(TMP, left_lo, shift);
+        __ or_(out_lo, out_lo, TMP);
+        __ b(&done);
+        __ delay_slot()->srav(out_hi, left_hi, shift);
+
+        // shift >= 32.
+        __ Bind(&large_shift);
+        __ sra(out_hi, left_hi, 31);
+        __ srav(out_lo, left_hi, shift);  // Only 5 low bits of shift used.
+
+        __ Bind(&done);
+        break;
+      }
+      case Token::kSHL: {
+        Label large_shift, done;
+        __ sltiu(CMPRES1, shift, Immediate(32));
+        __ beq(CMPRES1, ZR, &large_shift);
+
+        // shift < 32.
+        __ delay_slot()->ori(TMP, ZR, Immediate(32));
+        __ subu(TMP, TMP, shift);  // TMP = 32 - shift; 0 < TMP <= 31.
+        __ srlv(out_hi, left_lo, TMP);
+        __ sllv(TMP, left_hi, shift);
+        __ or_(out_hi, out_hi, TMP);
+        // Check for overflow.
+        if (can_overflow()) {
+          // Compare high word from input with shifted high word from output.
+          __ srav(TMP, out_hi, shift);
+          __ beq(TMP, left_hi, &done);
+          __ delay_slot()->sllv(out_lo, left_lo, shift);
+          __ b(deopt);
+        } else {
+          __ b(&done);
+          __ delay_slot()->sllv(out_lo, left_lo, shift);
+        }
+
+        // shift >= 32.
+        __ Bind(&large_shift);
+        __ sllv(out_hi, left_lo, shift);  // Only 5 low bits of shift used.
+        // Check for overflow.
+        if (can_overflow()) {
+          // Compare low word from input with shifted high word from output and
+          // high word from input to sign of output.
+          // Overflow if they aren't equal.
+          __ srav(TMP, out_hi, shift);
+          __ bne(TMP, left_lo, deopt);
+          __ delay_slot()->sra(TMP, out_hi, 31);
+          __ bne(TMP, left_hi, deopt);
+          __ delay_slot()->mov(out_lo, ZR);
+        } else {
+          __ mov(out_lo, ZR);
+        }
+        __ Bind(&done);
+        break;
+      }
+      default:
+        UNREACHABLE();
+    }
+  }
+}
+
+
+LocationSummary* UnaryMintOpInstr::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::Pair(Location::RequiresRegister(),
+                                    Location::RequiresRegister()));
+  summary->set_out(0, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+  return summary;
+}
+
+
+void UnaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ASSERT(op_kind() == Token::kBIT_NOT);
+  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();
+
+  __ nor(out_lo, ZR, left_lo);
+  __ nor(out_hi, ZR, left_hi);
+}
+
 
 CompileType BinaryUint32OpInstr::ComputeType() const {
   return CompileType::Int();
 }
 
 
 CompileType ShiftUint32OpInstr::ComputeType() const {
   return CompileType::Int();
 }
 
 
 CompileType UnaryUint32OpInstr::ComputeType() const {
   return CompileType::Int();
 }
 
 
-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 = 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::RequiresRegister());
+  return summary;
+}
+
+
+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:
+      __ and_(out, left, right);
+      break;
+    case Token::kBIT_OR:
+      __ or_(out, left, right);
+      break;
+    case Token::kBIT_XOR:
+      __ xor_(out, left, right);
+      break;
+    case Token::kADD:
+      __ addu(out, left, right);
+      break;
+    case Token::kSUB:
+      __ subu(out, left, right);
+      break;
+    case Token::kMUL:
+      __ multu(left, right);
+      __ mflo(out);
+      break;
+    default:
+      UNREACHABLE();
+  }
+}
+
+
+LocationSummary* ShiftUint32OpInstr::MakeLocationSummary(Isolate* isolate,
+                                                         bool opt) const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 1;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_in(1, Location::RegisterOrSmiConstant(right()));
+  summary->set_temp(0, Location::RequiresRegister());
+  summary->set_out(0, Location::RequiresRegister());
+  return summary;
+}
+
+
+void ShiftUint32OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  const intptr_t kShifterLimit = 31;
+
+  Register left = locs()->in(0).reg();
+  Register out = locs()->out(0).reg();
+  Register temp = locs()->temp(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();
+
+    // Do the shift: (shift_value > 0) && (shift_value <= kShifterLimit).
+    switch (op_kind()) {
+      case Token::kSHR:
+        __ srl(out, left, shift_value);
+        break;
+      case Token::kSHL:
+        __ sll(out, left, shift_value);
+        break;
+      default:
+        UNREACHABLE();
+    }
+    return;
+  }
+
+  // Non constant shift value.
+  Register shifter = locs()->in(1).reg();
+
+  __ SmiUntag(temp, shifter);
+  // If shift value is < 0, deoptimize.
+  __ bltz(temp, deopt);
+  __ delay_slot()->mov(out, left);
+  __ sltiu(CMPRES1, temp, Immediate(kShifterLimit + 1));
+  __ movz(out, ZR, CMPRES1);  // out = shift > kShifterLimit ? 0 : left.
+  // Do the shift % 32.
+  switch (op_kind()) {
+    case Token::kSHR:
+      __ srlv(out, out, temp);
+      break;
+    case Token::kSHL:
+      __ sllv(out, out, temp);
+      break;
+    default:
+      UNREACHABLE();
+  }
+}
+
+
+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::RequiresRegister());
+  return summary;
+}
+
+
+void UnaryUint32OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register left = locs()->in(0).reg();
+  Register out = locs()->out(0).reg();
+  ASSERT(left != out);
+
+  ASSERT(op_kind() == Token::kBIT_NOT);
+
+  __ nor(out, ZR, left);
+}
+
+
 DEFINE_UNIMPLEMENTED_INSTRUCTION(BinaryInt32OpInstr)
 
 
 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::Pair(Location::RequiresRegister(),
+                                      Location::RequiresRegister()));
+    summary->set_out(0, Location::RequiresRegister());
   } else if (to() == kUnboxedMint) {
-    UNREACHABLE();
+    ASSERT((from() == kUnboxedUint32) || (from() == kUnboxedInt32));
+    summary->set_in(0, Location::RequiresRegister());
+    summary->set_out(0, Location::Pair(Location::RequiresRegister(),
+                                       Location::RequiresRegister()));
   } 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;
 }
 
 
 void UnboxedIntConverterInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (from() == kUnboxedInt32 && to() == kUnboxedUint32) {
     const Register out = locs()->out(0).reg();
     // Representations are bitwise equivalent.
     ASSERT(out == locs()->in(0).reg());
   } else if (from() == kUnboxedUint32 && to() == kUnboxedInt32) {
     const Register out = locs()->out(0).reg();
     // Representations are bitwise equivalent.
     ASSERT(out == locs()->in(0).reg());
     if (CanDeoptimize()) {
       Label* deopt =
           compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnboxInteger);
       __ BranchSignedLess(out, Immediate(0), deopt);
     }
   } else if (from() == kUnboxedMint) {
-    UNREACHABLE();
-  } else if (to() == kUnboxedMint) {
-    ASSERT(from() == kUnboxedUint32 || from() == kUnboxedInt32);
-    UNREACHABLE();
+    ASSERT(to() == kUnboxedUint32 || to() == kUnboxedInt32);
+    PairLocation* in_pair = locs()->in(0).AsPairLocation();
+    Register in_lo = in_pair->At(0).reg();
+    Register in_hi = in_pair->At(1).reg();
+    Register out = locs()->out(0).reg();
+    // Copy low word.
+    __ mov(out, in_lo);
+    if (CanDeoptimize()) {
+      Label* deopt =
+          compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnboxInteger);
+      ASSERT(to() == kUnboxedInt32);
+      __ sra(TMP, in_lo, 31);
+      __ bne(in_hi, TMP, deopt);
+    }
+  } else if (from() == kUnboxedUint32 || from() == kUnboxedInt32) {
+    ASSERT(to() == kUnboxedMint);
+    Register in = locs()->in(0).reg();
+    PairLocation* out_pair = locs()->out(0).AsPairLocation();
+    Register out_lo = out_pair->At(0).reg();
+    Register out_hi = out_pair->At(1).reg();
+    // Copy low word.
+    __ mov(out_lo, in);
+    if (from() == kUnboxedUint32) {
+      __ xor_(out_hi, out_hi, out_hi);
+    } else {
+      ASSERT(from() == kUnboxedInt32);
+      __ sra(out_hi, in, 31);
+    }
   } else {
     UNREACHABLE();
   }
 }
 
 
 LocationSummary* ThrowInstr::MakeLocationSummary(Isolate* isolate,
                                                  bool opt) const {
   return new(isolate) LocationSummary(isolate, 0, 0, LocationSummary::kCall);
 }
@@ skipping 231 matching lines @@
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ LoadImmediate(S4, kInvalidObjectPointer);
   __ LoadImmediate(S5, kInvalidObjectPointer);
 #endif
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS