Implements far branch targets for 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 "lib/error.h"
@@ skipping 76 matching lines @@
   // A finally clause may leave a previously pushed return value if it
   // has its own return instruction. Method that have finally are currently
   // not optimized.
   if (!compiler->HasFinally()) {
     Label stack_ok;
     __ Comment("Stack Check");
     __ TraceSimMsg("Stack Check");
     const intptr_t fp_sp_dist =
         (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
     ASSERT(fp_sp_dist <= 0);
-    __ subu(TMP1, SP, FP);
+    __ subu(CMPRES1, SP, FP);
 
-    __ BranchEqual(TMP1, fp_sp_dist, &stack_ok);
+    __ BranchEqual(CMPRES1, fp_sp_dist, &stack_ok);
     __ break_(0);
 
     __ Bind(&stack_ok);
   }
 #endif
   // This sequence is patched by a debugger breakpoint. There is no need for
   // extra NOP instructions here because the sequence patched in for a
   // breakpoint is shorter than the sequence here.
   __ LeaveDartFrameAndReturn();
   compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
@@ skipping 242 matching lines @@
   }
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Object::null_array();
   const int kNumArgumentsChecked = 2;
 
   __ TraceSimMsg("EmitEqualityAsInstanceCall");
   __ Comment("EmitEqualityAsInstanceCall");
   Label check_identity;
   __ lw(A1, Address(SP, 1 * kWordSize));
   __ lw(A0, Address(SP, 0 * kWordSize));
-  __ LoadImmediate(TMP, reinterpret_cast<int32_t>(Object::null()));
-  __ beq(A1, TMP, &check_identity);
-  __ beq(A0, TMP, &check_identity);
+  __ LoadImmediate(CMPRES1, reinterpret_cast<int32_t>(Object::null()));
+  __ beq(A1, CMPRES1, &check_identity);
+  __ beq(A0, CMPRES1, &check_identity);
 
   ICData& equality_ic_data = ICData::ZoneHandle();
   if (compiler->is_optimizing() && FLAG_propagate_ic_data) {
     ASSERT(!original_ic_data.IsNull());
     if (original_ic_data.NumberOfChecks() == 0) {
       // IC call for reoptimization populates original ICData.
       equality_ic_data = original_ic_data.raw();
     } else {
       // Megamorphic call.
       equality_ic_data = original_ic_data.AsUnaryClassChecks();
@@ skipping 64 matching lines @@
 
 static void LoadValueCid(FlowGraphCompiler* compiler,
                          Register value_cid_reg,
                          Register value_reg,
                          Label* value_is_smi = NULL) {
   __ TraceSimMsg("LoadValueCid");
   Label done;
   if (value_is_smi == NULL) {
     __ LoadImmediate(value_cid_reg, kSmiCid);
   }
-  __ andi(TMP1, value_reg, Immediate(kSmiTagMask));
+  __ andi(CMPRES1, value_reg, Immediate(kSmiTagMask));
   if (value_is_smi == NULL) {
-    __ beq(TMP1, ZR, &done);
+    __ beq(CMPRES1, ZR, &done);
   } else {
-    __ beq(TMP1, ZR, value_is_smi);
+    __ beq(CMPRES1, ZR, value_is_smi);
   }
   __ LoadClassId(value_cid_reg, value_reg);
   __ Bind(&done);
 }
 
 
 static Condition TokenKindToSmiCondition(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;
   }
 }
 
 
-// Branches on condition c assuming comparison results in CMPRES and TMP1.
+// Branches on condition c assuming comparison results in CMPRES and CMPRES2.
 static void EmitBranchAfterCompare(
     FlowGraphCompiler* compiler, Condition c, Label* is_true) {
   switch (c) {
-    case EQ: __ beq(CMPRES, TMP1, is_true); break;
-    case NE: __ bne(CMPRES, TMP1, is_true); break;
-    case GT: __ bne(TMP1, ZR, is_true); break;
-    case GE: __ beq(CMPRES, ZR, is_true); break;
-    case LT: __ bne(CMPRES, ZR, is_true); break;
-    case LE: __ beq(TMP1, ZR, is_true); break;
+    case EQ: __ beq(CMPRES1, CMPRES2, is_true); break;
+    case NE: __ bne(CMPRES1, CMPRES2, is_true); break;
+    case GT: __ bne(CMPRES2, ZR, is_true); break;
+    case GE: __ beq(CMPRES1, ZR, is_true); break;
+    case LT: __ bne(CMPRES1, ZR, is_true); break;
+    case LE: __ beq(CMPRES2, ZR, is_true); break;
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 // A1: left, also on stack.
 // A0: right, also on stack.
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
@@ skipping 30 matching lines @@
     Label next_test;
     if (i < len - 1) {
       __ BranchNotEqual(temp, ic_data.GetReceiverClassIdAt(i), &next_test);
     } else {
       __ BranchNotEqual(temp, ic_data.GetReceiverClassIdAt(i), deopt);
     }
     const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(i));
     if (target.Owner() == object_store->object_class()) {
       // Object.== is same as ===.
       __ Drop(2);
-      __ slt(CMPRES, left, right);
-      __ slt(TMP1, right, left);
+      __ slt(CMPRES1, left, right);
+      __ slt(CMPRES2, right, left);
       if (branch != NULL) {
         branch->EmitBranchOnCondition(compiler, cond);
       } else {
         Register result = locs->out().reg();
         Label load_true;
         EmitBranchAfterCompare(compiler, cond, &load_true);
         __ LoadObject(result, Bool::False());
         __ b(&done);
         __ Bind(&load_true);
         __ LoadObject(result, Bool::True());
       }
     } else {
       const int kNumberOfArguments = 2;
       const Array& kNoArgumentNames = Object::null_array();
       compiler->GenerateStaticCall(deopt_id,
                                    token_pos,
                                    target,
                                    kNumberOfArguments,
                                    kNoArgumentNames,
                                    locs);
       if (branch == NULL) {
         if (kind == Token::kNE) {
           Label is_true;
-          __ CompareObject(CMPRES, TMP1, V0, Bool::True());
-          __ beq(CMPRES, TMP1, &is_true);
+          __ CompareObject(CMPRES1, CMPRES2, V0, Bool::True());
+          __ beq(CMPRES, CMPRES2, &is_true);
           __ LoadObject(V0, Bool::True());
           __ b(&done);
           __ Bind(&is_true);
           __ LoadObject(V0, Bool::False());
         }
       } else {
         if (branch->is_checked()) {
           EmitAssertBoolean(V0, token_pos, deopt_id, locs, compiler);
         }
-        __ CompareObject(CMPRES, TMP1, V0, Bool::True());
+        __ CompareObject(CMPRES1, CMPRES2, V0, Bool::True());
         branch->EmitBranchOnCondition(compiler, cond);
       }
     }
     if (i < len - 1) {
       __ b(&done);
       __ Bind(&next_test);
     }
   }
   __ Bind(&done);
 }
@@ skipping 11 matching lines @@
   Register right = locs.in(1).reg();
   Register temp = locs.temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id, kDeoptEquality);
 
   __ Comment("CheckedStrictEqual");
 
   __ andi(CMPRES, left, Immediate(kSmiTagMask));
   __ beq(CMPRES, ZR, deopt);
   // 'left' is not Smi.
   Label identity_compare;
-  __ LoadImmediate(TMP, reinterpret_cast<int32_t>(Object::null()));
-  __ beq(right, TMP, &identity_compare);
-  __ beq(left, TMP, &identity_compare);
+  __ LoadImmediate(CMPRES1, reinterpret_cast<int32_t>(Object::null()));
+  __ beq(right, CMPRES1, &identity_compare);
+  __ beq(left, CMPRES1, &identity_compare);
 
   __ LoadClassId(temp, left);
   const ICData& ic_data = ICData::Handle(orig_ic_data.AsUnaryClassChecks());
   const intptr_t len = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     if (i == (len - 1)) {
       __ BranchNotEqual(temp, ic_data.GetReceiverClassIdAt(i), deopt);
     } else {
       __ BranchEqual(temp, ic_data.GetReceiverClassIdAt(i), &identity_compare);
     }
   }
   __ Bind(&identity_compare);
-  __ subu(CMPRES, left, right);
+  __ subu(CMPRES1, left, right);
   if (branch == NULL) {
     Label done, is_equal;
     Register result = locs.out().reg();
     __ beq(CMPRES, ZR, &is_equal);
     // Not equal.
     __ LoadObject(result,
                   (kind == Token::kEQ) ? Bool::False() : Bool::True());
     __ b(&done);
     __ Bind(&is_equal);
     __ LoadObject(result,
                   (kind == Token::kEQ) ? Bool::True() : Bool::False());
     __ Bind(&done);
 
   } else {
     Condition cond = TokenKindToSmiCondition(kind);
-    __ mov(TMP, ZR);
+    __ mov(CMPRES2, ZR);
     branch->EmitBranchOnCondition(compiler, cond);
   }
 }
 
 
 // First test if receiver is NULL, in which case === is applied.
 // If type feedback was provided (lists of <class-id, target>), do a
 // type by type check (either === or static call to the operator.
 static void EmitGenericEqualityCompare(FlowGraphCompiler* compiler,
                                        LocationSummary* locs,
                                        Token::Kind kind,
                                        BranchInstr* branch,
                                        const ICData& ic_data,
                                        intptr_t deopt_id,
                                        intptr_t token_pos) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
   Register left = locs->in(0).reg();
   Register right = locs->in(1).reg();
   Label done, identity_compare, non_null_compare;
   __ TraceSimMsg("EmitGenericEqualityCompare");
   __ Comment("EmitGenericEqualityCompare");
-  __ LoadImmediate(TMP, reinterpret_cast<int32_t>(Object::null()));
-  __ beq(right, TMP, &identity_compare);
-  __ bne(left, TMP, &non_null_compare);
+  __ LoadImmediate(CMPRES1, reinterpret_cast<int32_t>(Object::null()));
+  __ beq(right, CMPRES1, &identity_compare);
+  __ bne(left, CMPRES1, &non_null_compare);
 
   // Comparison with NULL is "===".
   __ Bind(&identity_compare);
   Condition cond = TokenKindToSmiCondition(kind);
-  __ slt(CMPRES, left, right);
-  __ slt(TMP1, right, left);
+  __ slt(CMPRES1, left, right);
+  __ slt(CMPRES2, right, left);
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, cond);
   } else {
     Register result = locs->out().reg();
     Label load_true;
     EmitBranchAfterCompare(compiler, cond, &load_true);
     __ LoadObject(result, Bool::False());
     __ b(&done);
     __ Bind(&load_true);
     __ LoadObject(result, Bool::True());
@@ skipping 32 matching lines @@
                                 BranchInstr* branch) {
   __ 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(CMPRES, TMP1, right.reg(), left.constant());
+    __ CompareObject(CMPRES1, CMPRES2, right.reg(), left.constant());
     true_condition = FlipCondition(true_condition);
   } else if (right.IsConstant()) {
-    __ CompareObject(CMPRES, TMP1, left.reg(), right.constant());
+    __ CompareObject(CMPRES1, CMPRES2, left.reg(), right.constant());
   } else {
-    __ slt(CMPRES, left.reg(), right.reg());
-    __ slt(TMP1, right.reg(), left.reg());
+    __ slt(CMPRES1, left.reg(), right.reg());
+    __ slt(CMPRES2, right.reg(), left.reg());
   }
 
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, true_condition);
   } else {
     Register result = locs.out().reg();
     Label done, is_true;
     EmitBranchAfterCompare(compiler, true_condition, &is_true);
     __ LoadObject(result, Bool::False());
     __ b(&done);
@@ skipping 136 matching lines @@
   EmitEqualityAsInstanceCall(compiler,
                              deopt_id(),
                              token_pos(),
                              Token::kEQ,  // kNE reverse occurs at branch.
                              locs(),
                              *ic_data());
   if (branch->is_checked()) {
     EmitAssertBoolean(V0, token_pos(), deopt_id(), locs(), compiler);
   }
   Condition branch_condition = (kind() == Token::kNE) ? NE : EQ;
-  __ CompareObject(CMPRES, TMP1, V0, Bool::True());
+  __ CompareObject(CMPRES1, CMPRES2, V0, Bool::True());
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (operation_cid() == kMintCid) {
     const intptr_t kNumTemps = 2;
     LocationSummary* locs =
@@ skipping 119 matching lines @@
   }
   if (operation_cid() == kMintCid) {
     EmitUnboxedMintComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   if (operation_cid() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   EmitNativeCode(compiler);
-  __ CompareObject(CMPRES, TMP1, V0, Bool::True());
+  __ CompareObject(CMPRES1, CMPRES2, V0, Bool::True());
   branch->EmitBranchOnCondition(compiler, EQ);
 }
 
 
 LocationSummary* NativeCallInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 3;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(A1));
@@ skipping 592 matching lines @@
 
     if (value_cid == kDynamicCid) {
       if (value_cid_reg == kNoRegister) {
         ASSERT(!compiler->is_optimizing());
         value_cid_reg = A1;
         ASSERT((value_cid_reg != value_reg) && (field_reg != value_cid_reg));
       }
 
       LoadValueCid(compiler, value_cid_reg, value_reg);
 
-      __ lw(TMP1, field_cid_operand);
-      __ beq(value_cid_reg, TMP1, &ok);
+      __ lw(CMPRES1, field_cid_operand);
+      __ beq(value_cid_reg, CMPRES1, &ok);
       __ lw(TMP1, field_nullability_operand);
       __ subu(CMPRES, value_cid_reg, TMP1);
     } else if (value_cid == kNullCid) {
       // TODO(regis): TMP1 may conflict. Revisit.
       __ lw(TMP1, field_nullability_operand);
       __ LoadImmediate(CMPRES, value_cid);
       __ subu(CMPRES, TMP1, CMPRES);
     } else {
       // TODO(regis): TMP1 may conflict. Revisit.
       __ lw(TMP1, field_cid_operand);
       __ LoadImmediate(CMPRES, value_cid);
       __ subu(CMPRES, TMP1, CMPRES);
     }
     __ beq(CMPRES, ZR, &ok);
 
-    __ lw(TMP1, field_cid_operand);
-    __ BranchNotEqual(TMP1, kIllegalCid, fail);
+    __ lw(CMPRES1, field_cid_operand);
+    __ BranchNotEqual(CMPRES1, kIllegalCid, fail);
 
     if (value_cid == kDynamicCid) {
       __ sw(value_cid_reg, field_cid_operand);
       __ sw(value_cid_reg, field_nullability_operand);
     } else {
       __ LoadImmediate(TMP1, value_cid);
       __ sw(TMP1, field_cid_operand);
       __ sw(TMP1, field_nullability_operand);
     }
 
@@ skipping 34 matching lines @@
         ASSERT(!compiler->is_optimizing());
         return;
       }
     }
   }
 
   if (deopt == NULL) {
     ASSERT(!compiler->is_optimizing());
     __ Bind(fail);
 
-    __ lw(TMP1, FieldAddress(field_reg, Field::guarded_cid_offset()));
-    __ BranchEqual(TMP1, kDynamicCid, &ok);
+    __ lw(CMPRES1, FieldAddress(field_reg, Field::guarded_cid_offset()));
+    __ BranchEqual(CMPRES1, kDynamicCid, &ok);
 
     __ addiu(SP, SP, Immediate(-2 * kWordSize));
     __ sw(field_reg, Address(SP, 1 * kWordSize));
     __ sw(value_reg, Address(SP, 0 * kWordSize));
     __ CallRuntime(kUpdateFieldCidRuntimeEntry);
     __ Drop(2);  // Drop the field and the value.
   }
 
   __ Bind(&ok);
 }
@@ skipping 418 matching lines @@
   __ AddImmediate(SP, FP, fp_sp_dist);
 
   ASSERT(!exception_var().is_captured());
   ASSERT(!stacktrace_var().is_captured());
 
   __ sw(kExceptionObjectReg,
         Address(FP, exception_var().index() * kWordSize));
   __ sw(kStackTraceObjectReg,
         Address(FP, stacktrace_var().index() * kWordSize));
 
-  Label next;
-  __ mov(TMP, RA);  // Save return adress.
-  // Restore the pool pointer.
-  __ bal(&next);  // Branch and link to next instruction to get PC in RA.
-  __ delay_slot()->mov(CMPRES, RA);  // Save PC of the following mov.
+  __ GetNextPC(CMPRES, true);
 
   // Calculate offset of pool pointer from the PC.
   const intptr_t object_pool_pc_dist =
      Instructions::HeaderSize() - Instructions::object_pool_offset() +
-     compiler->assembler()->CodeSize();
+     compiler->assembler()->CodeSize() - 1 * Instr::kInstrSize;
 
-  __ Bind(&next);
-  __ mov(RA, TMP);  // Restore return address.
-  __ lw(PP, Address(CMPRES, -object_pool_pc_dist));
+  __ LoadFromOffset(PP, CMPRES, -object_pool_pc_dist);
 }
 
 
 LocationSummary* CheckStackOverflowInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs,
                           kNumTemps,
                           LocationSummary::kCallOnSlowPath);
@@ skipping 37 matching lines @@
 };
 
 
 void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("CheckStackOverflowInstr");
   CheckStackOverflowSlowPath* slow_path = new CheckStackOverflowSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   __ LoadImmediate(TMP1, Isolate::Current()->stack_limit_address());
 
-  __ lw(TMP1, Address(TMP1));
-  __ BranchUnsignedLessEqual(SP, TMP1, slow_path->entry_label());
+  __ lw(CMPRES1, Address(TMP1));
+  __ BranchUnsignedLessEqual(SP, CMPRES1, slow_path->entry_label());
   if (compiler->CanOSRFunction() && in_loop()) {
     Register temp = locs()->temp(0).reg();
     // In unoptimized code check the usage counter to trigger OSR at loop
     // stack checks.  Use progressively higher thresholds for more deeply
     // nested loops to attempt to hit outer loops with OSR when possible.
     __ LoadObject(temp, compiler->parsed_function().function());
     intptr_t threshold =
         FLAG_optimization_counter_threshold * (loop_depth() + 1);
     __ lw(temp, FieldAddress(temp, Function::usage_counter_offset()));
     __ BranchSignedGreaterEqual(temp, threshold, slow_path->entry_label());
@@ skipping 29 matching lines @@
       if ((value >= kCountLimit) && is_truncating) {
         __ mov(result, ZR);
       } else {
         // Result is Mint or exception.
         __ b(deopt);
       }
     } else {
       if (!is_truncating) {
         // Check for overflow (preserve left).
         __ sll(TMP1, left, value);
-        __ sra(TMP1, TMP1, value);
-        __ bne(TMP1, left, deopt);  // Overflow.
+        __ sra(CMPRES1, TMP1, value);
+        __ bne(CMPRES1, left, deopt);  // Overflow.
       }
       // Shift for result now we know there is no overflow.
       __ sll(result, left, value);
     }
     return;
   }
 
   // Right (locs.in(1)) is not constant.
   Register right = locs.in(1).reg();
   Range* right_range = shift_left->right()->definition()->range();
@@ skipping 46 matching lines @@
       __ sra(TMP, right, kSmiTagSize);
       __ sllv(result, left, TMP);
     }
   } else {
     if (right_needs_check) {
       ASSERT(shift_left->CanDeoptimize());
       __ BranchUnsignedGreaterEqual(
           right, reinterpret_cast<int32_t>(Smi::New(Smi::kBits)), deopt);
     }
     // Left is not a constant.
+    Register temp = locs.temp(0).reg();
     // Check if count too large for handling it inlined.
-    __ sra(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
-    // Overflow test (preserve left, right, and TMP);
-    Register temp = locs.temp(0).reg();
-    __ sllv(temp, left, TMP);
-    __ srav(temp, temp, TMP);
-    __ bne(temp, left, deopt);  // Overflow.
+    __ sra(temp, right, kSmiTagSize);  // SmiUntag right into temp.
+    // Overflow test (preserve left, right, and temp);
+    __ sllv(CMPRES1, left, temp);
+    __ srav(CMPRES1, CMPRES1, temp);
+    __ bne(CMPRES1, left, deopt);  // Overflow.
     // Shift for result now we know there is no overflow.
-    __ sllv(result, left, TMP);
+    __ sllv(result, left, temp);
   }
 }
 
 
 LocationSummary* BinarySmiOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = op_kind() == Token::kADD ? 1 : 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   if (op_kind() == Token::kTRUNCDIV) {
@@ skipping 70 matching lines @@
         if (deopt == NULL) {
           if (value == 2) {
             __ sll(result, left, 1);
           } else {
             __ LoadImmediate(TMP1, value);
             __ mult(left, TMP1);
             __ mflo(result);
           }
         } else {
           if (value == 2) {
-            __ sra(TMP1, left, 31);  // TMP1 = sign of left.
+            __ sra(CMPRES2, left, 31);  // CMPRES2 = sign of left.
             __ sll(result, left, 1);
           } else {
             __ LoadImmediate(TMP1, value);
             __ mult(left, TMP1);
             __ mflo(result);
-            __ mfhi(TMP1);
+            __ mfhi(CMPRES2);
           }
           __ sra(CMPRES, result, 31);
-          __ bne(TMP1, CMPRES, deopt);
+          __ bne(CMPRES1, CMPRES2, deopt);
         }
         break;
       }
       case Token::kTRUNCDIV: {
         const intptr_t value = Smi::Cast(constant).Value();
         if (value == 1) {
           if (result != left) {
             __ mov(result, left);
           }
           break;
@@ skipping 106 matching lines @@
         __ bltz(CMPRES, deopt);
       }
       break;
     }
     case Token::kMUL: {
       __ TraceSimMsg("kMUL");
       __ sra(TMP, left, kSmiTagSize);
       __ mult(TMP, right);
       __ mflo(result);
       if (deopt != NULL) {
-        __ mfhi(TMP1);
-        __ sra(CMPRES, result, 31);
-        __ bne(TMP1, CMPRES, deopt);
+        __ mfhi(CMPRES2);
+        __ sra(CMPRES1, result, 31);
+        __ bne(CMPRES1, CMPRES2, deopt);
       }
       break;
     }
     case Token::kBIT_AND: {
       // No overflow check.
       __ and_(result, left, right);
       break;
     }
     case Token::kBIT_OR: {
       // No overflow check.
@@ skipping 13 matching lines @@
       __ sra(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
       __ div(temp, TMP);
       __ mflo(result);
       // Check the corner case of dividing the 'MIN_SMI' with -1, in which
       // case we cannot tag the result.
       __ BranchEqual(result, 0x40000000, deopt);
       __ SmiTag(result);
       break;
     }
     case Token::kSHR: {
+      Register temp = locs()->temp(0).reg();
       if (CanDeoptimize()) {
         __ bltz(right, deopt);
       }
-      __ sra(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
+      __ sra(temp, right, kSmiTagSize);  // SmiUntag right into temp.
       // sra operation masks the count to 5 bits.
       const intptr_t kCountLimit = 0x1F;
       Range* right_range = this->right()->definition()->range();
       if ((right_range == NULL) ||
           !right_range->IsWithin(RangeBoundary::kMinusInfinity, kCountLimit)) {
         Label ok;
-        __ BranchSignedLessEqual(TMP, kCountLimit, &ok);
-        __ LoadImmediate(TMP, kCountLimit);
+        __ BranchSignedLessEqual(temp, kCountLimit, &ok);
+        __ LoadImmediate(temp, kCountLimit);
         __ Bind(&ok);
       }
-      Register temp = locs()->temp(0).reg();
-      __ sra(temp, left, kSmiTagSize);  // SmiUntag left into temp.
-      __ srav(result, temp, TMP);
+
+      __ sra(CMPRES1, left, kSmiTagSize);  // SmiUntag left into CMPRES1.
+      __ srav(result, CMPRES1, temp);
       __ SmiTag(result);
       break;
     }
     case Token::kDIV: {
       // Dispatches to 'Double./'.
       // TODO(srdjan): Implement as conversion to double and double division.
       UNREACHABLE();
       break;
     }
     case Token::kMOD: {
@@ skipping 134 matching lines @@
   } else if (value_cid == kSmiCid) {
     __ SmiUntag(value);  // Untag input before conversion.
     __ mtc1(value, STMP1);
     __ cvtdw(result, STMP1);
   } else {
     Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptBinaryDoubleOp);
     Label is_smi, done;
 
     __ andi(CMPRES, value, Immediate(kSmiTagMask));
     __ beq(CMPRES, ZR, &is_smi);
-    __ LoadClassId(TMP, value);
-    __ BranchNotEqual(TMP, kDoubleCid, deopt);
+    __ LoadClassId(CMPRES1, value);
+    __ BranchNotEqual(CMPRES1, kDoubleCid, deopt);
     __ LoadDFromOffset(result, value, Double::value_offset() - kHeapObjectTag);
     __ b(&done);
     __ Bind(&is_smi);
     // TODO(regis): Why do we preserve value here but not above?
     __ sra(TMP, value, 1);
     __ mtc1(TMP, STMP1);
     __ cvtdw(result, STMP1);
     __ Bind(&done);
   }
 }
@@ skipping 671 matching lines @@
   summary->set_in(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("CheckSmiInstr");
   Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         kDeoptCheckSmi);
-  __ andi(TMP1, value, Immediate(kSmiTagMask));
-  __ bne(TMP1, ZR, deopt);
+  __ andi(CMPRES1, value, Immediate(kSmiTagMask));
+  __ bne(CMPRES1, ZR, deopt);
 }
 
 
 LocationSummary* CheckArrayBoundInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(kLengthPos, Location::RegisterOrSmiConstant(length()));
   locs->set_in(kIndexPos, Location::RegisterOrSmiConstant(index()));
@@ skipping 246 matching lines @@
   } else {
     compiler->EmitEqualityRegRegCompare(left.reg(),
                                        right.reg(),
                                        needs_number_check(),
                                        token_pos());
   }
 
   Register result = locs()->out().reg();
   Label load_true, done;
   if (kind() == Token::kEQ_STRICT) {
-    __ beq(CMPRES, TMP1, &load_true);
+    __ beq(CMPRES1, CMPRES2, &load_true);
   } else {
     ASSERT(kind() == Token::kNE_STRICT);
-    __ bne(CMPRES, TMP1, &load_true);
+    __ bne(CMPRES1, CMPRES2, &load_true);
   }
   __ LoadObject(result, Bool::False());
   __ b(&done);
   __ Bind(&load_true);
   __ LoadObject(result, Bool::True());
   __ Bind(&done);
 }
 
 
 void StrictCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
@@ skipping 110 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS