Reduce register pressure on ARM, ARM64, and 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 1326 matching lines @@
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kOneByteStringCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
-      locs->set_in(2, Location::WritableRegister());
+      locs->set_in(2, Location::RequiresRegister());
       break;
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:  // TODO(srdjan): Support Float64 constants.
     case kTypedDataInt32x4ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
       locs->set_in(2, Location::RequiresFpuRegister());
       break;
     default:
       UNREACHABLE();
       return NULL;
@@ skipping 32 matching lines @@
     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);
+        __ SmiUntag(TMP, value);
+        __ sb(TMP, element_address);
       }
       break;
     }
     case kTypedDataUint8ClampedArrayCid:
     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);
+        __ SmiUntag(TMP, value);
+        __ BranchUnsignedLess(TMP, 0xFF + 1, &store_value);
         __ LoadImmediate(TMP, 0xFF);
         __ slti(CMPRES1, value, Immediate(1));
         __ movn(TMP, ZR, CMPRES1);
-        __ mov(value, TMP);
         __ Bind(&store_value);
-        __ sb(value, element_address);
+        __ sb(TMP, element_address);
       }
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       Register value = locs()->in(2).reg();
-      __ SmiUntag(value);
-      __ sh(value, element_address);
+      __ SmiUntag(TMP, value);
+      __ sh(TMP, element_address);
       break;
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid: {
       if (value()->IsSmiValue()) {
         ASSERT(RequiredInputRepresentation(2) == kTagged);
         Register value = locs()->in(2).reg();
-        __ SmiUntag(value);
-        __ sw(value, element_address);
+        __ SmiUntag(TMP, value);
+        __ sw(TMP, element_address);
       } else {
         UNIMPLEMENTED();
       }
       break;
     }
     case kTypedDataFloat32ArrayCid: {
       FRegister value = EvenFRegisterOf(locs()->in(2).fpu_reg());
       __ swc1(value, element_address);
       break;
     }
@@ skipping 1241 matching lines @@
         return;
       }
       const intptr_t max_right = kSmiBits - Utils::HighestBit(left_int);
       const bool right_needs_check =
           (right_range == NULL) ||
           !right_range->IsWithin(0, max_right - 1);
       if (right_needs_check) {
         __ BranchUnsignedGreaterEqual(
             right, reinterpret_cast<int32_t>(Smi::New(max_right)), deopt);
       }
-      __ sra(TMP, right, kSmiTagMask);  // SmiUntag right into TMP.
+      __ SmiUntag(TMP, right);
       __ sllv(result, left, TMP);
     }
     return;
   }
 
   const bool right_needs_check =
       (right_range == NULL) || !right_range->IsWithin(0, (Smi::kBits - 1));
   if (is_truncating) {
     if (right_needs_check) {
       const bool right_may_be_negative =
@@ skipping 18 matching lines @@
     }
   } 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(temp, right, kSmiTagSize);  // SmiUntag right into temp.
+    __ SmiUntag(temp, right);
     // 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, temp);
   }
 }
 
 
@@ skipping 250 matching lines @@
       // No overflow check.
       __ xor_(result, left, right);
       break;
     }
     case Token::kTRUNCDIV: {
       if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
         // Handle divide by zero in runtime.
         __ beq(right, ZR, deopt);
       }
       Register temp = locs()->temp(0).reg();
-      __ sra(temp, left, kSmiTagSize);  // SmiUntag left into temp.
-      __ sra(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
+      __ SmiUntag(temp, left);
+      __ SmiUntag(TMP, right);
       __ 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::kMOD: {
       if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
         // Handle divide by zero in runtime.
         __ beq(right, ZR, deopt);
       }
       Register temp = locs()->temp(0).reg();
-      __ sra(temp, left, kSmiTagSize);  // SmiUntag left into temp.
-      __ sra(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
+      __ SmiUntag(temp, left);
+      __ SmiUntag(TMP, right);
       __ div(temp, TMP);
       __ mfhi(result);
       //  res = left % right;
       //  if (res < 0) {
       //    if (right < 0) {
       //      res = res - right;
       //    } else {
       //      res = res + right;
       //    }
       //  }
@@ skipping 15 matching lines @@
       }
       __ Bind(&done);
       __ SmiTag(result);
       break;
     }
     case Token::kSHR: {
       Register temp = locs()->temp(0).reg();
       if (CanDeoptimize()) {
         __ bltz(right, deopt);
       }
-      __ sra(temp, right, kSmiTagSize);  // SmiUntag right into temp.
+      __ SmiUntag(temp, right);
       // sra operation masks the count to 5 bits.
       const intptr_t kCountLimit = 0x1F;
       if ((right_range == NULL) ||
           !right_range->IsWithin(RangeBoundary::kMinusInfinity, kCountLimit)) {
         Label ok;
         __ BranchSignedLessEqual(temp, kCountLimit, &ok);
         __ LoadImmediate(temp, kCountLimit);
         __ Bind(&ok);
       }
 
-      __ sra(CMPRES1, left, kSmiTagSize);  // SmiUntag left into CMPRES1.
+      __ SmiUntag(CMPRES1, left);
       __ 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;
     }
@@ skipping 74 matching lines @@
                  out_reg,
                  locs()->temp(0).reg());
   __ Bind(slow_path->exit_label());
   __ StoreDToOffset(value, out_reg, Double::value_offset() - kHeapObjectTag);
 }
 
 
 LocationSummary* UnboxDoubleInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
   const intptr_t kNumInputs = 1;
-  const intptr_t value_cid = value()->Type()->ToCid();
-  const bool needs_writable_input = (value_cid == kSmiCid);
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  summary->set_in(0, needs_writable_input
-                     ? Location::WritableRegister()
-                     : Location::RequiresRegister());
+  summary->set_in(0, Location::RequiresRegister());
   summary->set_out(0, Location::RequiresFpuRegister());
   return summary;
 }
 
 
 void UnboxDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   CompileType* value_type = value()->Type();
   const intptr_t value_cid = value_type->ToCid();
   const Register value = locs()->in(0).reg();
   const DRegister result = locs()->out(0).fpu_reg();
 
   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);
+    __ SmiUntag(TMP, value);
+    __ mtc1(TMP, STMP1);
     __ cvtdw(result, STMP1);
   } else {
     Label* deopt = compiler->AddDeoptStub(deopt_id_,
                                           ICData::kDeoptBinaryDoubleOp);
     if (value_type->is_nullable() &&
         (value_type->ToNullableCid() == kDoubleCid)) {
       __ BranchEqual(value, reinterpret_cast<int32_t>(Object::null()), deopt);
       // It must be double now.
       __ LoadDFromOffset(result, value,
           Double::value_offset() - kHeapObjectTag);
     } else {
       Label is_smi, done;
 
       __ 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);
+      __ SmiUntag(TMP, value);
       __ mtc1(TMP, STMP1);
       __ cvtdw(result, STMP1);
       __ Bind(&done);
     }
   }
 }
 
 
 LocationSummary* BoxFloat32x4Instr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
@@ skipping 642 matching lines @@
 }
 
 
 
 LocationSummary* SmiToDoubleInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* result = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  result->set_in(0, Location::WritableRegister());
+  result->set_in(0, Location::RequiresRegister());
   result->set_out(0, Location::RequiresFpuRegister());
   return result;
 }
 
 
 void SmiToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   FpuRegister result = locs()->out(0).fpu_reg();
-  __ SmiUntag(value);
-  __ mtc1(value, STMP1);
+  __ SmiUntag(TMP, value);
+  __ mtc1(TMP, STMP1);
   __ cvtdw(result, STMP1);
 }
 
 
 LocationSummary* DoubleToIntegerInstr::MakeLocationSummary(Isolate* isolate,
                                                            bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* result = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
@@ skipping 337 matching lines @@
     Register temp = locs()->temp(0).reg();
     ASSERT(locs()->out(0).IsPairLocation());
     PairLocation* pair = locs()->out(0).AsPairLocation();
     Register result_div = pair->At(0).reg();
     Register result_mod = pair->At(1).reg();
     Range* right_range = InputAt(1)->definition()->range();
     if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
       // Handle divide by zero in runtime.
       __ beq(right, ZR, deopt);
     }
-    __ sra(temp, left, kSmiTagSize);  // SmiUntag left into temp.
-    __ sra(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
+    __ SmiUntag(temp, left);
+    __ SmiUntag(TMP, right);
     __ div(temp, TMP);
     __ mflo(result_div);
     __ mfhi(result_mod);
     // Check the corner case of dividing the 'MIN_SMI' with -1, in which
     // case we cannot tag the result.
     __ BranchEqual(result_div, 0x40000000, deopt);
     //  res = left % right;
     //  if (res < 0) {
     //    if (right < 0) {
     //      res = res - right;
@@ skipping 492 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS