Reduce register pressure on ARM, ARM64, and MIPS.

runtime/vm/intermediate_language_arm.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_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 1433 matching lines @@
                         : Location::RegisterOrConstant(value()));
       break;
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kOneByteStringCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
-      locs->set_in(2, Location::WritableRegister());
+      locs->set_in(2, Location::RequiresRegister());
       break;
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
-      // For smis, use a writable register because the value must be untagged
-      // before storing. Mints are stored in register pairs.
+      // Smis are untagged in TMP register. Mints are stored in register pairs.
       if (value()->IsSmiValue()) {
-        locs->set_in(2, Location::WritableRegister());
+        locs->set_in(2, Location::RequiresRegister());
       } else {
         // We only move the lower 32-bits so we don't care where the high bits
         // are located.
         locs->set_in(2, Location::Pair(Location::RequiresRegister(),
                                        Location::Any()));
       }
       break;
     case kTypedDataFloat32ArrayCid:
       // Need low register (<= Q7).
       locs->set_in(2, Location::FpuRegisterLocation(Q7));
@@ skipping 41 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(IP, static_cast<int8_t>(constant.Value()));
         __ strb(IP, element_address);
       } else {
         const Register value = locs()->in(2).reg();
-        __ SmiUntag(value);
-        __ strb(value, element_address);
+        __ SmiUntag(IP, value);
+        __ strb(IP, 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(IP, static_cast<int8_t>(value));
         __ strb(IP, element_address);
       } else {
         const Register value = locs()->in(2).reg();
-        Label store_value;
-        __ SmiUntag(value);
-        __ cmp(value, Operand(0xFF));
+        __ LoadImmediate(IP, 0x1FE);  // Smi 0xFF.
+        __ cmp(value, Operand(IP));  // Compare Smi value and smi 0xFF.
         // Clamp to 0x00 or 0xFF respectively.
-        __ b(&store_value, LS);
-        __ mov(value, Operand(0x00), LE);
-        __ mov(value, Operand(0xFF), GT);
-        __ Bind(&store_value);
-        __ strb(value, element_address);
+        __ mov(IP, Operand(0), LE);  // IP = value <= 0x1FE ? 0 : 0x1FE.
+        __ mov(IP, Operand(value), LS);  // IP = value in range ? value : IP.
+        __ SmiUntag(IP);
+        __ strb(IP, element_address);
       }
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       const Register value = locs()->in(2).reg();
-      __ SmiUntag(value);
-      __ strh(value, element_address);
+      __ SmiUntag(IP, value);
+      __ strh(IP, element_address);
       break;
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid: {
       if (value()->IsSmiValue()) {
         ASSERT(RequiredInputRepresentation(2) == kTagged);
         const Register value = locs()->in(2).reg();
-        __ SmiUntag(value);
-        __ str(value, element_address);
+        __ SmiUntag(IP, value);
+        __ str(IP, element_address);
       } else {
         ASSERT(RequiredInputRepresentation(2) == kUnboxedMint);
         PairLocation* value_pair = locs()->in(2).AsPairLocation();
         Register value1 = value_pair->At(0).reg();
         __ str(value1, element_address);
       }
       break;
     }
     case kTypedDataFloat32ArrayCid: {
       const SRegister value_reg =
@@ skipping 1403 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) {
         __ cmp(right, Operand(reinterpret_cast<int32_t>(Smi::New(max_right))));
         __ b(deopt, CS);
       }
-      __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
+      __ SmiUntag(IP, right);
       __ Lsl(result, left, IP);
     }
     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 =
           (right_range == NULL) ||
           !right_range->IsWithin(0, RangeBoundary::kPlusInfinity);
       if (right_may_be_negative) {
         ASSERT(shift_left->CanDeoptimize());
         __ cmp(right, Operand(0));
         __ b(deopt, MI);
       }
 
       __ cmp(right, Operand(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
       __ mov(result, Operand(0), CS);
-      __ Asr(IP, right, kSmiTagSize, CC);  // SmiUntag right into IP if CC.
+      __ SmiUntag(IP, right, CC);  // SmiUntag right into IP if CC.
       __ Lsl(result, left, IP, CC);
     } else {
-      __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
+      __ SmiUntag(IP, right);
       __ Lsl(result, left, IP);
     }
   } else {
     if (right_needs_check) {
       ASSERT(shift_left->CanDeoptimize());
       __ cmp(right, Operand(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
       __ b(deopt, CS);
     }
     // Left is not a constant.
     // Check if count too large for handling it inlined.
-    __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
+    __ SmiUntag(IP, right);
     // Overflow test (preserve left, right, and IP);
     const Register temp = locs.temp(0).reg();
     __ Lsl(temp, left, IP);
     __ cmp(left, Operand(temp, ASR, IP));
     __ b(deopt, NE);  // Overflow.
     // Shift for result now we know there is no overflow.
     __ Lsl(result, left, IP);
   }
 }
 
@@ skipping 230 matching lines @@
     case Token::kSUB: {
       if (deopt == NULL) {
         __ sub(result, left, Operand(right));
       } else {
         __ subs(result, left, Operand(right));
         __ b(deopt, VS);
       }
       break;
     }
     case Token::kMUL: {
-      __ Asr(IP, left, kSmiTagSize);  // SmiUntag left into IP.
+      __ SmiUntag(IP, left);
       if (deopt == NULL) {
         __ mul(result, IP, right);
       } else {
         if (TargetCPUFeatures::arm_version() == ARMv7) {
           __ smull(result, IP, IP, right);
           // IP: result bits 32..63.
           __ cmp(IP, Operand(result, ASR, 31));
           __ b(deopt, NE);
         } else {
           const QRegister qtmp = locs()->temp(0).fpu_reg();
@@ skipping 21 matching lines @@
       break;
     }
     case Token::kTRUNCDIV: {
       if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
         // Handle divide by zero in runtime.
         __ cmp(right, Operand(0));
         __ b(deopt, EQ);
       }
       const Register temp = locs()->temp(0).reg();
       const DRegister dtemp = EvenDRegisterOf(locs()->temp(1).fpu_reg());
-      __ Asr(temp, left, kSmiTagSize);  // SmiUntag left into temp.
-      __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
+      __ SmiUntag(temp, left);
+      __ SmiUntag(IP, right);
 
       __ IntegerDivide(result, temp, IP, dtemp, DTMP);
 
       // Check the corner case of dividing the 'MIN_SMI' with -1, in which
       // case we cannot tag the result.
       __ CompareImmediate(result, 0x40000000);
       __ b(deopt, EQ);
       __ SmiTag(result);
       break;
     }
     case Token::kMOD: {
       if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
         // Handle divide by zero in runtime.
         __ cmp(right, Operand(0));
         __ b(deopt, EQ);
       }
       const Register temp = locs()->temp(0).reg();
       const DRegister dtemp = EvenDRegisterOf(locs()->temp(1).fpu_reg());
-      __ Asr(temp, left, kSmiTagSize);  // SmiUntag left into temp.
-      __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
+      __ SmiUntag(temp, left);
+      __ SmiUntag(IP, right);
 
       __ IntegerDivide(result, temp, IP, dtemp, DTMP);
 
-      __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
+      __ SmiUntag(IP, right);
       __ mls(result, IP, result, temp);  // result <- left - right * result
       __ SmiTag(result);
       //  res = left % right;
       //  if (res < 0) {
       //    if (right < 0) {
       //      res = res - right;
       //    } else {
       //      res = res + right;
       //    }
       //  }
       Label done;
       __ cmp(result, Operand(0));
       __ b(&done, GE);
       // Result is negative, adjust it.
       __ cmp(right, Operand(0));
       __ sub(result, result, Operand(right), LT);
       __ add(result, result, Operand(right), GE);
       __ Bind(&done);
       break;
     }
     case Token::kSHR: {
       if (CanDeoptimize()) {
         __ CompareImmediate(right, 0);
         __ b(deopt, LT);
       }
-      __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
+      __ SmiUntag(IP, right);
       // sarl operation masks the count to 5 bits.
       const intptr_t kCountLimit = 0x1F;
       if ((right_range == NULL) ||
           !right_range->IsWithin(RangeBoundary::kMinusInfinity, kCountLimit)) {
         __ CompareImmediate(IP, kCountLimit);
         __ LoadImmediate(IP, kCountLimit, GT);
       }
       const Register temp = locs()->temp(0).reg();
-      __ Asr(temp, left, kSmiTagSize);  // SmiUntag left into temp.
+      __ SmiUntag(temp, left);
       __ Asr(result, temp, IP);
       __ SmiTag(result);
       break;
     }
     case Token::kDIV: {
       // Dispatches to 'Double./'.
       // TODO(srdjan): Implement as conversion to double and double division.
       UNREACHABLE();
       break;
     }
@@ skipping 76 matching lines @@
   __ 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_temp = ((value_cid != kSmiCid) && (value_cid != kDoubleCid));
-  const bool needs_writable_input = (value_cid == kSmiCid);
   const intptr_t kNumTemps = needs_temp ? 1 : 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());
   if (needs_temp) summary->set_temp(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 = EvenDRegisterOf(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.
-    __ vmovsr(STMP, value);
+    __ SmiUntag(IP, value);
+    __ vmovsr(STMP, IP);
     __ vcvtdi(result, STMP);
   } else {
     Label* deopt = compiler->AddDeoptStub(deopt_id_,
                                           ICData::kDeoptBinaryDoubleOp);
     const Register temp = locs()->temp(0).reg();
     if (value_type->is_nullable() &&
         (value_type->ToNullableCid() == kDoubleCid)) {
       __ CompareImmediate(value, reinterpret_cast<intptr_t>(Object::null()));
       __ b(deopt, EQ);
       // It must be double now.
       __ LoadDFromOffset(result, value,
           Double::value_offset() - kHeapObjectTag);
     } else {
       Label is_smi, done;
       __ tst(value, Operand(kSmiTagMask));
       __ b(&is_smi, EQ);
       __ CompareClassId(value, kDoubleCid, temp);
       __ b(deopt, NE);
       __ LoadDFromOffset(result, value,
           Double::value_offset() - kHeapObjectTag);
       __ b(&done);
       __ Bind(&is_smi);
-      // TODO(regis): Why do we preserve value here but not above?
-      __ mov(IP, Operand(value, ASR, 1));  // Copy and untag.
+      __ SmiUntag(IP, value);
       __ vmovsr(STMP, IP);
       __ vcvtdi(result, STMP);
       __ Bind(&done);
     }
   }
 }
 
 
 LocationSummary* BoxFloat32x4Instr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
@@ skipping 1591 matching lines @@
   __ vnegd(result, value);
 }
 
 
 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) {
   const Register value = locs()->in(0).reg();
   const DRegister result = EvenDRegisterOf(locs()->out(0).fpu_reg());
-  __ SmiUntag(value);
-  __ vmovsr(STMP, value);
+  __ SmiUntag(IP, value);
+  __ vmovsr(STMP, IP);
   __ vcvtdi(result, STMP);
 }
 
 
 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 398 matching lines @@
     const 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.
       __ cmp(right, Operand(0));
       __ b(deopt, EQ);
     }
     const Register temp = locs()->temp(0).reg();
     const DRegister dtemp = EvenDRegisterOf(locs()->temp(1).fpu_reg());
 
-    __ Asr(temp, left, kSmiTagSize);  // SmiUntag left into temp.
-    __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
+    __ SmiUntag(temp, left);
+    __ SmiUntag(IP, right);
 
     __ IntegerDivide(result_div, temp, IP, dtemp, DTMP);
 
     // Check the corner case of dividing the 'MIN_SMI' with -1, in which
     // case we cannot tag the result.
     __ CompareImmediate(result_div, 0x40000000);
     __ b(deopt, EQ);
-    __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
+    __ SmiUntag(IP, right);
     // result_mod <- left - right * result_div.
     __ mls(result_mod, IP, result_div, temp);
     __ SmiTag(result_div);
     __ SmiTag(result_mod);
     // Correct MOD result:
     //  res = left % right;
     //  if (res < 0) {
     //    if (right < 0) {
     //      res = res - right;
     //    } else {
@@ skipping 817 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM