Reduce register pressure on ARM, ARM64, and MIPS.

runtime/vm/intermediate_language_arm64.cc

 // Copyright (c) 2014, 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_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 1191 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());
-      break;
     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.
       locs->set_in(2, Location::RequiresFpuRegister());
       break;
     case kTypedDataInt32x4ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
     case kTypedDataFloat64x2ArrayCid:
       locs->set_in(2, Location::RequiresFpuRegister());
       break;
@@ skipping 34 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()), PP);
         __ str(TMP, element_address, kUnsignedByte);
       } else {
         const Register value = locs()->in(2).reg();
-        __ SmiUntag(value);
-        __ str(value, element_address, kUnsignedByte);
+        __ SmiUntag(TMP, value);
+        __ str(TMP, element_address, kUnsignedByte);
       }
       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), PP);
         __ str(TMP, element_address, kUnsignedByte);
       } else {
         const Register value = locs()->in(2).reg();
-        Label store_value;
-        __ SmiUntag(value);
-        __ CompareImmediate(value, 0xFF, PP);
+        __ CompareImmediate(value, 0x1FE, PP);  // Smi value and smi 0xFF.
         // Clamp to 0x00 or 0xFF respectively.
-        __ b(&store_value, LS);
-        __ LoadImmediate(TMP, 0x00, PP);
-        __ LoadImmediate(TMP2, 0xFF, PP);
-        __ csel(value, TMP, value, LE);
-        __ csel(value, TMP2, value, GT);
-        __ Bind(&store_value);
-        __ str(value, element_address, kUnsignedByte);
+        __ csetm(TMP, GT);  // TMP = value > 0x1FE ? -1 : 0.
+        __ csel(TMP, value, TMP, LS);  // TMP = value in range ? value : TMP.
+        __ SmiUntag(TMP);
+        __ str(TMP, element_address, kUnsignedByte);
       }
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       const Register value = locs()->in(2).reg();
-      __ SmiUntag(value);
-      __ str(value, element_address, kUnsignedHalfword);
+      __ SmiUntag(TMP, value);
+      __ str(TMP, element_address, kUnsignedHalfword);
       break;
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid: {
       const Register value = locs()->in(2).reg();
-      __ SmiUntag(value);
-      __ str(value, element_address, kUnsignedWord);
+      __ SmiUntag(TMP, value);
+      __ str(TMP, element_address, kUnsignedWord);
       break;
     }
     case kTypedDataFloat32ArrayCid: {
       const VRegister value_reg = locs()->in(2).fpu_reg();
       __ fstrs(value_reg, element_address);
       break;
     }
     case kTypedDataFloat64ArrayCid: {
       const VRegister value_reg = locs()->in(2).fpu_reg();
       __ fstrd(value_reg, element_address);
@@ skipping 1309 matching lines @@
       }
       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) {
         __ CompareImmediate(right,
             reinterpret_cast<int64_t>(Smi::New(max_right)), PP);
         __ b(deopt, CS);
       }
-      __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
+      __ SmiUntag(TMP, right);
       __ lslv(result, left, TMP);
     }
     if (FLAG_throw_on_javascript_int_overflow) {
       EmitJavascriptOverflowCheck(compiler, shift_left->range(), deopt, result);
     }
     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());
         __ CompareRegisters(right, ZR);
         __ b(deopt, MI);
       }
 
       __ CompareImmediate(
           right, reinterpret_cast<int64_t>(Smi::New(Smi::kBits)), PP);
       __ csel(result, ZR, result, CS);
-      __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
+      __ SmiUntag(TMP, right);
       __ lslv(TMP, left, TMP);
       __ csel(result, TMP, result, CC);
     } else {
-      __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
+      __ SmiUntag(TMP, right);
       __ lslv(result, left, TMP);
     }
   } else {
     if (right_needs_check) {
       ASSERT(shift_left->CanDeoptimize());
       __ CompareImmediate(
           right, reinterpret_cast<int64_t>(Smi::New(Smi::kBits)), PP);
       __ b(deopt, CS);
     }
     // Left is not a constant.
     // Check if count too large for handling it inlined.
-    __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
+    __ SmiUntag(TMP, right);
     // Overflow test (preserve left, right, and TMP);
     const Register temp = locs.temp(0).reg();
     __ lslv(temp, left, TMP);
     __ asrv(TMP2, temp, TMP);
     __ CompareRegisters(left, TMP2);
     __ b(deopt, NE);  // Overflow.
     // Shift for result now we know there is no overflow.
     __ lslv(result, left, TMP);
   }
   if (FLAG_throw_on_javascript_int_overflow) {
@@ skipping 195 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(TMP, left, kSmiTagSize);  // SmiUntag left into TMP.
+      __ SmiUntag(TMP, left);
       if (deopt == NULL) {
         __ mul(result, TMP, right);
       } else {
           __ mul(result, TMP, right);
           __ smulh(TMP, TMP, right);
           // TMP: result bits 64..127.
           __ cmp(TMP, Operand(result, ASR, 63));
           __ b(deopt, NE);
       }
       break;
@@ skipping 13 matching lines @@
       __ eor(result, left, Operand(right));
       break;
     }
     case Token::kTRUNCDIV: {
       if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
         // Handle divide by zero in runtime.
         __ CompareRegisters(right, ZR);
         __ b(deopt, EQ);
       }
       const Register temp = TMP2;
-      __ Asr(temp, left, kSmiTagSize);  // SmiUntag left into temp.
-      __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right into IP.
+      __ SmiUntag(temp, left);
+      __ SmiUntag(TMP, right);
 
       __ sdiv(result, temp, TMP);
 
       // Check the corner case of dividing the 'MIN_SMI' with -1, in which
       // case we cannot tag the result.
       __ CompareImmediate(result, 0x4000000000000000LL, kNoPP);
       __ b(deopt, EQ);
       __ SmiTag(result);
       break;
     }
     case Token::kMOD: {
       if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
         // Handle divide by zero in runtime.
         __ CompareRegisters(right, ZR);
         __ b(deopt, EQ);
       }
       const Register temp = TMP2;
-      __ Asr(temp, left, kSmiTagSize);  // SmiUntag left into temp.
-      __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right into IP.
+      __ SmiUntag(temp, left);
+      __ SmiUntag(TMP, right);
 
       __ sdiv(result, temp, TMP);
 
-      __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right into IP.
+      __ SmiUntag(TMP, right);
       __ msub(result, TMP, 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;
       __ CompareRegisters(result, ZR);
       __ b(&done, GE);
       // Result is negative, adjust it.
       __ CompareRegisters(right, ZR);
       __ sub(TMP, result, Operand(right));
       __ add(result, result, Operand(right));
       __ csel(result, TMP, result, LT);
       __ Bind(&done);
       break;
     }
     case Token::kSHR: {
       if (CanDeoptimize()) {
         __ CompareRegisters(right, ZR);
         __ b(deopt, LT);
       }
-      __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
+      __ SmiUntag(TMP, right);
       // sarl operation masks the count to 6 bits.
       const intptr_t kCountLimit = 0x3F;
       if ((right_range == NULL) ||
           !right_range->IsWithin(RangeBoundary::kMinusInfinity, kCountLimit)) {
         __ LoadImmediate(TMP2, kCountLimit, PP);
         __ CompareRegisters(TMP, TMP2);
         __ csel(TMP, TMP2, TMP, GT);
       }
       const Register temp = locs()->temp(0).reg();
-      __ Asr(temp, left, kSmiTagSize);  // SmiUntag left into temp.
+      __ SmiUntag(temp, left);
       __ asrv(result, temp, TMP);
       __ SmiTag(result);
       break;
     }
     case Token::kDIV: {
       // Dispatches to 'Double./'.
       // TODO(srdjan): Implement as conversion to double and double division.
       UNREACHABLE();
       break;
     }
@@ skipping 1498 matching lines @@
   __ fnegd(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 VRegister result = locs()->out(0).fpu_reg();
-  __ SmiUntag(value);
-  __ scvtfd(result, value);
+  __ SmiUntag(TMP, value);
+  __ scvtfd(result, TMP);
 }
 
 
 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);
   result->set_in(0, Location::RegisterLocation(R1));
@@ skipping 348 matching lines @@
     const PairLocation* pair = locs()->out(0).AsPairLocation();
     const Register result_div = pair->At(0).reg();
     const Register result_mod = pair->At(1).reg();
     const Range* right_range = InputAt(1)->definition()->range();
     if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
       // Handle divide by zero in runtime.
       __ CompareRegisters(right, ZR);
       __ b(deopt, EQ);
     }
 
-    __ Asr(result_mod, left, kSmiTagSize);  // SmiUntag left.
-    __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right.
+    __ SmiUntag(result_mod, left);
+    __ SmiUntag(TMP, right);
 
     __ sdiv(result_div, result_mod, TMP);
 
     // Check the corner case of dividing the 'MIN_SMI' with -1, in which
     // case we cannot tag the result.
     __ CompareImmediate(result_div, 0x4000000000000000, PP);
     __ b(deopt, EQ);
     // result_mod <- left - right * result_div.
     __ msub(result_mod, TMP, result_div, result_mod);
     __ SmiTag(result_div);
@@ skipping 493 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64