VM: New calling convention for generated code.

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"
@@ skipping 531 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);
   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(R9, R0, Operand(32));  // R9 <- 32 - R0
-  __ mov(R7, Operand(R7, LSL, R9));  // R7 <- R7 << R9
+  __ rsb(R10, R0, Operand(32));  // R10 <- 32 - R0
+  __ mov(R7, Operand(R7, LSL, R10));  // R7 <- R7 << R10
   __ and_(R7, R1, Operand(R7));  // R7 <- R7 & R1
-  __ mov(R7, Operand(R7, LSR, R9));  // R7 <- R7 >> R9
+  __ mov(R7, Operand(R7, LSR, R10));  // R7 <- R7 >> R10
   // 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);
   __ Ret();
   __ Bind(&fall_through);
+  ASSERT(CODE_REG == R10);
+  __ Pop(R10);
 }
 
 
 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 205 matching lines @@
   __ ldrd(R2, SP, 2 * kWordSize);
   // R4 = r_digits, R5 = n, n is Smi, n % _DIGIT_BITS != 0.
   __ ldrd(R4, 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));
   // R7 = &x_digits[x_used]
   __ add(R7, R6, Operand(R2, LSL, 1));
-  // R9 = &r_digits[1]
-  __ add(R9, R4, Operand(TypedData::data_offset() - kHeapObjectTag +
+  // R10 = &r_digits[1]
+  __ add(R10, R4, Operand(TypedData::data_offset() - kHeapObjectTag +
                          Bigint::kBytesPerDigit));
-  // R9 = &r_digits[x_used + n ~/ _DIGIT_BITS + 1]
+  // R10 = &r_digits[x_used + n ~/ _DIGIT_BITS + 1]
   __ add(R0, R0, Operand(R2, ASR, 1));
-  __ add(R9, R9, Operand(R0, LSL, 2));
+  __ 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));
   Label loop;
   __ Bind(&loop);
   __ ldr(R0, Address(R7, -Bigint::kBytesPerDigit, Address::PreIndex));
   __ orr(R1, R1, Operand(R0, LSR, R2));
-  __ str(R1, Address(R9, -Bigint::kBytesPerDigit, Address::PreIndex));
+  __ str(R1, Address(R10, -Bigint::kBytesPerDigit, Address::PreIndex));
   __ mov(R1, Operand(R0, LSL, R3));
   __ teq(R7, Operand(R6));
   __ b(&loop, NE);
-  __ str(R1, Address(R9, -Bigint::kBytesPerDigit, Address::PreIndex));
+  __ str(R1, Address(R10, -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, SP, 2 * kWordSize);
   // R4 = r_digits, R5 = n, n is Smi, n % _DIGIT_BITS != 0.
   __ ldrd(R4, SP, 0 * kWordSize);
   __ SmiUntag(R5);
   // R0 = n ~/ _DIGIT_BITS
   __ Asr(R0, R5, Operand(5));
-  // R9 = &r_digits[0]
-  __ add(R9, R4, Operand(TypedData::data_offset() - kHeapObjectTag));
+  // R10 = &r_digits[0]
+  __ add(R10, R4, 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, R9, Operand(R0, LSL, 2));
+  __ 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));
   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(R9, Bigint::kBytesPerDigit, Address::PostIndex));
+  __ str(R1, Address(R10, Bigint::kBytesPerDigit, Address::PostIndex));
   __ mov(R1, Operand(R0, LSR, R3));
   __ Bind(&loop_entry);
-  __ teq(R9, Operand(R6));
+  __ teq(R10, Operand(R6));
   __ b(&loop, NE);
-  __ str(R1, Address(R9, 0));
+  __ str(R1, Address(R10, 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, SP, 3 * kWordSize);
   // R3 = &digits[0]
   __ add(R3, R3, Operand(TypedData::data_offset() - kHeapObjectTag));
 
   // R4 = a_used, R5 = a_digits
   __ ldrd(R4, 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));
 
   // R7 = &digits[a_used >> 1], a_used is Smi.
   __ add(R7, R3, Operand(R4, LSL, 1));
 
-  // R9 = &digits[used >> 1], used is Smi.
-  __ add(R9, R3, Operand(R2, LSL, 1));
+  // R10 = &digits[used >> 1], used is Smi.
+  __ add(R10, R3, Operand(R2, LSL, 1));
 
   __ adds(R0, R0, 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));
   __ b(&add_loop, NE);
 
   Label last_carry;
-  __ teq(R3, Operand(R9));  // Does not affect carry flag.
+  __ teq(R3, Operand(R10));  // 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(R9));  // Does not affect carry flag.
+  __ teq(R3, Operand(R10));  // Does not affect carry flag.
   __ str(R0, Address(R6, 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));
 
   // Returning Object::null() is not required, since this method is private.
   __ Ret();
@@ skipping 16 matching lines @@
   __ 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));
 
   // R7 = &digits[a_used >> 1], a_used is Smi.
   __ add(R7, R3, Operand(R4, LSL, 1));
 
-  // R9 = &digits[used >> 1], used is Smi.
-  __ add(R9, R3, Operand(R2, LSL, 1));
+  // R10 = &digits[used >> 1], used is Smi.
+  __ add(R10, R3, Operand(R2, LSL, 1));
 
   __ subs(R0, R0, 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));
   __ b(&sub_loop, NE);
 
   Label done;
-  __ teq(R3, Operand(R9));  // Does not affect carry flag.
+  __ teq(R3, Operand(R10));  // 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(R9));  // Does not affect carry flag.
+  __ teq(R3, Operand(R10));  // Does not affect carry flag.
   __ str(R0, Address(R6, 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) {
@@ skipping 148 matching lines @@
 
   // *ajp++ = low32(t) = R0
   __ str(R0, Address(R5, Bigint::kBytesPerDigit, Address::PostIndex));
 
   // R6 = low32(c) = high32(t)
   // R7 = high32(c) = 0
   __ mov(R7, Operand(0));
 
   // int n = used - i - 1; while (--n >= 0) ...
   __ ldr(R0, Address(SP, 0 * kWordSize));  // used is Smi
-  __ sub(R9, R0, Operand(R2));
+  __ sub(R10, R0, Operand(R2));
   __ mov(R0, Operand(2));  // n = used - i - 2; if (n >= 0) ... while (--n >= 0)
-  __ rsbs(R9, R0, Operand(R9, ASR, kSmiTagSize));
+  __ rsbs(R10, R0, Operand(R10, ASR, kSmiTagSize));
 
   Label loop, done;
   __ b(&done, MI);
 
   __ Bind(&loop);
   // x:   R3
   // xip: R4
   // ajp: R5
   // c:   R7:R6
   // t:   R2:R1:R0 (not live at loop entry)
-  // n:   R9
+  // n:   R10
 
   // uint32_t xi = *xip++
   __ ldr(R2, Address(R4, Bigint::kBytesPerDigit, Address::PostIndex));
 
   // uint96_t t = R7:R6: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));
   __ 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.
 
   // *ajp++ = low32(t) = R0
   __ str(R0, Address(R5, Bigint::kBytesPerDigit, Address::PostIndex));
 
   // while (--n >= 0)
-  __ subs(R9, R9, Operand(1));  // --n
+  __ subs(R10, R10, Operand(1));  // --n
   __ b(&loop, PL);
 
   __ Bind(&done);
   // uint32_t aj = *ajp
   __ ldr(R0, Address(R5, 0));
 
   // uint64_t t = aj + c
   __ adds(R6, R6, Operand(R0));
   __ adc(R7, R7, Operand(0));
 
@@ skipping 794 matching lines @@
   __ 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));
 
   // 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) {
   // R1: Isolate.
   __ LoadIsolate(R1);
   // R0: Current user tag.
@@ skipping 19 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