Re-assign registers on ARM so PP and CODE_REG are below R7 (FP on iOS).

runtime/vm/intrinsifier_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/intrinsifier.h"
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/regexp_assembler.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, interpret_irregexp);
 
 // When entering intrinsics code:
-// R5: IC Data
 // R4: Arguments descriptor
 // LR: Return address
-// The R5, R4 registers can be destroyed only if there is no slow-path, i.e.
+// The R4 register can be destroyed only if there is no slow-path, i.e.
 // if the intrinsified method always executes a return.
 // The FP register should not be modified, because it is used by the profiler.
-// The THR register (see constants_arm.h) must be preserved.
+// The PP and THR registers (see constants_arm.h) must be preserved.
 
 #define __ assembler->
 
 
 intptr_t Intrinsifier::ParameterSlotFromSp() { return -1; }
 
 
 // Intrinsify only for Smi value and index. Non-smi values need a store buffer
 // update. Array length is always a Smi.
 void Intrinsifier::ObjectArraySetIndexed(Assembler* assembler) {
@@ skipping 168 matching lines @@
   __ ldr(R3, Address(SP, kArrayLengthStackOffset));  /* Array length. */       \
   __ InitializeFieldNoBarrier(R0,                                              \
                               FieldAddress(R0, type_name::length_offset()),    \
                               R3);                                             \
   /* Initialize all array elements to 0. */                                    \
   /* R0: new object start as a tagged pointer. */                              \
   /* R1: new object end address. */                                            \
   /* R2: allocation size. */                                                   \
   /* R3: iterator which initially points to the start of the variable */       \
   /* R4: allocation stats address */                                           \
-  /* R6, R7: zero. */                                                          \
+  /* R8, R9: zero. */                                                          \
   /* data area to be initialized. */                                           \
-  __ LoadImmediate(R6, 0);                                                     \
-  __ mov(R7, Operand(R6));                                                     \
+  __ LoadImmediate(R8, 0);                                                     \
+  __ mov(R9, Operand(R8));                                                     \
   __ AddImmediate(R3, R0, sizeof(Raw##type_name) - 1);                         \
   Label init_loop;                                                             \
   __ Bind(&init_loop);                                                         \
   __ AddImmediate(R3, 2 * kWordSize);                                          \
   __ cmp(R3, Operand(R1));                                                     \
-  __ strd(R6, R7, R3, -2 * kWordSize, LS);                                     \
+  __ strd(R8, R9, R3, -2 * kWordSize, LS);                                     \
   __ b(&init_loop, CC);                                                        \
-  __ str(R6, Address(R3, -2 * kWordSize), HI);                                 \
+  __ str(R8, Address(R3, -2 * kWordSize), HI);                                 \
                                                                                \
   __ IncrementAllocationStatsWithSize(R4, R2, space);                          \
   __ Ret();                                                                    \
   __ Bind(&fall_through);                                                      \
 
 
 static int GetScaleFactor(intptr_t size) {
   switch (size) {
     case 1: return 0;
     case 2: return 1;
@@ skipping 66 matching lines @@
   __ subs(R0, R1, Operand(R0));  // Subtract.
   __ bx(LR, VC);  // Return if no overflow.
   // Otherwise fall through.
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_mulFromInteger(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);  // checks two smis
-  __ SmiUntag(R0);  // Untags R6. We only want result shifted by one.
+  __ SmiUntag(R0);  // Untags R0. We only want result shifted by one.
   __ smull(R0, IP, R0, R1);  // IP:R0 <- R0 * R1.
   __ cmp(IP, Operand(R0, ASR, 31));
   __ bx(LR, EQ);
   __ Bind(&fall_through);  // Fall through on overflow.
 }
 
 
 void Intrinsifier::Integer_mul(Assembler* assembler) {
   Integer_mulFromInteger(assembler);
 }
@@ skipping 172 matching lines @@
 
 void Intrinsifier::Integer_bitXor(Assembler* assembler) {
   Integer_bitXorFromInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_shl(Assembler* assembler) {
   ASSERT(kSmiTagShift == 1);
   ASSERT(kSmiTag == 0);
   Label fall_through;
-  __ Push(R10);
+  __ Push(R6);
   TestBothArgumentsSmis(assembler, &fall_through);
   __ CompareImmediate(R0, Smi::RawValue(Smi::kBits));
   __ b(&fall_through, HI);
 
   __ SmiUntag(R0);
 
   // Check for overflow by shifting left and shifting back arithmetically.
   // If the result is different from the original, there was overflow.
   __ mov(IP, Operand(R1, LSL, R0));
   __ cmp(R1, Operand(IP, ASR, R0));
 
   // No overflow, result in R0.
   __ mov(R0, Operand(R1, LSL, R0), EQ);
   __ bx(LR, EQ);
 
   // Arguments are Smi but the shift produced an overflow to Mint.
   __ CompareImmediate(R1, 0);
   __ b(&fall_through, LT);
   __ SmiUntag(R1);
 
   // Pull off high bits that will be shifted off of R1 by making a mask
   // ((1 << R0) - 1), shifting it to the left, masking R1, then shifting back.
   // high bits = (((1 << R0) - 1) << (32 - R0)) & R1) >> (32 - R0)
   // lo bits = R1 << R0
   __ LoadImmediate(R7, 1);
   __ mov(R7, Operand(R7, LSL, R0));  // R7 <- 1 << R0
   __ sub(R7, R7, Operand(1));  // R7 <- R7 - 1
-  __ rsb(R10, R0, Operand(32));  // R10 <- 32 - R0
-  __ mov(R7, Operand(R7, LSL, R10));  // R7 <- R7 << R10
+  __ rsb(R6, R0, Operand(32));  // R6 <- 32 - R0
+  __ mov(R7, Operand(R7, LSL, R6));  // R7 <- R7 << R6
   __ and_(R7, R1, Operand(R7));  // R7 <- R7 & R1
-  __ mov(R7, Operand(R7, LSR, R10));  // R7 <- R7 >> R10
+  __ mov(R7, Operand(R7, LSR, R6));  // R7 <- R7 >> R6
   // Now R7 has the bits that fall off of R1 on a left shift.
   __ mov(R1, Operand(R1, LSL, R0));  // R1 gets the low bits.
 
   const Class& mint_class = Class::Handle(
       Isolate::Current()->object_store()->mint_class());
   __ TryAllocate(mint_class, &fall_through, R0, R2);
 
 
   __ str(R1, FieldAddress(R0, Mint::value_offset()));
   __ str(R7, FieldAddress(R0, Mint::value_offset() + kWordSize));
-  __ Pop(R10);
+  __ Pop(R6);
   __ Ret();
   __ Bind(&fall_through);
-  ASSERT(CODE_REG == R10);
-  __ Pop(R10);
+  ASSERT(CODE_REG == R6);
+  __ Pop(R6);
 }
 
 
 static void Get64SmiOrMint(Assembler* assembler,
                            Register res_hi,
                            Register res_lo,
                            Register reg,
                            Label* not_smi_or_mint) {
   Label not_smi, done;
   __ tst(reg, Operand(kSmiTagMask));
@@ skipping 48 matching lines @@
       break;
     default:
       UNREACHABLE();
       hi_true_cond = hi_false_cond = lo_false_cond = VS;
   }
 
   __ Bind(&try_mint_smi);
   // Get left as 64 bit integer.
   Get64SmiOrMint(assembler, R3, R2, R1, &fall_through);
   // Get right as 64 bit integer.
-  Get64SmiOrMint(assembler, R7, R6, R0, &fall_through);
+  Get64SmiOrMint(assembler, R7, R8, R0, &fall_through);
   // R3: left high.
   // R2: left low.
   // R7: right high.
-  // R6: right low.
+  // R8: right low.
 
   __ cmp(R3, Operand(R7));  // Compare left hi, right high.
   __ b(&is_false, hi_false_cond);
   __ b(&is_true, hi_true_cond);
-  __ cmp(R2, Operand(R6));  // Compare left lo, right lo.
+  __ cmp(R2, Operand(R8));  // Compare left lo, right lo.
   __ b(&is_false, lo_false_cond);
   // Else is true.
   __ b(&is_true);
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_greaterThanFromInt(Assembler* assembler) {
   CompareIntegers(assembler, LT);
@@ skipping 116 matching lines @@
   __ rsb(R0, R0, Operand(32));
   __ SmiTag(R0);
   __ Ret();
 }
 
 
 void Intrinsifier::Bigint_lsh(Assembler* assembler) {
   // static void _lsh(Uint32List x_digits, int x_used, int n,
   //                  Uint32List r_digits)
 
-  // R2 = x_used, R3 = x_digits, x_used > 0, x_used is Smi.
-  __ ldrd(R2, R3, SP, 2 * kWordSize);
-  // R4 = r_digits, R5 = n, n is Smi, n % _DIGIT_BITS != 0.
-  __ ldrd(R4, R5, SP, 0 * kWordSize);
-  __ SmiUntag(R5);
-  // R0 = n ~/ _DIGIT_BITS
-  __ Asr(R0, R5, Operand(5));
-  // R6 = &x_digits[0]
-  __ add(R6, R3, Operand(TypedData::data_offset() - kHeapObjectTag));
+  // R0 = x_used, R1 = x_digits, x_used > 0, x_used is Smi.
+  __ ldrd(R0, R1, SP, 2 * kWordSize);
+  // R2 = r_digits, R3 = n, n is Smi, n % _DIGIT_BITS != 0.
+  __ ldrd(R2, R3, SP, 0 * kWordSize);
+  __ SmiUntag(R3);
+  // R4 = n ~/ _DIGIT_BITS
+  __ Asr(R4, R3, Operand(5));
+  // R8 = &x_digits[0]
+  __ add(R8, R1, Operand(TypedData::data_offset() - kHeapObjectTag));
   // R7 = &x_digits[x_used]
-  __ add(R7, R6, Operand(R2, LSL, 1));
-  // R10 = &r_digits[1]
-  __ add(R10, R4, Operand(TypedData::data_offset() - kHeapObjectTag +
+  __ add(R7, R8, Operand(R0, LSL, 1));
+  // R6 = &r_digits[1]
+  __ add(R6, R2, Operand(TypedData::data_offset() - kHeapObjectTag +
                          Bigint::kBytesPerDigit));
-  // R10 = &r_digits[x_used + n ~/ _DIGIT_BITS + 1]
-  __ add(R0, R0, Operand(R2, ASR, 1));
-  __ add(R10, R10, Operand(R0, LSL, 2));
-  // R3 = n % _DIGIT_BITS
-  __ and_(R3, R5, Operand(31));
-  // R2 = 32 - R3
-  __ rsb(R2, R3, Operand(32));
-  __ mov(R1, Operand(0));
+  // R6 = &r_digits[x_used + n ~/ _DIGIT_BITS + 1]
+  __ add(R4, R4, Operand(R0, ASR, 1));
+  __ add(R6, R6, Operand(R4, LSL, 2));
+  // R1 = n % _DIGIT_BITS
+  __ and_(R1, R3, Operand(31));
+  // R0 = 32 - R1
+  __ rsb(R0, R1, Operand(32));
+  __ mov(R9, Operand(0));
   Label loop;
   __ Bind(&loop);
-  __ ldr(R0, Address(R7, -Bigint::kBytesPerDigit, Address::PreIndex));
-  __ orr(R1, R1, Operand(R0, LSR, R2));
-  __ str(R1, Address(R10, -Bigint::kBytesPerDigit, Address::PreIndex));
-  __ mov(R1, Operand(R0, LSL, R3));
-  __ teq(R7, Operand(R6));
+  __ ldr(R4, Address(R7, -Bigint::kBytesPerDigit, Address::PreIndex));
+  __ orr(R9, R9, Operand(R4, LSR, R0));
+  __ str(R9, Address(R6, -Bigint::kBytesPerDigit, Address::PreIndex));
+  __ mov(R9, Operand(R4, LSL, R1));
+  __ teq(R7, Operand(R8));
   __ b(&loop, NE);
-  __ str(R1, Address(R10, -Bigint::kBytesPerDigit, Address::PreIndex));
+  __ str(R9, Address(R6, -Bigint::kBytesPerDigit, Address::PreIndex));
   // Returning Object::null() is not required, since this method is private.
   __ Ret();
 }
 
 
 void Intrinsifier::Bigint_rsh(Assembler* assembler) {
   // static void _lsh(Uint32List x_digits, int x_used, int n,
   //                  Uint32List r_digits)
 
-  // R2 = x_used, R3 = x_digits, x_used > 0, x_used is Smi.
-  __ ldrd(R2, R3, SP, 2 * kWordSize);
-  // R4 = r_digits, R5 = n, n is Smi, n % _DIGIT_BITS != 0.
-  __ ldrd(R4, R5, SP, 0 * kWordSize);
-  __ SmiUntag(R5);
-  // R0 = n ~/ _DIGIT_BITS
-  __ Asr(R0, R5, Operand(5));
-  // R10 = &r_digits[0]
-  __ add(R10, R4, Operand(TypedData::data_offset() - kHeapObjectTag));
+  // R0 = x_used, R1 = x_digits, x_used > 0, x_used is Smi.
+  __ ldrd(R0, R1, SP, 2 * kWordSize);
+  // R2 = r_digits, R3 = n, n is Smi, n % _DIGIT_BITS != 0.
+  __ ldrd(R2, R3, SP, 0 * kWordSize);
+  __ SmiUntag(R3);
+  // R4 = n ~/ _DIGIT_BITS
+  __ Asr(R4, R3, Operand(5));
+  // R6 = &r_digits[0]
+  __ add(R6, R2, Operand(TypedData::data_offset() - kHeapObjectTag));
   // R7 = &x_digits[n ~/ _DIGIT_BITS]
-  __ add(R7, R3, Operand(TypedData::data_offset() - kHeapObjectTag));
-  __ add(R7, R7, Operand(R0, LSL, 2));
-  // R6 = &r_digits[x_used - n ~/ _DIGIT_BITS - 1]
-  __ add(R0, R0, Operand(1));
-  __ rsb(R0, R0, Operand(R2, ASR, 1));
-  __ add(R6, R10, Operand(R0, LSL, 2));
-  // R3 = n % _DIGIT_BITS
-  __ and_(R3, R5, Operand(31));
-  // R2 = 32 - R3
-  __ rsb(R2, R3, Operand(32));
-  // R1 = x_digits[n ~/ _DIGIT_BITS] >> (n % _DIGIT_BITS)
-  __ ldr(R1, Address(R7, Bigint::kBytesPerDigit, Address::PostIndex));
-  __ mov(R1, Operand(R1, LSR, R3));
+  __ add(R7, R1, Operand(TypedData::data_offset() - kHeapObjectTag));
+  __ add(R7, R7, Operand(R4, LSL, 2));
+  // R8 = &r_digits[x_used - n ~/ _DIGIT_BITS - 1]
+  __ add(R4, R4, Operand(1));
+  __ rsb(R4, R4, Operand(R0, ASR, 1));
+  __ add(R8, R6, Operand(R4, LSL, 2));
+  // R1 = n % _DIGIT_BITS
+  __ and_(R1, R3, Operand(31));
+  // R0 = 32 - R1
+  __ rsb(R0, R1, Operand(32));
+  // R9 = x_digits[n ~/ _DIGIT_BITS] >> (n % _DIGIT_BITS)
+  __ ldr(R9, Address(R7, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ mov(R9, Operand(R9, LSR, R1));
   Label loop_entry;
   __ b(&loop_entry);
   Label loop;
   __ Bind(&loop);
-  __ ldr(R0, Address(R7, Bigint::kBytesPerDigit, Address::PostIndex));
-  __ orr(R1, R1, Operand(R0, LSL, R2));
-  __ str(R1, Address(R10, Bigint::kBytesPerDigit, Address::PostIndex));
-  __ mov(R1, Operand(R0, LSR, R3));
+  __ ldr(R4, Address(R7, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ orr(R9, R9, Operand(R4, LSL, R0));
+  __ str(R9, Address(R6, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ mov(R9, Operand(R4, LSR, R1));
   __ Bind(&loop_entry);
-  __ teq(R10, Operand(R6));
+  __ teq(R6, Operand(R8));
   __ b(&loop, NE);
-  __ str(R1, Address(R10, 0));
+  __ str(R9, Address(R6, 0));
   // Returning Object::null() is not required, since this method is private.
   __ Ret();
 }
 
 
 void Intrinsifier::Bigint_absAdd(Assembler* assembler) {
   // static void _absAdd(Uint32List digits, int used,
   //                     Uint32List a_digits, int a_used,
   //                     Uint32List r_digits)
 
-  // R2 = used, R3 = digits
-  __ ldrd(R2, R3, SP, 3 * kWordSize);
-  // R3 = &digits[0]
+  // R0 = used, R1 = digits
+  __ ldrd(R0, R1, SP, 3 * kWordSize);
+  // R1 = &digits[0]
+  __ add(R1, R1, Operand(TypedData::data_offset() - kHeapObjectTag));
+
+  // R2 = a_used, R3 = a_digits
+  __ ldrd(R2, R3, SP, 1 * kWordSize);
+  // R3 = &a_digits[0]
   __ add(R3, R3, Operand(TypedData::data_offset() - kHeapObjectTag));
 
-  // R4 = a_used, R5 = a_digits
-  __ ldrd(R4, R5, SP, 1 * kWordSize);
-  // R5 = &a_digits[0]
-  __ add(R5, R5, Operand(TypedData::data_offset() - kHeapObjectTag));
-
-  // R6 = r_digits
-  __ ldr(R6, Address(SP, 0 * kWordSize));
-  // R6 = &r_digits[0]
-  __ add(R6, R6, Operand(TypedData::data_offset() - kHeapObjectTag));
+  // R8 = r_digits
+  __ ldr(R8, Address(SP, 0 * kWordSize));
+  // R8 = &r_digits[0]
+  __ add(R8, R8, Operand(TypedData::data_offset() - kHeapObjectTag));
 
   // R7 = &digits[a_used >> 1], a_used is Smi.
-  __ add(R7, R3, Operand(R4, LSL, 1));
+  __ add(R7, R1, Operand(R2, LSL, 1));
 
-  // R10 = &digits[used >> 1], used is Smi.
-  __ add(R10, R3, Operand(R2, LSL, 1));
+  // R6 = &digits[used >> 1], used is Smi.
+  __ add(R6, R1, Operand(R0, LSL, 1));
 
-  __ adds(R0, R0, Operand(0));  // carry flag = 0
+  __ adds(R4, R4, Operand(0));  // carry flag = 0
   Label add_loop;
   __ Bind(&add_loop);
   // Loop a_used times, a_used > 0.
-  __ ldr(R0, Address(R3, Bigint::kBytesPerDigit, Address::PostIndex));
-  __ ldr(R1, Address(R5, Bigint::kBytesPerDigit, Address::PostIndex));
-  __ adcs(R0, R0, Operand(R1));
-  __ teq(R3, Operand(R7));  // Does not affect carry flag.
-  __ str(R0, Address(R6, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R4, Address(R1, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R9, Address(R3, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ adcs(R4, R4, Operand(R9));
+  __ teq(R1, Operand(R7));  // Does not affect carry flag.
+  __ str(R4, Address(R8, Bigint::kBytesPerDigit, Address::PostIndex));
   __ b(&add_loop, NE);
 
   Label last_carry;
-  __ teq(R3, Operand(R10));  // Does not affect carry flag.
+  __ teq(R1, Operand(R6));  // Does not affect carry flag.
   __ b(&last_carry, EQ);  // If used - a_used == 0.
 
   Label carry_loop;
   __ Bind(&carry_loop);
   // Loop used - a_used times, used - a_used > 0.
-  __ ldr(R0, Address(R3, Bigint::kBytesPerDigit, Address::PostIndex));
-  __ adcs(R0, R0, Operand(0));
-  __ teq(R3, Operand(R10));  // Does not affect carry flag.
-  __ str(R0, Address(R6, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R4, Address(R1, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ adcs(R4, R4, Operand(0));
+  __ teq(R1, Operand(R6));  // Does not affect carry flag.
+  __ str(R4, Address(R8, Bigint::kBytesPerDigit, Address::PostIndex));
   __ b(&carry_loop, NE);
 
   __ Bind(&last_carry);
-  __ mov(R0, Operand(0));
-  __ adc(R0, R0, Operand(0));
-  __ str(R0, Address(R6, 0));
+  __ mov(R4, Operand(0));
+  __ adc(R4, R4, Operand(0));
+  __ str(R4, Address(R8, 0));
 
   // Returning Object::null() is not required, since this method is private.
   __ Ret();
 }
 
 
 void Intrinsifier::Bigint_absSub(Assembler* assembler) {
   // static void _absSub(Uint32List digits, int used,
   //                     Uint32List a_digits, int a_used,
   //                     Uint32List r_digits)
 
-  // R2 = used, R3 = digits
-  __ ldrd(R2, R3, SP, 3 * kWordSize);
-  // R3 = &digits[0]
+  // R0 = used, R1 = digits
+  __ ldrd(R0, R1, SP, 3 * kWordSize);
+  // R1 = &digits[0]
+  __ add(R1, R1, Operand(TypedData::data_offset() - kHeapObjectTag));
+
+  // R2 = a_used, R3 = a_digits
+  __ ldrd(R2, R3, SP, 1 * kWordSize);
+  // R3 = &a_digits[0]
   __ add(R3, R3, Operand(TypedData::data_offset() - kHeapObjectTag));
 
-  // R4 = a_used, R5 = a_digits
-  __ ldrd(R4, R5, SP, 1 * kWordSize);
-  // R5 = &a_digits[0]
-  __ add(R5, R5, Operand(TypedData::data_offset() - kHeapObjectTag));
-
-  // R6 = r_digits
-  __ ldr(R6, Address(SP, 0 * kWordSize));
-  // R6 = &r_digits[0]
-  __ add(R6, R6, Operand(TypedData::data_offset() - kHeapObjectTag));
+  // R8 = r_digits
+  __ ldr(R8, Address(SP, 0 * kWordSize));
+  // R8 = &r_digits[0]
+  __ add(R8, R8, Operand(TypedData::data_offset() - kHeapObjectTag));
 
   // R7 = &digits[a_used >> 1], a_used is Smi.
-  __ add(R7, R3, Operand(R4, LSL, 1));
+  __ add(R7, R1, Operand(R2, LSL, 1));
 
-  // R10 = &digits[used >> 1], used is Smi.
-  __ add(R10, R3, Operand(R2, LSL, 1));
+  // R6 = &digits[used >> 1], used is Smi.
+  __ add(R6, R1, Operand(R0, LSL, 1));
 
-  __ subs(R0, R0, Operand(0));  // carry flag = 1
+  __ subs(R4, R4, Operand(0));  // carry flag = 1
   Label sub_loop;
   __ Bind(&sub_loop);
   // Loop a_used times, a_used > 0.
-  __ ldr(R0, Address(R3, Bigint::kBytesPerDigit, Address::PostIndex));
-  __ ldr(R1, Address(R5, Bigint::kBytesPerDigit, Address::PostIndex));
-  __ sbcs(R0, R0, Operand(R1));
-  __ teq(R3, Operand(R7));  // Does not affect carry flag.
-  __ str(R0, Address(R6, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R4, Address(R1, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R9, Address(R3, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ sbcs(R4, R4, Operand(R9));
+  __ teq(R1, Operand(R7));  // Does not affect carry flag.
+  __ str(R4, Address(R8, Bigint::kBytesPerDigit, Address::PostIndex));
   __ b(&sub_loop, NE);
 
   Label done;
-  __ teq(R3, Operand(R10));  // Does not affect carry flag.
+  __ teq(R1, Operand(R6));  // Does not affect carry flag.
   __ b(&done, EQ);  // If used - a_used == 0.
 
   Label carry_loop;
   __ Bind(&carry_loop);
   // Loop used - a_used times, used - a_used > 0.
-  __ ldr(R0, Address(R3, Bigint::kBytesPerDigit, Address::PostIndex));
-  __ sbcs(R0, R0, Operand(0));
-  __ teq(R3, Operand(R10));  // Does not affect carry flag.
-  __ str(R0, Address(R6, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ ldr(R4, Address(R1, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ sbcs(R4, R4, Operand(0));
+  __ teq(R1, Operand(R6));  // Does not affect carry flag.
+  __ str(R4, Address(R8, Bigint::kBytesPerDigit, Address::PostIndex));
   __ b(&carry_loop, NE);
 
   __ Bind(&done);
   // Returning Object::null() is not required, since this method is private.
   __ Ret();
 }
 
 
 void Intrinsifier::Bigint_mulAdd(Assembler* assembler) {
   // Pseudo code:
@@ skipping 24 matching lines @@
   // }
 
   Label done;
   // R3 = x, no_op if x == 0
   __ ldrd(R0, R1, SP, 5 * kWordSize);  // R0 = xi as Smi, R1 = x_digits.
   __ add(R1, R1, Operand(R0, LSL, 1));
   __ ldr(R3, FieldAddress(R1, TypedData::data_offset()));
   __ tst(R3, Operand(R3));
   __ b(&done, EQ);
 
-  // R6 = SmiUntag(n), no_op if n == 0
-  __ ldr(R6, Address(SP, 0 * kWordSize));
-  __ Asrs(R6, R6, Operand(kSmiTagSize));
+  // R8 = SmiUntag(n), no_op if n == 0
+  __ ldr(R8, Address(SP, 0 * kWordSize));
+  __ Asrs(R8, R8, Operand(kSmiTagSize));
   __ b(&done, EQ);
 
   // R4 = mip = &m_digits[i >> 1]
   __ ldrd(R0, R1, SP, 3 * kWordSize);  // R0 = i as Smi, R1 = m_digits.
   __ add(R1, R1, Operand(R0, LSL, 1));
   __ add(R4, R1, Operand(TypedData::data_offset() - kHeapObjectTag));
 
-  // R5 = ajp = &a_digits[j >> 1]
+  // R9 = ajp = &a_digits[j >> 1]
   __ ldrd(R0, R1, SP, 1 * kWordSize);  // R0 = j as Smi, R1 = a_digits.
   __ add(R1, R1, Operand(R0, LSL, 1));
-  __ add(R5, R1, Operand(TypedData::data_offset() - kHeapObjectTag));
+  __ add(R9, R1, Operand(TypedData::data_offset() - kHeapObjectTag));
 
   // R1 = c = 0
   __ mov(R1, Operand(0));
 
   Label muladd_loop;
   __ Bind(&muladd_loop);
   // x:   R3
   // mip: R4
-  // ajp: R5
+  // ajp: R9
   // c:   R1
-  // n:   R6
+  // n:   R8
 
   // uint32_t mi = *mip++
   __ ldr(R2, Address(R4, Bigint::kBytesPerDigit, Address::PostIndex));
 
   // uint32_t aj = *ajp
-  __ ldr(R0, Address(R5, 0));
+  __ ldr(R0, Address(R9, 0));
 
   // uint64_t t = x*mi + aj + c
   __ umaal(R0, R1, R2, R3);  // R1:R0 = R2*R3 + R1 + R0.
 
   // *ajp++ = low32(t) = R0
-  __ str(R0, Address(R5, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R9, Bigint::kBytesPerDigit, Address::PostIndex));
 
   // c = high32(t) = R1
 
   // while (--n > 0)
-  __ subs(R6, R6, Operand(1));  // --n
+  __ subs(R8, R8, Operand(1));  // --n
   __ b(&muladd_loop, NE);
 
   __ tst(R1, Operand(R1));
   __ b(&done, EQ);
 
   // *ajp++ += c
-  __ ldr(R0, Address(R5, 0));
+  __ ldr(R0, Address(R9, 0));
   __ adds(R0, R0, Operand(R1));
-  __ str(R0, Address(R5, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R9, Bigint::kBytesPerDigit, Address::PostIndex));
   __ b(&done, CC);
 
   Label propagate_carry_loop;
   __ Bind(&propagate_carry_loop);
-  __ ldr(R0, Address(R5, 0));
+  __ ldr(R0, Address(R9, 0));
   __ adds(R0, R0, Operand(1));
-  __ str(R0, Address(R5, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R9, Bigint::kBytesPerDigit, Address::PostIndex));
   __ b(&propagate_carry_loop, CS);
 
   __ Bind(&done);
   __ mov(R0, Operand(Smi::RawValue(1)));  // One digit processed.
   __ Ret();
 }
 
 
 void Intrinsifier::Bigint_sqrAdd(Assembler* assembler) {
   // Pseudo code:
@@ skipping 26 matching lines @@
   __ ldrd(R2, R3, SP, 2 * kWordSize);  // R2 = i as Smi, R3 = x_digits
   __ add(R3, R3, Operand(R2, LSL, 1));
   __ add(R4, R3, Operand(TypedData::data_offset() - kHeapObjectTag));
 
   // R3 = x = *xip++, return if x == 0
   Label x_zero;
   __ ldr(R3, Address(R4, Bigint::kBytesPerDigit, Address::PostIndex));
   __ tst(R3, Operand(R3));
   __ b(&x_zero, EQ);
 
-  // R5 = ajp = &a_digits[i]
+  // R7 = ajp = &a_digits[i]
   __ ldr(R1, Address(SP, 1 * kWordSize));  // a_digits
   __ add(R1, R1, Operand(R2, LSL, 2));  // j == 2*i, i is Smi.
-  __ add(R5, R1, Operand(TypedData::data_offset() - kHeapObjectTag));
+  __ add(R7, R1, Operand(TypedData::data_offset() - kHeapObjectTag));
 
-  // R6:R0 = t = x*x + *ajp
-  __ ldr(R0, Address(R5, 0));
-  __ mov(R6, Operand(0));
-  __ umaal(R0, R6, R3, R3);  // R6:R0 = R3*R3 + R6 + R0.
+  // R8:R0 = t = x*x + *ajp
+  __ ldr(R0, Address(R7, 0));
+  __ mov(R8, Operand(0));
+  __ umaal(R0, R8, R3, R3);  // R8:R0 = R3*R3 + R8 + R0.
 
   // *ajp++ = low32(t) = R0
-  __ str(R0, Address(R5, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R7, Bigint::kBytesPerDigit, Address::PostIndex));
 
-  // R6 = low32(c) = high32(t)
-  // R7 = high32(c) = 0
-  __ mov(R7, Operand(0));
+  // R8 = low32(c) = high32(t)
+  // R9 = high32(c) = 0
+  __ mov(R9, Operand(0));
 
   // int n = used - i - 1; while (--n >= 0) ...
   __ ldr(R0, Address(SP, 0 * kWordSize));  // used is Smi
-  __ sub(R10, R0, Operand(R2));
+  __ sub(R6, R0, Operand(R2));
   __ mov(R0, Operand(2));  // n = used - i - 2; if (n >= 0) ... while (--n >= 0)
-  __ rsbs(R10, R0, Operand(R10, ASR, kSmiTagSize));
+  __ rsbs(R6, R0, Operand(R6, ASR, kSmiTagSize));
 
   Label loop, done;
   __ b(&done, MI);
 
   __ Bind(&loop);
   // x:   R3
   // xip: R4
-  // ajp: R5
-  // c:   R7:R6
+  // ajp: R7
+  // c:   R9:R8
   // t:   R2:R1:R0 (not live at loop entry)
-  // n:   R10
+  // n:   R6
 
   // uint32_t xi = *xip++
   __ ldr(R2, Address(R4, Bigint::kBytesPerDigit, Address::PostIndex));
 
-  // uint96_t t = R7:R6:R0 = 2*x*xi + aj + c
+  // uint96_t t = R9:R8:R0 = 2*x*xi + aj + c
   __ umull(R0, R1, R2, R3);  // R1:R0 = R2*R3.
   __ adds(R0, R0, Operand(R0));
   __ adcs(R1, R1, Operand(R1));
   __ mov(R2, Operand(0));
   __ adc(R2, R2, Operand(0));  // R2:R1:R0 = 2*x*xi.
-  __ adds(R0, R0, Operand(R6));
-  __ adcs(R1, R1, Operand(R7));
+  __ adds(R0, R0, Operand(R8));
+  __ adcs(R1, R1, Operand(R9));
   __ adc(R2, R2, Operand(0));  // R2:R1:R0 = 2*x*xi + c.
-  __ ldr(R6, Address(R5, 0));  // R6 = aj = *ajp.
-  __ adds(R0, R0, Operand(R6));
-  __ adcs(R6, R1, Operand(0));
-  __ adc(R7, R2, Operand(0));  // R7:R6:R0 = 2*x*xi + c + aj.
+  __ ldr(R8, Address(R7, 0));  // R8 = aj = *ajp.
+  __ adds(R0, R0, Operand(R8));
+  __ adcs(R8, R1, Operand(0));
+  __ adc(R9, R2, Operand(0));  // R9:R8:R0 = 2*x*xi + c + aj.
 
   // *ajp++ = low32(t) = R0
-  __ str(R0, Address(R5, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R0, Address(R7, Bigint::kBytesPerDigit, Address::PostIndex));
 
   // while (--n >= 0)
-  __ subs(R10, R10, Operand(1));  // --n
+  __ subs(R6, R6, Operand(1));  // --n
   __ b(&loop, PL);
 
   __ Bind(&done);
   // uint32_t aj = *ajp
-  __ ldr(R0, Address(R5, 0));
+  __ ldr(R0, Address(R7, 0));
 
   // uint64_t t = aj + c
-  __ adds(R6, R6, Operand(R0));
-  __ adc(R7, R7, Operand(0));
+  __ adds(R8, R8, Operand(R0));
+  __ adc(R9, R9, Operand(0));
 
-  // *ajp = low32(t) = R6
-  // *(ajp + 1) = high32(t) = R7
-  __ strd(R6, R7, R5, 0);
+  // *ajp = low32(t) = R8
+  // *(ajp + 1) = high32(t) = R9
+  __ strd(R8, R9, R7, 0);
 
   __ Bind(&x_zero);
   __ mov(R0, Operand(Smi::RawValue(1)));  // One digit processed.
   __ Ret();
 }
 
 
 void Intrinsifier::Bigint_estQuotientDigit(Assembler* assembler) {
   // No unsigned 64-bit / 32-bit divide instruction.
 }
@@ skipping 321 matching lines @@
   __ ldr(R1, FieldAddress(R0, state_field.Offset()));
   // Addresses of _state[0] and _state[1].
 
   const int64_t disp_0 = Instance::DataOffsetFor(kTypedDataUint32ArrayCid);
   const int64_t disp_1 = disp_0 +
       Instance::ElementSizeFor(kTypedDataUint32ArrayCid);
 
   __ LoadImmediate(R0, a_int32_value);
   __ LoadFromOffset(kWord, R2, R1, disp_0 - kHeapObjectTag);
   __ LoadFromOffset(kWord, R3, R1, disp_1 - kHeapObjectTag);
-  __ mov(R6, Operand(0));  // Zero extend unsigned _state[kSTATE_HI].
-  // Unsigned 32-bit multiply and 64-bit accumulate into R6:R3.
-  __ umlal(R3, R6, R0, R2);  // R6:R3 <- R6:R3 + R0 * R2.
+  __ mov(R8, Operand(0));  // Zero extend unsigned _state[kSTATE_HI].
+  // Unsigned 32-bit multiply and 64-bit accumulate into R8:R3.
+  __ umlal(R3, R8, R0, R2);  // R8:R3 <- R8:R3 + R0 * R2.
   __ StoreToOffset(kWord, R3, R1, disp_0 - kHeapObjectTag);
-  __ StoreToOffset(kWord, R6, R1, disp_1 - kHeapObjectTag);
+  __ StoreToOffset(kWord, R8, R1, disp_1 - kHeapObjectTag);
   __ Ret();
 }
 
 
 void Intrinsifier::ObjectEquals(Assembler* assembler) {
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ ldr(R1, Address(SP, 1 * kWordSize));
   __ cmp(R0, Operand(R1));
   __ LoadObject(R0, Bool::False(), NE);
   __ LoadObject(R0, Bool::True(), EQ);
@@ skipping 125 matching lines @@
 
   __ ldr(R2, FieldAddress(R1, String::length_offset()));
 
   Label done;
   // If the string is empty, set the hash to 1, and return.
   __ cmp(R2, Operand(Smi::RawValue(0)));
   __ b(&done, EQ);
 
   __ SmiUntag(R2);
   __ mov(R3, Operand(0));
-  __ AddImmediate(R6, R1, OneByteString::data_offset() - kHeapObjectTag);
+  __ AddImmediate(R8, R1, OneByteString::data_offset() - kHeapObjectTag);
   // R1: Instance of OneByteString.
   // R2: String length, untagged integer.
   // R3: Loop counter, untagged integer.
-  // R6: String data.
+  // R8: String data.
   // R0: Hash code, untagged integer.
 
   Label loop;
   // Add to hash code: (hash_ is uint32)
   // hash_ += ch;
   // hash_ += hash_ << 10;
   // hash_ ^= hash_ >> 6;
   // Get one characters (ch).
   __ Bind(&loop);
-  __ ldrb(R7, Address(R6, 0));
+  __ ldrb(R7, Address(R8, 0));
   // R7: ch.
   __ add(R3, R3, Operand(1));
-  __ add(R6, R6, Operand(1));
+  __ add(R8, R8, Operand(1));
   __ add(R0, R0, Operand(R7));
   __ add(R0, R0, Operand(R0, LSL, 10));
   __ eor(R0, R0, Operand(R0, LSR, 6));
   __ cmp(R3, Operand(R2));
   __ b(&loop, NE);
 
   // Finalize.
   // hash_ += hash_ << 3;
   // hash_ ^= hash_ >> 11;
   // hash_ += hash_ << 15;
@@ skipping 17 matching lines @@
 // initialized.
 // 'length-reg' (R2) contains tagged length.
 // Returns new string as tagged pointer in R0.
 static void TryAllocateOnebyteString(Assembler* assembler,
                                      Label* ok,
                                      Label* failure) {
   const Register length_reg = R2;
   Label fail;
   __ MaybeTraceAllocation(kOneByteStringCid, R0, failure,
                           /* inline_isolate = */ false);
-  __ mov(R6, Operand(length_reg));  // Save the length register.
+  __ mov(R8, Operand(length_reg));  // Save the length register.
   // TODO(koda): Protect against negative length and overflow here.
   __ SmiUntag(length_reg);
   const intptr_t fixed_size = sizeof(RawString) + kObjectAlignment - 1;
   __ AddImmediate(length_reg, fixed_size);
   __ bic(length_reg, length_reg, Operand(kObjectAlignment - 1));
 
   const intptr_t cid = kOneByteStringCid;
   Heap::Space space = Heap::SpaceForAllocation(cid);
   __ ldr(R3, Address(THR, Thread::heap_offset()));
   __ ldr(R0, Address(R3, Heap::TopOffset(space)));
@@ skipping 29 matching lines @@
     __ mov(R3, Operand(R2, LSL, shift), LS);
     __ mov(R3, Operand(0), HI);
 
     // Get the class index and insert it into the tags.
     // R3: size and bit tags.
     __ LoadImmediate(TMP, RawObject::ClassIdTag::encode(cid));
     __ orr(R3, R3, Operand(TMP));
     __ str(R3, FieldAddress(R0, String::tags_offset()));  // Store tags.
   }
 
-  // Set the length field using the saved length (R6).
+  // Set the length field using the saved length (R8).
   __ InitializeFieldNoBarrier(R0,
                               FieldAddress(R0, String::length_offset()),
-                              R6);
+                              R8);
   // Clear hash.
   __ LoadImmediate(TMP, 0);
   __ InitializeFieldNoBarrier(R0,
                               FieldAddress(R0, String::hash_offset()),
                               TMP);
 
   __ IncrementAllocationStatsWithSize(R4, R2, space);
   __ b(ok);
 
   __ Bind(&fail);
@@ skipping 31 matching lines @@
 
   // R3: Start address to copy from (untagged).
   // R1: Untagged start index.
   __ ldr(R2, Address(SP, kEndIndexOffset));
   __ SmiUntag(R2);
   __ sub(R2, R2, Operand(R1));
 
   // R3: Start address to copy from (untagged).
   // R2: Untagged number of bytes to copy.
   // R0: Tagged result string.
-  // R6: Pointer into R3.
+  // R8: Pointer into R3.
   // R7: Pointer into R0.
   // R1: Scratch register.
   Label loop, done;
   __ cmp(R2, Operand(0));
   __ b(&done, LE);
-  __ mov(R6, Operand(R3));
+  __ mov(R8, Operand(R3));
   __ mov(R7, Operand(R0));
   __ Bind(&loop);
-  __ ldrb(R1, Address(R6, 0));
-  __ AddImmediate(R6, 1);
+  __ ldrb(R1, Address(R8, 0));
+  __ AddImmediate(R8, 1);
   __ sub(R2, R2, Operand(1));
   __ cmp(R2, Operand(0));
   __ strb(R1, FieldAddress(R7, OneByteString::data_offset()));
   __ AddImmediate(R7, 1);
   __ b(&loop, GT);
 
   __ Bind(&done);
   __ Ret();
   __ Bind(&fall_through);
 }
@@ skipping 100 matching lines @@
 void Intrinsifier::JSRegExp_ExecuteMatch(Assembler* assembler) {
   if (FLAG_interpret_irregexp) return;
 
   static const intptr_t kRegExpParamOffset = 2 * kWordSize;
   static const intptr_t kStringParamOffset = 1 * kWordSize;
   // start_index smi is located at offset 0.
 
   // Incoming registers:
   // R0: Function. (Will be reloaded with the specialized matcher function.)
   // R4: Arguments descriptor. (Will be preserved.)
-  // R5: Unknown. (Must be GC safe on tail call.)
+  // R9: Unknown. (Must be GC safe on tail call.)
 
   // Load the specialized function pointer into R0. Leverage the fact the
   // string CIDs as well as stored function pointers are in sequence.
   __ ldr(R2, Address(SP, kRegExpParamOffset));
   __ ldr(R1, Address(SP, kStringParamOffset));
   __ LoadClassId(R1, R1);
   __ AddImmediate(R1, R1, -kOneByteStringCid);
   __ add(R1, R2, Operand(R1, LSL, kWordSizeLog2));
   __ ldr(R0, FieldAddress(R1, JSRegExp::function_offset(kOneByteStringCid)));
 
   // Registers are now set up for the lazy compile stub. It expects the function
-  // in R0, the argument descriptor in R4, and IC-Data in R5.
-  __ eor(R5, R5, Operand(R5));
+  // in R0, the argument descriptor in R4, and IC-Data in R9.
+  __ eor(R9, R9, Operand(R9));
 
   // Tail-call the function.
   __ ldr(CODE_REG, FieldAddress(R0, Function::code_offset()));
   __ ldr(R1, FieldAddress(R0, Function::entry_point_offset()));
   __ bx(R1);
 }
 
 
 // On stack: user tag (+0).
 void Intrinsifier::UserTag_makeCurrent(Assembler* assembler) {
@@ skipping 22 matching lines @@
 
 void Intrinsifier::Profiler_getCurrentTag(Assembler* assembler) {
   __ LoadIsolate(R0);
   __ ldr(R0, Address(R0, Isolate::current_tag_offset()));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM