Merge (x & y) == 0 pattern to emit a single test instruction.

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 326 matching lines @@
     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 CMPRES2.
+// Branches on condition c assuming comparison results in CMPRES1 and CMPRES2.
 static void EmitBranchAfterCompare(
     FlowGraphCompiler* compiler, Condition c, Label* is_true) {
   switch (c) {
     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:
@@ skipping 141 matching lines @@
     return;
   }
   if (operation_cid() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   UNREACHABLE();
 }
 
 
+LocationSummary* TestSmiInstr::MakeLocationSummary() const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  locs->set_in(0, Location::RequiresRegister());
+  // Only one input can be a constant operand. The case of two constant
+  // operands should be handled by constant propagation.
+  locs->set_in(1, Location::RegisterOrConstant(right()));
+  return locs;
+}
+
+
+void TestSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  // Never emitted outside of the BranchInstr.
+  UNREACHABLE();
+}
+
+
+void TestSmiInstr::EmitBranchCode(FlowGraphCompiler* compiler,
+                                  BranchInstr* branch) {
+  Condition branch_condition = (kind() == Token::kNE) ? NE : EQ;
+  Register left = locs()->in(0).reg();
+  Location right = locs()->in(1);
+  if (right.IsConstant()) {
+    ASSERT(right.constant().IsSmi());
+    const int32_t imm =
+        reinterpret_cast<int32_t>(right.constant().raw());
+    if (Utils::IsUint(kImmBits, imm)) {

[zra, 2013/11/05 18:38:03]

I'm adding AndImmediate in https://codereview.chromium.org/58003003/. You can
use that here.

[Florian Schneider, 2013/11/06 12:13:42]

Thanks. Done.

+      __ andi(CMPRES1, left, Immediate(imm));
+    } else {
+      __ LoadImmediate(TMP, imm);
+      __ and_(CMPRES1, left, TMP);
+    }
+  } else {
+    __ and_(CMPRES1, left, right.reg());
+  }
+  __ mov(CMPRES2, ZR);
+  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 =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresFpuRegister());
     locs->set_in(1, Location::RequiresFpuRegister());
     locs->set_temp(0, Location::RequiresRegister());
@@ skipping 122 matching lines @@
 
 void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register char_code = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ TraceSimMsg("StringFromCharCodeInstr");
 
   __ LoadImmediate(result,
                    reinterpret_cast<uword>(Symbols::PredefinedAddress()));
   __ AddImmediate(result, Symbols::kNullCharCodeSymbolOffset * kWordSize);
-  __ sll(TMP1, char_code, 1);  // Char code is a smi.
-  __ addu(TMP1, TMP1, result);
-  __ lw(result, Address(TMP1));
+  __ sll(TMP, char_code, 1);  // Char code is a smi.
+  __ addu(TMP, TMP, result);
+  __ lw(result, Address(TMP));
 }
 
 
 LocationSummary* StringInterpolateInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(A0));
   summary->set_out(Location::RegisterLocation(V0));
@@ skipping 36 matching lines @@
   return LocationSummary::Make(kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register object = locs()->in(0).reg();
   Register result = locs()->out().reg();
   Label load, done;
-  __ andi(CMPRES, object, Immediate(kSmiTagMask));
-  __ bne(CMPRES, ZR, &load);
+  __ andi(CMPRES1, object, Immediate(kSmiTagMask));
+  __ bne(CMPRES1, ZR, &load);
   __ LoadImmediate(result, Smi::RawValue(kSmiCid));
   __ b(&done);
   __ Bind(&load);
   __ LoadClassId(result, object);
   __ SmiTag(result);
   __ Bind(&done);
 }
 
 
 CompileType LoadIndexedInstr::ComputeType() const {
@@ skipping 197 matching lines @@
         __ lw(result, element_address);
         // Verify that the signed value in 'result' can fit inside a Smi.
         __ BranchSignedLess(result, 0xC0000000, deopt);
         __ SmiTag(result);
       }
       break;
     case kTypedDataUint32ArrayCid: {
         Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptUint32Load);
         __ lw(result, element_address);
         // Verify that the unsigned value in 'result' can fit inside a Smi.
-        __ LoadImmediate(TMP1, 0xC0000000);
-        __ and_(CMPRES, result, TMP1);
-        __ bne(CMPRES, ZR, deopt);
+        __ LoadImmediate(TMP, 0xC0000000);
+        __ and_(CMPRES1, result, TMP);
+        __ bne(CMPRES1, ZR, deopt);
         __ SmiTag(result);
       }
       break;
     default:
       ASSERT((class_id() == kArrayCid) || (class_id() == kImmutableArrayCid));
       __ lw(result, element_address);
       break;
   }
 }
 
@@ skipping 162 matching lines @@
           value = 0;
         }
         __ LoadImmediate(TMP, static_cast<int8_t>(value));
         __ sb(TMP, element_address);
       } else {
         Register value = locs()->in(2).reg();
         Label store_value, bigger, smaller;
         __ SmiUntag(value);
         __ BranchUnsignedLess(value, 0xFF + 1, &store_value);
         __ LoadImmediate(TMP, 0xFF);
-        __ slti(CMPRES, value, Immediate(1));
-        __ movn(TMP, ZR, CMPRES);
+        __ slti(CMPRES1, value, Immediate(1));
+        __ movn(TMP, ZR, CMPRES1);
         __ mov(value, TMP);
         __ Bind(&store_value);
         __ sb(value, element_address);
       }
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       Register value = locs()->in(2).reg();
       __ SmiUntag(value);
@@ skipping 167 matching lines @@
           __ lw(CMPRES1, field_length_operand);
           __ subu(CMPRES1, TMP, CMPRES1);
           __ b(&length_compared);
           __ Bind(&no_fixed_length);
           __ b(fail);
           __ Bind(&length_compared);
         }
         __ bne(CMPRES1, ZR, fail);
       }
       __ Bind(&skip_length_check);
-      __ lw(TMP1, field_nullability_operand);
-      __ subu(CMPRES, value_cid_reg, TMP1);
+      __ lw(TMP, field_nullability_operand);
+      __ subu(CMPRES1, value_cid_reg, TMP);
     } else if (value_cid == kNullCid) {
-      // TODO(regis): TMP1 may conflict. Revisit.
-      __ lw(TMP1, field_nullability_operand);
-      __ LoadImmediate(CMPRES, value_cid);
-      __ subu(CMPRES, TMP1, CMPRES);
+      __ lw(TMP, field_nullability_operand);
+      __ LoadImmediate(CMPRES1, value_cid);
+      __ subu(CMPRES1, TMP, CMPRES1);
     } else {
       Label skip_length_check;
-      // TODO(regis): TMP1 may conflict. Revisit.
-      __ lw(TMP1, field_cid_operand);
-      __ LoadImmediate(CMPRES, value_cid);
-      __ subu(CMPRES, TMP1, CMPRES);
-      __ bne(CMPRES, ZR, &skip_length_check);
+      __ lw(TMP, field_cid_operand);
+      __ LoadImmediate(CMPRES1, value_cid);
+      __ subu(CMPRES1, TMP, CMPRES1);
+      __ bne(CMPRES1, ZR, &skip_length_check);
       // Insert length check.
       if (field_has_length) {
         ASSERT(value_cid_reg != kNoRegister);
         if ((value_cid == kArrayCid) || (value_cid == kImmutableArrayCid)) {
           __ lw(TMP, FieldAddress(value_reg, Array::length_offset()));
-          __ LoadImmediate(CMPRES, Smi::RawValue(field_length));
-          __ subu(CMPRES, TMP, CMPRES);
+          __ LoadImmediate(CMPRES1, Smi::RawValue(field_length));
+          __ subu(CMPRES1, TMP, CMPRES1);
         } else if (RawObject::IsTypedDataClassId(value_cid)) {
           __ lw(TMP, FieldAddress(value_reg, TypedData::length_offset()));
-          __ LoadImmediate(CMPRES, Smi::RawValue(field_length));
-          __ subu(CMPRES, TMP, CMPRES);
+          __ LoadImmediate(CMPRES1, Smi::RawValue(field_length));
+          __ subu(CMPRES1, TMP, CMPRES1);
         } else if (field_cid != kIllegalCid) {
           ASSERT(field_cid != value_cid);
           ASSERT(field_length >= 0);
           // Field has a known class id and length. At compile time it is
           // known that the value's class id is not a fixed length list.
           __ b(fail);
         } else {
           ASSERT(field_cid == kIllegalCid);
           ASSERT(field_length == Field::kUnknownFixedLength);
           // Following jump cannot not occur, fall through.
         }
-        __ bne(CMPRES, ZR, fail);
+        __ bne(CMPRES1, ZR, fail);
       }
       __ Bind(&skip_length_check);
     }
-    __ beq(CMPRES, ZR, &ok);
+    __ beq(CMPRES1, ZR, &ok);
 
     __ 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);
       if (field_has_length) {
         Label check_array, length_set, no_fixed_length;
         __ BranchEqual(value_cid_reg, kNullCid, &no_fixed_length);
@@ skipping 13 matching lines @@
         __ BranchSignedGreater(value_cid_reg, kImmutableArrayCid,
                                &no_fixed_length);
         __ BranchSignedLess(value_cid_reg, kArrayCid, &no_fixed_length);
         // Destroy value_cid_reg (safe because we are finished with it).
         __ lw(value_cid_reg,
                 FieldAddress(value_reg, Array::length_offset()));
         __ sw(value_cid_reg, field_length_operand);
         // Updated field length from regular array.
         __ b(&length_set);
         __ Bind(&no_fixed_length);
-        // TODO(regis): TMP1 may conflict. Revisit.
-        __ LoadImmediate(TMP1, Smi::RawValue(Field::kNoFixedLength));
-        __ sw(TMP1, field_length_operand);
+        __ LoadImmediate(TMP, Smi::RawValue(Field::kNoFixedLength));
+        __ sw(TMP, field_length_operand);
         __ Bind(&length_set);
       }
     } else {
       ASSERT(field_reg != kNoRegister);
-      __ LoadImmediate(TMP1, value_cid);
-      __ sw(TMP1, field_cid_operand);
-      __ sw(TMP1, field_nullability_operand);
+      __ LoadImmediate(TMP, value_cid);
+      __ sw(TMP, field_cid_operand);
+      __ sw(TMP, field_nullability_operand);
       if (field_has_length) {
         ASSERT(value_cid_reg != kNoRegister);
         if ((value_cid == kArrayCid) || (value_cid == kImmutableArrayCid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ lw(value_cid_reg,
                 FieldAddress(value_reg, Array::length_offset()));
           __ sw(value_cid_reg, field_length_operand);
         } else if (RawObject::IsTypedDataClassId(value_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ lw(value_cid_reg,
                 FieldAddress(value_reg, TypedData::length_offset()));
           __ sw(value_cid_reg, field_length_operand);
         } else {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ LoadImmediate(value_cid_reg, Smi::RawValue(Field::kNoFixedLength));
           __ sw(value_cid_reg, field_length_operand);
         }
       }
     }
     if (!ok_is_fall_through) {
       __ b(&ok);
     }
   } else {
     if (field_reg != kNoRegister) {
       __ LoadObject(field_reg, Field::ZoneHandle(field().raw()));
     }
     if (value_cid == kDynamicCid) {
       // Field's guarded class id is fixed by value's class id is not known.
-      __ andi(CMPRES, value_reg, Immediate(kSmiTagMask));
+      __ andi(CMPRES1, value_reg, Immediate(kSmiTagMask));
 
       if (field_cid != kSmiCid) {
-        __ beq(CMPRES, ZR, fail);
+        __ beq(CMPRES1, ZR, fail);
         __ LoadClassId(value_cid_reg, value_reg);
-        __ LoadImmediate(TMP1, field_cid);
-        __ subu(CMPRES, value_cid_reg, TMP1);
+        __ LoadImmediate(TMP, field_cid);
+        __ subu(CMPRES1, value_cid_reg, TMP);
       }
 
       if (field_has_length) {
         // Jump when Value CID != Field guard CID
-        __ bne(CMPRES, ZR, fail);
+        __ bne(CMPRES1, ZR, fail);
         // Classes are same, perform guarded list length check.
         ASSERT(field_reg != kNoRegister);
         ASSERT(value_cid_reg != kNoRegister);
         FieldAddress field_length_operand(
             field_reg, Field::guarded_list_length_offset());
         if ((field_cid == kArrayCid) || (field_cid == kImmutableArrayCid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ lw(value_cid_reg,
                 FieldAddress(value_reg, Array::length_offset()));
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ lw(value_cid_reg,
                 FieldAddress(value_reg, TypedData::length_offset()));
         }
-        __ lw(TMP1, field_length_operand);
-        __ subu(CMPRES, value_cid_reg, TMP1);
+        __ lw(TMP, field_length_operand);
+        __ subu(CMPRES1, value_cid_reg, TMP);
       }
 
       if (field().is_nullable() && (field_cid != kNullCid)) {
-        __ beq(CMPRES, ZR, &ok);
+        __ beq(CMPRES1, ZR, &ok);
         __ LoadImmediate(TMP, reinterpret_cast<int32_t>(Object::null()));
-        __ subu(CMPRES, value_reg, TMP);
+        __ subu(CMPRES1, value_reg, TMP);
       }
 
       if (ok_is_fall_through) {
-        __ bne(CMPRES, ZR, fail);
+        __ bne(CMPRES1, ZR, fail);
       } else {
-        __ beq(CMPRES, ZR, &ok);
+        __ beq(CMPRES1, ZR, &ok);
       }
     } else {
       // Both value's and field's class id is known.
       if ((value_cid != field_cid) && (value_cid != nullability)) {
         if (ok_is_fall_through) {
           __ b(fail);
         }
       } else if (field_has_length && (value_cid == field_cid)) {
         ASSERT(value_cid_reg != kNoRegister);
         if ((field_cid == kArrayCid) || (field_cid == kImmutableArrayCid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ lw(value_cid_reg,
                 FieldAddress(value_reg, Array::length_offset()));
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ lw(value_cid_reg,
                 FieldAddress(value_reg, TypedData::length_offset()));
         }
-        __ LoadImmediate(TMP1, Smi::RawValue(field_length));
-        __ subu(CMPRES, value_cid_reg, TMP1);
+        __ LoadImmediate(TMP, Smi::RawValue(field_length));
+        __ subu(CMPRES1, value_cid_reg, TMP);
         if (ok_is_fall_through) {
-          __ bne(CMPRES, ZR, fail);
+          __ bne(CMPRES1, ZR, fail);
         }
       } else {
         // Nothing to emit.
         ASSERT(!compiler->is_optimizing());
         return;
       }
     }
   }
 
   if (deopt == NULL) {
@@ skipping 198 matching lines @@
 
 void InstantiateTypeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("InstantiateTypeInstr");
   Register instantiator_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
 
   // 'instantiator_reg' is the instantiator AbstractTypeArguments object
   // (or null).
   // A runtime call to instantiate the type is required.
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
-  __ LoadObject(TMP1, Object::ZoneHandle());
-  __ sw(TMP1, Address(SP, 2 * kWordSize));  // Make room for the result.
-  __ LoadObject(TMP1, type());
-  __ sw(TMP1, Address(SP, 1 * kWordSize));
+  __ LoadObject(TMP, Object::ZoneHandle());
+  __ sw(TMP, Address(SP, 2 * kWordSize));  // Make room for the result.
+  __ LoadObject(TMP, type());
+  __ sw(TMP, Address(SP, 1 * kWordSize));
   // Push instantiator type arguments.
   __ sw(instantiator_reg, Address(SP, 0 * kWordSize));
 
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kInstantiateTypeRuntimeEntry,
                                 2,
                                 locs());
   // Pop instantiated type.
   __ lw(result_reg, Address(SP, 2 * kWordSize));
@@ skipping 30 matching lines @@
   // the type arguments.
   Label type_arguments_instantiated;
   const intptr_t len = type_arguments().Length();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
     __ BranchEqual(instantiator_reg, reinterpret_cast<int32_t>(Object::null()),
                    &type_arguments_instantiated);
   }
   // Instantiate non-null type arguments.
   // A runtime call to instantiate the type arguments is required.
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
-  __ LoadObject(TMP1, Object::ZoneHandle());
-  __ sw(TMP1, Address(SP, 2 * kWordSize));  // Make room for the result.
-  __ LoadObject(TMP1, type_arguments());
-  __ sw(TMP1, Address(SP, 1 * kWordSize));
+  __ LoadObject(TMP, Object::ZoneHandle());
+  __ sw(TMP, Address(SP, 2 * kWordSize));  // Make room for the result.
+  __ LoadObject(TMP, type_arguments());
+  __ sw(TMP, Address(SP, 1 * kWordSize));
   // Push instantiator type arguments.
   __ sw(instantiator_reg, Address(SP, 0 * kWordSize));
 
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kInstantiateTypeArgumentsRuntimeEntry,
                                 2,
                                 locs());
   // Pop instantiated type arguments.
   __ lw(result_reg, Address(SP, 2 * kWordSize));
@@ skipping 122 matching lines @@
 }
 
 
 void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ TraceSimMsg("CloneContextInstr");
 
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
-  __ LoadObject(TMP1, Object::ZoneHandle());  // Make room for the result.
-  __ sw(TMP1, Address(SP, 1 * kWordSize));
+  __ LoadObject(TMP, Object::ZoneHandle());  // Make room for the result.
+  __ sw(TMP, Address(SP, 1 * kWordSize));
   __ sw(context_value, Address(SP, 0 * kWordSize));
 
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kCloneContextRuntimeEntry,
                                 1,
                                 locs());
   __ lw(result, Address(SP, 1 * kWordSize));  // Get result (cloned context).
   __ addiu(SP, SP, Immediate(2 * kWordSize));
 }
 
 
 LocationSummary* CatchBlockEntryInstr::MakeLocationSummary() const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void CatchBlockEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   compiler->AddExceptionHandler(catch_try_index(),
                                 try_index(),
                                 compiler->assembler()->CodeSize(),
                                 catch_handler_types_,
                                 needs_stacktrace());
   // Restore pool pointer.
-  __ GetNextPC(CMPRES, TMP);
+  __ GetNextPC(CMPRES1, TMP);
   const intptr_t object_pool_pc_dist =
      Instructions::HeaderSize() - Instructions::object_pool_offset() +
      compiler->assembler()->CodeSize() - 1 * Instr::kInstrSize;
-  __ LoadFromOffset(PP, CMPRES, -object_pool_pc_dist);
+  __ LoadFromOffset(PP, CMPRES1, -object_pool_pc_dist);
 
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 
   // 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);
@@ skipping 55 matching lines @@
  private:
   CheckStackOverflowInstr* instruction_;
 };
 
 
 void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("CheckStackOverflowInstr");
   CheckStackOverflowSlowPath* slow_path = new CheckStackOverflowSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
-  __ LoadImmediate(TMP1, Isolate::Current()->stack_limit_address());
+  __ LoadImmediate(TMP, Isolate::Current()->stack_limit_address());
 
-  __ lw(CMPRES1, Address(TMP1));
+  __ lw(CMPRES1, Address(TMP));
   __ 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()));
@@ skipping 29 matching lines @@
       // of constant propagation, inlining, etc.
       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(CMPRES1, TMP1, value);
+        __ sll(TMP, left, value);
+        __ sra(CMPRES1, TMP, 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();
@@ skipping 29 matching lines @@
     if (right_needs_check) {
       const bool right_may_be_negative =
           (right_range == NULL) ||
           !right_range->IsWithin(0, RangeBoundary::kPlusInfinity);
       if (right_may_be_negative) {
         ASSERT(shift_left->CanDeoptimize());
         __ bltz(right, deopt);
       }
       Label done, is_not_zero;
 
-      __ sltiu(CMPRES,
+      __ sltiu(CMPRES1,
           right, Immediate(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
-      __ movz(result, ZR, CMPRES);  // result = right >= kBits ? 0 : result.
-      __ sra(TMP1, right, kSmiTagSize);
-      __ sllv(TMP1, left, TMP1);
+      __ movz(result, ZR, CMPRES1);  // result = right >= kBits ? 0 : result.
+      __ sra(TMP, right, kSmiTagSize);
+      __ sllv(TMP, left, TMP);
       // result = right < kBits ? left << right : result.
-      __ movn(result, TMP1, CMPRES);
+      __ movn(result, TMP, CMPRES1);
     } else {
       __ 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);
     }
@@ skipping 62 matching lines @@
   if (locs()->in(1).IsConstant()) {
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     int32_t imm = reinterpret_cast<int32_t>(constant.raw());
     switch (op_kind()) {
       case Token::kSUB: {
         __ TraceSimMsg("kSUB imm");
         if (deopt == NULL) {
           __ AddImmediate(result, left, -imm);
         } else {
-          __ SubImmediateDetectOverflow(result, left, imm, CMPRES);
-          __ bltz(CMPRES, deopt);
+          __ SubImmediateDetectOverflow(result, left, imm, CMPRES1);
+          __ bltz(CMPRES1, deopt);
         }
         break;
       }
       case Token::kADD: {
         if (deopt == NULL) {
           __ AddImmediate(result, left, imm);
         } else {
           Register temp = locs()->temp(0).reg();
-          __ AddImmediateDetectOverflow(result, left, imm, CMPRES, temp);
-          __ bltz(CMPRES, deopt);
+          __ AddImmediateDetectOverflow(result, left, imm, CMPRES1, temp);
+          __ bltz(CMPRES1, deopt);
         }
         break;
       }
       case Token::kMUL: {
         // Keep left value tagged and untag right value.
         const intptr_t value = Smi::Cast(constant).Value();
         if (deopt == NULL) {
           if (value == 2) {
             __ sll(result, left, 1);
           } else {
-            __ LoadImmediate(TMP1, value);
-            __ mult(left, TMP1);
+            __ LoadImmediate(TMP, value);
+            __ mult(left, TMP);
             __ mflo(result);
           }
         } else {
           if (value == 2) {
             __ sra(CMPRES2, left, 31);  // CMPRES2 = sign of left.
             __ sll(result, left, 1);
           } else {
-            __ LoadImmediate(TMP1, value);
-            __ mult(left, TMP1);
+            __ LoadImmediate(TMP, value);
+            __ mult(left, TMP);
             __ mflo(result);
             __ mfhi(CMPRES2);
           }
-          __ sra(CMPRES, result, 31);
+          __ sra(CMPRES1, result, 31);
           __ 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);
           }
@@ skipping 20 matching lines @@
           __ subu(result, ZR, result);
         }
         __ SmiTag(result);
         break;
       }
       case Token::kBIT_AND: {
         // No overflow check.
         if (Utils::IsUint(kImmBits, imm)) {
           __ andi(result, left, Immediate(imm));
         } else {
-          __ LoadImmediate(TMP1, imm);
-          __ and_(result, left, TMP1);
+          __ LoadImmediate(TMP, imm);
+          __ and_(result, left, TMP);
         }
         break;
       }
       case Token::kBIT_OR: {
         // No overflow check.
         if (Utils::IsUint(kImmBits, imm)) {
           __ ori(result, left, Immediate(imm));
         } else {
-          __ LoadImmediate(TMP1, imm);
-          __ or_(result, left, TMP1);
+          __ LoadImmediate(TMP, imm);
+          __ or_(result, left, TMP);
         }
         break;
       }
       case Token::kBIT_XOR: {
         // No overflow check.
         if (Utils::IsUint(kImmBits, imm)) {
           __ xori(result, left, Immediate(imm));
         } else {
-          __ LoadImmediate(TMP1, imm);
-          __ xor_(result, left, TMP1);
+          __ LoadImmediate(TMP, imm);
+          __ xor_(result, left, TMP);
         }
         break;
       }
       case Token::kSHR: {
         // sarl operation masks the count to 5 bits.
         const intptr_t kCountLimit = 0x1F;
         intptr_t value = Smi::Cast(constant).Value();
 
         __ TraceSimMsg("kSHR");
 
@@ skipping 24 matching lines @@
     return;
   }
 
   Register right = locs()->in(1).reg();
   switch (op_kind()) {
     case Token::kADD: {
       if (deopt == NULL) {
         __ addu(result, left, right);
       } else {
         Register temp = locs()->temp(0).reg();
-        __ AdduDetectOverflow(result, left, right, CMPRES, temp);
-        __ bltz(CMPRES, deopt);
+        __ AdduDetectOverflow(result, left, right, CMPRES1, temp);
+        __ bltz(CMPRES1, deopt);
       }
       break;
     }
     case Token::kSUB: {
       __ TraceSimMsg("kSUB");
       if (deopt == NULL) {
         __ subu(result, left, right);
       } else {
-        __ SubuDetectOverflow(result, left, right, CMPRES);
-        __ bltz(CMPRES, deopt);
+        __ SubuDetectOverflow(result, left, right, CMPRES1);
+        __ bltz(CMPRES1, deopt);
       }
       break;
     }
     case Token::kMUL: {
       __ TraceSimMsg("kMUL");
       __ sra(TMP, left, kSmiTagSize);
       __ mult(TMP, right);
       __ mflo(result);
       if (deopt != NULL) {
         __ mfhi(CMPRES2);
@@ skipping 92 matching lines @@
 }
 
 
 void CheckEitherNonSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptBinaryDoubleOp);
   intptr_t left_cid = left()->Type()->ToCid();
   intptr_t right_cid = right()->Type()->ToCid();
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   if (left_cid == kSmiCid) {
-    __ andi(CMPRES, right, Immediate(kSmiTagMask));
+    __ andi(CMPRES1, right, Immediate(kSmiTagMask));
   } else if (right_cid == kSmiCid) {
-    __ andi(CMPRES, left, Immediate(kSmiTagMask));
+    __ andi(CMPRES1, left, Immediate(kSmiTagMask));
   } else {
     __ or_(TMP, left, right);
-    __ andi(CMPRES, TMP, Immediate(kSmiTagMask));
+    __ andi(CMPRES1, TMP, Immediate(kSmiTagMask));
   }
-  __ beq(CMPRES, ZR, deopt);
+  __ beq(CMPRES1, ZR, deopt);
 }
 
 
 LocationSummary* BoxDoubleInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs,
                           kNumTemps,
                           LocationSummary::kCallOnSlowPath);
@@ skipping 75 matching lines @@
   if (value_cid == kDoubleCid) {
     __ LoadDFromOffset(result, value, Double::value_offset() - kHeapObjectTag);
   } 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);
+    __ andi(CMPRES1, value, Immediate(kSmiTagMask));
+    __ beq(CMPRES1, ZR, &is_smi);
     __ 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 437 matching lines @@
 }
 
 
 void UnarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
   switch (op_kind()) {
     case Token::kNEGATE: {
       Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                             kDeoptUnaryOp);
-      __ SubuDetectOverflow(result, ZR, value, CMPRES);
-      __ bltz(CMPRES, deopt);
+      __ SubuDetectOverflow(result, ZR, value, CMPRES1);
+      __ bltz(CMPRES1, deopt);
       break;
     }
     case Token::kBIT_NOT:
       __ nor(result, value, ZR);
       __ addiu(result, result, Immediate(-1));  // Remove inverted smi-tag.
       break;
     default:
       UNREACHABLE();
   }
 }
@@ skipping 61 matching lines @@
   ASSERT(result == V0);
   ASSERT(result != value_obj);
   __ LoadDFromOffset(DTMP, value_obj, Double::value_offset() - kHeapObjectTag);
   __ cvtwd(STMP1, DTMP);
   __ mfc1(result, STMP1);
 
   // Overflow is signaled with minint.
   Label do_call, done;
   // Check for overflow and that it fits into Smi.
   __ LoadImmediate(TMP, 0xC0000000);
-  __ subu(CMPRES, result, TMP);
-  __ bltz(CMPRES, &do_call);
+  __ subu(CMPRES1, result, TMP);
+  __ bltz(CMPRES1, &do_call);
   __ SmiTag(result);
   __ b(&done);
   __ Bind(&do_call);
   __ Push(value_obj);
   ASSERT(instance_call()->HasICData());
   const ICData& ic_data = *instance_call()->ic_data();
   ASSERT((ic_data.NumberOfChecks() == 1));
   const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(0));
 
   const intptr_t kNumberOfArguments = 1;
@@ skipping 20 matching lines @@
 
 void DoubleToSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptDoubleToSmi);
   Register result = locs()->out().reg();
   DRegister value = locs()->in(0).fpu_reg();
   __ cvtwd(STMP1, value);
   __ mfc1(result, STMP1);
 
   // Check for overflow and that it fits into Smi.
   __ LoadImmediate(TMP, 0xC0000000);
-  __ subu(CMPRES, result, TMP);
-  __ bltz(CMPRES, deopt);
+  __ subu(CMPRES1, result, TMP);
+  __ bltz(CMPRES1, deopt);
   __ SmiTag(result);
 }
 
 
 LocationSummary* DoubleToDoubleInstr::MakeLocationSummary() const {
   UNIMPLEMENTED();
   return NULL;
 }
 
 
@@ skipping 143 matching lines @@
 
   ASSERT((unary_checks().GetReceiverClassIdAt(0) != kSmiCid) ||
          (unary_checks().NumberOfChecks() > 1));
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         kDeoptCheckClass);
   Label is_ok;
   intptr_t cix = 0;
   if (unary_checks().GetReceiverClassIdAt(cix) == kSmiCid) {
-    __ andi(CMPRES, value, Immediate(kSmiTagMask));
-    __ beq(CMPRES, ZR, &is_ok);
+    __ andi(CMPRES1, value, Immediate(kSmiTagMask));
+    __ beq(CMPRES1, ZR, &is_ok);
     cix++;  // Skip first check.
   } else {
-    __ andi(CMPRES, value, Immediate(kSmiTagMask));
-    __ beq(CMPRES, ZR, deopt);
+    __ andi(CMPRES1, value, Immediate(kSmiTagMask));
+    __ beq(CMPRES1, ZR, deopt);
   }
   __ LoadClassId(temp, value);
   const intptr_t num_checks = unary_checks().NumberOfChecks();
   for (intptr_t i = cix; i < num_checks; i++) {
     ASSERT(unary_checks().GetReceiverClassIdAt(i) != kSmiCid);
-    __ LoadImmediate(TMP1, unary_checks().GetReceiverClassIdAt(i));
-    __ subu(CMPRES, temp, TMP1);
+    __ LoadImmediate(TMP, unary_checks().GetReceiverClassIdAt(i));
+    __ subu(CMPRES1, temp, TMP);
     if (i == (num_checks - 1)) {
-      __ bne(CMPRES, ZR, deopt);
+      __ bne(CMPRES1, ZR, deopt);
     } else {
-      __ beq(CMPRES, ZR, &is_ok);
+      __ beq(CMPRES1, ZR, &is_ok);
     }
   }
   __ Bind(&is_ok);
 }
 
 
 LocationSummary* CheckSmiInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
@@ skipping 226 matching lines @@
                                            bool value) {
   __ TraceSimMsg("ControlInstruction::EmitBranchOnValue");
   if (value && !compiler->CanFallThroughTo(true_successor())) {
     __ b(compiler->GetJumpLabel(true_successor()));
   } else if (!value && !compiler->CanFallThroughTo(false_successor())) {
     __ b(compiler->GetJumpLabel(false_successor()));
   }
 }
 
 
-// The comparison result is in CMPRES.
+// The comparison result is in CMPRES1.
 void ControlInstruction::EmitBranchOnCondition(FlowGraphCompiler* compiler,
                                                Condition true_condition) {
   __ TraceSimMsg("ControlInstruction::EmitBranchOnCondition");
   if (compiler->CanFallThroughTo(false_successor())) {
     // If the next block is the false successor, fall through to it.
     Label* label = compiler->GetJumpLabel(true_successor());
     EmitBranchAfterCompare(compiler, true_condition, label);
   } else {
     // If the next block is not the false successor, branch to it.
     Condition false_condition = NegateCondition(true_condition);
@@ skipping 120 matching lines @@
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ LoadObject(result, Bool::True());
-  __ LoadObject(TMP1, Bool::False());
-  __ subu(CMPRES, value, result);
-  __ movz(result, TMP1, CMPRES);  // If value is True, move False into result.
+  __ LoadObject(TMP, Bool::False());
+  __ subu(CMPRES1, value, result);
+  __ movz(result, TMP, CMPRES1);  // If value is True, move False into result.
 }
 
 
 LocationSummary* StoreVMFieldInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, value()->NeedsStoreBuffer() ? Location::WritableRegister()
                                               : Location::RequiresRegister());
@@ skipping 49 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS