Enables optimization 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 "lib/error.h"
@@ skipping 74 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(T2, SP, FP);
+    __ subu(TMP1, SP, FP);
 
-    __ BranchEqual(T2, fp_sp_dist, &stack_ok);
+    __ BranchEqual(TMP1, 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 213 matching lines @@
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
   if (IsPolymorphic()) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
-    UNIMPLEMENTED();  // TODO(regis): Verify register allocation.
+    locs->set_in(0, Location::RegisterLocation(A1));
+    locs->set_in(1, Location::RegisterLocation(A0));
+    locs->set_temp(0, Location::RegisterLocation(T0));
+    locs->set_out(Location::RegisterLocation(V0));
     return locs;
   }
   const intptr_t kNumTemps = 1;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(A1));
   locs->set_in(1, Location::RegisterLocation(A0));
   locs->set_temp(0, Location::RegisterLocation(T0));
   locs->set_out(Location::RegisterLocation(V0));
   return locs;
@@ skipping 14 matching lines @@
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id,
                                    token_pos);
   }
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 2;
 
   Label check_identity;
-  __ LoadImmediate(TMP1, reinterpret_cast<intptr_t>(Object::null()));
-  __ beq(A1, TMP1, &check_identity);
-  __ beq(A0, TMP1, &check_identity);
+  __ beq(A1, NULLREG, &check_identity);
+  __ beq(A0, NULLREG, &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 110 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 TMP1.
+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;
+      default:
+        UNREACHABLE();
+        break;
+    }
+}
+
+
 static void EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                 const LocationSummary& locs,
                                 Token::Kind kind,
                                 BranchInstr* branch) {
   __ TraceSimMsg("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, right.reg(), left.constant());
+    __ CompareObject(CMPRES, TMP1, right.reg(), left.constant());
     true_condition = FlowGraphCompiler::FlipCondition(true_condition);
   } else if (right.IsConstant()) {
-    __ CompareObject(CMPRES, left.reg(), right.constant());
+    __ CompareObject(CMPRES, TMP1, left.reg(), right.constant());
   } else {
-    __ subu(CMPRES, left.reg(), right.reg());
+    __ slt(CMPRES, left.reg(), right.reg());
+    __ slt(TMP1, right.reg(), left.reg());
   }
 
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, true_condition);
   } else {
     Register result = locs.out().reg();
     Label done, is_true;
-    switch (true_condition) {
-      case EQ: __ beq(CMPRES, ZR, &is_true); break;
-      case NE: __ bne(CMPRES, ZR, &is_true); break;
-      case GT: __ bgtz(CMPRES, &is_true); break;
-      case GE: __ bgez(CMPRES, &is_true); break;
-      case LT: __ bltz(CMPRES, &is_true); break;
-      case LE: __ blez(CMPRES, &is_true); break;
-      default:
-        UNREACHABLE();
-        break;
-    }
+    EmitBranchAfterCompare(compiler, true_condition, &is_true);
     __ LoadObject(result, Bool::False());
     __ b(&done);
     __ Bind(&is_true);
     __ LoadObject(result, Bool::True());
     __ Bind(&done);
   }
 }
 
 
 static void EmitUnboxedMintEqualityOp(FlowGraphCompiler* compiler,
@@ skipping 97 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, V0, Bool::True());
+  __ CompareObject(CMPRES, TMP1, V0, Bool::True());
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (operands_class_id() == kMintCid) {
     const intptr_t kNumTemps = 2;
     LocationSummary* locs =
@@ skipping 115 matching lines @@
   }
   if (operands_class_id() == kMintCid) {
     EmitUnboxedMintComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   if (operands_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   EmitNativeCode(compiler);
-  __ CompareObject(CMPRES, V0, Bool::True());
+  __ CompareObject(CMPRES, TMP1, 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 53 matching lines @@
   return NULL;
 }
 
 
 void LoadUntaggedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* LoadClassIdInstr::MakeLocationSummary() const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  return LocationSummary::Make(kNumInputs,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
 }
 
 
 void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  Register object = locs()->in(0).reg();
+  Register result = locs()->out().reg();
+  Label load, done;
+  __ andi(CMPRES, object, Immediate(kSmiTagMask));
+  __ bne(CMPRES, ZR, &load);
+  __ LoadImmediate(result, Smi::RawValue(kSmiCid));
+  __ b(&done);
+  __ Bind(&load);
+  __ LoadClassId(result, object);
+  __ SmiTag(result);
+  __ Bind(&done);
 }
 
 
 CompileType LoadIndexedInstr::ComputeType() const {
   switch (class_id_) {
     case kArrayCid:
     case kImmutableArrayCid:
       return CompileType::Dynamic();
 
     case kTypedDataFloat32ArrayCid:
@@ skipping 108 matching lines @@
         __ sll(index.reg(), index.reg(), 2);
         break;
       }
       case 16: {
         __ sll(index.reg(), index.reg(), 3);
         break;
       }
       default:
         UNREACHABLE();
     }
-    __ AddImmediate(index.reg(),
+    __ addu(index.reg(), array, index.reg());
+    element_address = Address(index.reg(),
         FlowGraphCompiler::DataOffsetFor(class_id()) - kHeapObjectTag);
-    element_address = Address(array, index.reg());
   }
 
   if ((representation() == kUnboxedDouble) ||
       (representation() == kUnboxedMint) ||
       (representation() == kUnboxedFloat32x4)) {
     UNIMPLEMENTED();
   }
 
   Register result = locs()->out().reg();
-  if ((index_scale() == 1) && index.IsRegister()) {
-    __ SmiUntag(index.reg());
-  }
   switch (class_id()) {
     case kTypedDataInt8ArrayCid:
       ASSERT(index_scale() == 1);
       __ lb(result, element_address);
       __ SmiTag(result);
       break;
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
@@ skipping 32 matching lines @@
     default:
       ASSERT((class_id() == kArrayCid) || (class_id() == kImmutableArrayCid));
       __ lw(result, element_address);
       break;
   }
 }
 
 
 Representation StoreIndexedInstr::RequiredInputRepresentation(
     intptr_t idx) const {
-  UNIMPLEMENTED();
-  return kTagged;
+  // Array can be a Dart object or a pointer to external data.
+  if (idx == 0)  return kNoRepresentation;  // Flexible input representation.
+  if (idx == 1) return kTagged;  // Index is a smi.
+  ASSERT(idx == 2);
+  switch (class_id_) {
+    case kArrayCid:
+    case kOneByteStringCid:
+    case kTypedDataInt8ArrayCid:
+    case kTypedDataUint8ArrayCid:
+    case kExternalTypedDataUint8ArrayCid:
+    case kTypedDataUint8ClampedArrayCid:
+    case kExternalTypedDataUint8ClampedArrayCid:
+    case kTypedDataInt16ArrayCid:
+    case kTypedDataUint16ArrayCid:
+      return kTagged;
+    case kTypedDataInt32ArrayCid:
+    case kTypedDataUint32ArrayCid:
+      return value()->IsSmiValue() ? kTagged : kUnboxedMint;
+    case kTypedDataFloat32ArrayCid:
+    case kTypedDataFloat64ArrayCid:
+      return kUnboxedDouble;
+    case kTypedDataFloat32x4ArrayCid:
+      return kUnboxedFloat32x4;
+    default:
+      UNIMPLEMENTED();
+      return kTagged;
+  }
 }
 
 
 LocationSummary* StoreIndexedInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   // The smi index is either untagged (element size == 1), or it is left smi
   // tagged (for all element sizes > 1).
   // TODO(regis): Revisit and see if the index can be immediate.
   locs->set_in(1, Location::WritableRegister());
   switch (class_id()) {
     case kArrayCid:
       locs->set_in(2, ShouldEmitStoreBarrier()
                         ? Location::WritableRegister()
                         : Location::RegisterOrConstant(value()));
       break;
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kOneByteStringCid:
+      locs->set_in(2, Location::RegisterOrSmiConstant(value()));
+      break;
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
+      locs->set_in(2, Location::WritableRegister());
+      break;
     case kTypedDataFloat32ArrayCid:
-    case kTypedDataFloat64ArrayCid:
+      // TODO(regis): Verify.
+      // Need temp register for float-to-double conversion.
+      locs->AddTemp(Location::RequiresFpuRegister());
+      // Fall through.
+    case kTypedDataFloat64ArrayCid:  // TODO(srdjan): Support Float64 constants.
     case kTypedDataFloat32x4ArrayCid:
-      UNIMPLEMENTED();
+      locs->set_in(2, Location::RequiresFpuRegister());
       break;
     default:
       UNREACHABLE();
       return NULL;
   }
   return locs;
 }
 
 
 void StoreIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 27 matching lines @@
         __ sll(index.reg(), index.reg(), 2);
         break;
       }
       case 16: {
         __ sll(index.reg(), index.reg(), 3);
         break;
       }
       default:
         UNREACHABLE();
     }
-    __ AddImmediate(index.reg(),
+    __ addu(index.reg(), array, index.reg());
+    element_address = Address(index.reg(),
         FlowGraphCompiler::DataOffsetFor(class_id()) - kHeapObjectTag);
-    __ addu(TMP1, array, index.reg());
-    element_address = Address(TMP1);
   }
 
   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 {
         Register value = locs()->in(2).reg();
         __ StoreIntoObjectNoBarrier(array, element_address, value);
       }
       break;
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
+    case kOneByteStringCid: {
+      if (locs()->in(2).IsConstant()) {
+        const Smi& constant = Smi::Cast(locs()->in(2).constant());
+        __ LoadImmediate(TMP, static_cast<int8_t>(constant.Value()));
+        __ sb(TMP, element_address);
+      } else {
+        Register value = locs()->in(2).reg();
+        __ SmiUntag(value);
+        __ sb(value, element_address);
+      }
+      break;
+    }
     case kTypedDataUint8ClampedArrayCid:
-    case kExternalTypedDataUint8ClampedArrayCid:
-    case kOneByteStringCid:
+    case kExternalTypedDataUint8ClampedArrayCid: {
+      if (locs()->in(2).IsConstant()) {
+        const Smi& constant = Smi::Cast(locs()->in(2).constant());
+        intptr_t value = constant.Value();
+        // Clamp to 0x0 or 0xFF respectively.
+        if (value > 0xFF) {
+          value = 0xFF;
+        } else if (value < 0) {
+          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);
+        __ mov(value, TMP);
+        __ Bind(&store_value);
+        __ sb(value, element_address);
+      }
+      break;
+    }
     case kTypedDataInt16ArrayCid:
-    case kTypedDataUint16ArrayCid:
+    case kTypedDataUint16ArrayCid: {
+      Register value = locs()->in(2).reg();
+      __ SmiUntag(value);
+      __ sh(value, element_address);
+      break;
+    }
     case kTypedDataInt32ArrayCid:
-    case kTypedDataUint32ArrayCid:
+    case kTypedDataUint32ArrayCid: {
+      if (value()->IsSmiValue()) {
+        ASSERT(RequiredInputRepresentation(2) == kTagged);
+        Register value = locs()->in(2).reg();
+        __ SmiUntag(value);
+        __ sw(value, element_address);
+      } else {
+        UNIMPLEMENTED();
+      }
+      break;
+    }
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
       UNIMPLEMENTED();
       break;
     default:
       UNREACHABLE();
   }
 }
 
@@ skipping 107 matching lines @@
 
       if (field_cid != kSmiCid) {
         __ beq(CMPRES, ZR, fail);
         __ LoadClassId(value_cid_reg, value_reg);
         __ LoadImmediate(TMP1, field_cid);
         __ subu(CMPRES, value_cid_reg, TMP1);
       }
 
       if (field().is_nullable() && (field_cid != kNullCid)) {
         __ beq(CMPRES, ZR, &ok);
-        __ LoadImmediate(TMP1, reinterpret_cast<intptr_t>(Object::null()));
-        __ subu(CMPRES, value_reg, TMP1);
+        __ subu(CMPRES, value_reg, NULLREG);
       }
 
       if (ok_is_fall_through) {
         __ bne(CMPRES, ZR, fail);
       } else {
         __ beq(CMPRES, ZR, &ok);
       }
     } else {
       // Both value's and field's class id is known.
       if ((value_cid != field_cid) && (value_cid != nullability)) {
@@ skipping 186 matching lines @@
   // (or null).
   if (!type_arguments().IsUninstantiatedIdentity() &&
       !type_arguments().CanShareInstantiatorTypeArguments(
           instantiator_class())) {
     // If the instantiator is null and if the type argument vector
     // instantiated from null becomes a vector of dynamic, then use null as
     // the type arguments.
     Label type_arguments_instantiated;
     const intptr_t len = type_arguments().Length();
     if (type_arguments().IsRawInstantiatedRaw(len)) {
-      __ BranchEqual(instantiator_reg,
-                     reinterpret_cast<intptr_t>(Object::null()),
-                     &type_arguments_instantiated);
+      __ beq(instantiator_reg, NULLREG, &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));
     // Push instantiator type arguments.
     __ sw(instantiator_reg, Address(SP, 0 * kWordSize));
@@ skipping 34 matching lines @@
   // instantiator_reg is the instantiator type argument vector, i.e. an
   // AbstractTypeArguments object (or null).
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments.
   Label type_arguments_instantiated;
   ASSERT(type_arguments().IsRawInstantiatedRaw(type_arguments().Length()));
-  __ BranchEqual(instantiator_reg,
-                 reinterpret_cast<intptr_t>(Object::null()),
-                 &type_arguments_instantiated);
+  __ beq(instantiator_reg, NULLREG, &type_arguments_instantiated);
   // Instantiate non-null type arguments.
   // In the non-factory case, we rely on the allocation stub to
   // instantiate the type arguments.
   __ LoadObject(result_reg, type_arguments());
   // result_reg: uninstantiated type arguments.
   __ Bind(&type_arguments_instantiated);
 
   // result_reg: uninstantiated or instantiated type arguments.
 }
 
@@ skipping 19 matching lines @@
   // (or null).
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
 
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments and do not pass the instantiator.
   ASSERT(type_arguments().IsRawInstantiatedRaw(type_arguments().Length()));
   Label instantiator_not_null;
-  __ BranchNotEqual(instantiator_reg,
-      reinterpret_cast<intptr_t>(Object::null()), &instantiator_not_null);
+  __ bne(instantiator_reg, NULLREG, &instantiator_not_null);
   // Null was used in VisitExtractConstructorTypeArguments as the
   // instantiated type arguments, no proper instantiator needed.
   __ LoadImmediate(instantiator_reg,
                    Smi::RawValue(StubCode::kNoInstantiator));
   __ Bind(&instantiator_not_null);
   // instantiator_reg: instantiator or kNoInstantiator.
 }
 
 
 LocationSummary* AllocateContextInstr::MakeLocationSummary() const {
@@ skipping 53 matching lines @@
 
   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(T0, RA);  // Save return adress.
+  __ 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(T1, RA);  // Save PC of the following mov.
+  __ delay_slot()->mov(CMPRES, RA);  // Save PC of the following mov.
 
   // Calculate offset of pool pointer from the PC.
   const intptr_t object_pool_pc_dist =
      Instructions::HeaderSize() - Instructions::object_pool_offset() +
      compiler->assembler()->CodeSize();
 
   __ Bind(&next);
-  __ mov(RA, T0);  // Restore return address.
-  __ lw(PP, Address(T1, -object_pool_pc_dist));
+  __ mov(RA, TMP);  // Restore return address.
+  __ lw(PP, Address(CMPRES, -object_pool_pc_dist));
 }
 
 
 LocationSummary* CheckStackOverflowInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs,
                           kNumTemps,
                           LocationSummary::kCallOnSlowPath);
@@ skipping 42 matching lines @@
   __ Bind(slow_path->exit_label());
 }
 
 
 LocationSummary* BinarySmiOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (op_kind() == Token::kTRUNCDIV) {
     UNIMPLEMENTED();
     return NULL;
   } else {
-    const intptr_t kNumTemps = 0;
+    const intptr_t kNumTemps = op_kind() == Token::kADD ? 1 : 0;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RegisterOrSmiConstant(right()));
     if (op_kind() == Token::kADD) {
       // Need an extra temp for the overflow detection code.
       summary->set_temp(0, Location::RequiresRegister());
     }
     // We make use of 3-operand instructions by not requiring result register
     // to be identical to first input register as on Intel.
@@ skipping 631 matching lines @@
     summary->AddTemp(Location::RequiresRegister());
   }
   return summary;
 }
 
 
 void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (null_check()) {
     Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                           kDeoptCheckClass);
-    __ BranchEqual(locs()->in(0).reg(),
-                  reinterpret_cast<intptr_t>(Object::null()), deopt);
+    __ beq(locs()->in(0).reg(), NULLREG, deopt);
     return;
   }
 
   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;
@@ skipping 232 matching lines @@
 }
 
 
 // The comparison result is in CMPRES.
 void ControlInstruction::EmitBranchOnCondition(FlowGraphCompiler* compiler,
                                                Condition true_condition) {
   __ TraceSimMsg("ControlInstruction::EmitBranchOnCondition");
   if (compiler->CanFallThroughTo(false_successor())) {
     // If the next block is the false successor we will fall through to it.
     Label* label = compiler->GetJumpLabel(true_successor());
-    switch (true_condition) {
-      case EQ: __ beq(CMPRES, ZR, label); break;
-      case NE: __ bne(CMPRES, ZR, label); break;
-      case GT: __ bgtz(CMPRES, label); break;
-      case GE: __ bgez(CMPRES, label); break;
-      case LT: __ bltz(CMPRES, label); break;
-      case LE: __ blez(CMPRES, label); break;
-      default:
-        UNREACHABLE();
-        break;
-    }
+    EmitBranchAfterCompare(compiler, true_condition, label);
   } else {
     // If the next block is the true successor we negate comparison and fall
     // through to it.
     Condition false_condition = NegateCondition(true_condition);
     Label* label = compiler->GetJumpLabel(false_successor());
-    switch (false_condition) {
-      case EQ: __ beq(CMPRES, ZR, label); break;
-      case NE: __ bne(CMPRES, ZR, label); break;
-      case GT: __ bgtz(CMPRES, label); break;
-      case GE: __ bgez(CMPRES, label); break;
-      case LT: __ bltz(CMPRES, label); break;
-      case LE: __ blez(CMPRES, label); break;
-      default:
-        UNREACHABLE();
-        break;
-    }
+    EmitBranchAfterCompare(compiler, false_condition, label);
     // Fall through or jump to the true successor.
     if (!compiler->CanFallThroughTo(true_successor())) {
       __ b(compiler->GetJumpLabel(true_successor()));
     }
   }
 }
 
 
 LocationSummary* CurrentContextInstr::MakeLocationSummary() const {
   return LocationSummary::Make(0,
@@ skipping 149 matching lines @@
   locs->set_in(1, Location::RequiresRegister());
   return locs;
 }
 
 
 void StoreVMFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value_reg = locs()->in(0).reg();
   Register dest_reg = locs()->in(1).reg();
 
   if (value()->NeedsStoreBuffer()) {
-    __ StoreIntoObject(dest_reg, FieldAddress(dest_reg, offset_in_bytes()),
-                       value_reg);
+    __ StoreIntoObject(dest_reg,
+        FieldAddress(dest_reg, offset_in_bytes()), value_reg);
   } else {
-    __ StoreIntoObjectNoBarrier(
-        dest_reg, FieldAddress(dest_reg, offset_in_bytes()), value_reg);
+    __ StoreIntoObjectNoBarrier(dest_reg,
+        FieldAddress(dest_reg, offset_in_bytes()), value_reg);
   }
 }
 
 
 LocationSummary* AllocateObjectInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 23 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS