Use the iOS ABI when running SIMARM on Mac or targeting iOS.

runtime/vm/stub_code_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"
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/cpu.h"
@@ skipping 619 matching lines @@
   __ add(R9, R9, Operand(R3, LSL, 1));  // R3 is  a Smi.
   ASSERT(kSmiTagShift == 1);
   __ bic(R9, R9, Operand(kObjectAlignment - 1));
 
   // R9: Allocation size.
   Heap::Space space = Heap::SpaceForAllocation(cid);
   __ LoadIsolate(R8);
   __ ldr(R8, Address(R8, Isolate::heap_offset()));
   // Potential new object start.
   __ ldr(R0, Address(R8, Heap::TopOffset(space)));
-  __ adds(R7, R0, Operand(R9));  // Potential next object start.
+  __ adds(R711, R0, Operand(R9));  // Potential next object start.
   __ b(&slow_case, CS);  // Branch if unsigned overflow.
 
   // Check if the allocation fits into the remaining space.
   // R0: potential new object start.
-  // R7: potential next object start.
+  // R711: potential next object start.
   // R9: allocation size.
   __ ldr(R3, Address(R8, Heap::EndOffset(space)));
-  __ cmp(R7, Operand(R3));
+  __ cmp(R711, Operand(R3));
   __ b(&slow_case, CS);
 
   // Successfully allocated the object(s), now update top to point to
   // next object start and initialize the object.
   __ LoadAllocationStatsAddress(R3, cid, /* inline_isolate = */ false);
-  __ str(R7, Address(R8, Heap::TopOffset(space)));
+  __ str(R711, Address(R8, Heap::TopOffset(space)));
   __ add(R0, R0, Operand(kHeapObjectTag));
 
   // Initialize the tags.
   // R0: new object start as a tagged pointer.
   // R3: allocation stats address.
-  // R7: new object end address.
+  // R711: new object end address.
   // R9: allocation size.
   {
     const intptr_t shift = RawObject::kSizeTagPos - kObjectAlignmentLog2;
 
     __ CompareImmediate(R9, RawObject::SizeTag::kMaxSizeTag);
     __ mov(R8, Operand(R9, LSL, shift), LS);
     __ mov(R8, Operand(0), HI);
 
     // Get the class index and insert it into the tags.
     // R8: size and bit tags.
     __ LoadImmediate(TMP, RawObject::ClassIdTag::encode(cid));
     __ orr(R8, R8, Operand(TMP));
     __ str(R8, FieldAddress(R0, Array::tags_offset()));  // Store tags.
   }
 
   // R0: new object start as a tagged pointer.
-  // R7: new object end address.
+  // R711: new object end address.
   // Store the type argument field.
   __ InitializeFieldNoBarrier(R0,
                               FieldAddress(R0, Array::type_arguments_offset()),
                               R1);
 
   // Set the length field.
   __ InitializeFieldNoBarrier(R0,
                               FieldAddress(R0, Array::length_offset()),
                               R2);
 
   // Initialize all array elements to raw_null.
   // R0: new object start as a tagged pointer.
   // R3: allocation stats address.
   // R8, R9: null
   // R4: iterator which initially points to the start of the variable
   // data area to be initialized.
-  // R7: new object end address.
+  // R711: new object end address.
   // R9: allocation size.
   __ IncrementAllocationStatsWithSize(R3, R9, space);
 
   __ LoadObject(R8, Object::null_object());
   __ mov(R9, Operand(R8));
   __ AddImmediate(R4, R0, sizeof(RawArray) - kHeapObjectTag);
-  __ InitializeFieldsNoBarrier(R0, R4, R7, R8, R9);
+  __ InitializeFieldsNoBarrier(R0, R4, R711, R8, R9);
   __ Ret();  // Returns the newly allocated object in R0.
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ LoadObject(IP, Object::null_object());
   // Setup space on stack for return value.
@@ skipping 51 matching lines @@
   // Save top resource and top exit frame info. Use R4-6 as temporary registers.
   // StackFrameIterator reads the top exit frame info saved in this frame.
   __ LoadFromOffset(kWord, R9, THR, Thread::top_exit_frame_info_offset());
   __ LoadFromOffset(kWord, R4, THR, Thread::top_resource_offset());
   __ LoadImmediate(R8, 0);
   __ StoreToOffset(kWord, R8, THR, Thread::top_resource_offset());
   __ StoreToOffset(kWord, R8, THR, Thread::top_exit_frame_info_offset());
 
   // kExitLinkSlotFromEntryFp must be kept in sync with the code below.
   __ Push(R4);
+#if defined(TARGET_OS_MAC)
+  ASSERT(kExitLinkSlotFromEntryFp == -26);
+#else
   ASSERT(kExitLinkSlotFromEntryFp == -27);
+#endif
   __ Push(R9);
 
   // Load arguments descriptor array into R4, which is passed to Dart code.
   __ ldr(R4, Address(R1, VMHandles::kOffsetOfRawPtrInHandle));
 
   // Load number of arguments into R9.
   __ ldr(R9, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
   __ SmiUntag(R9);
 
   // Compute address of 'arguments array' data area into R2.
@@ skipping 141 matching lines @@
                                 R8);
 
     // Initialize the context variables.
     // R0: new object.
     // R1: number of context variables.
     // R2: object size.
     // R3: next object start.
     // R8, R9: raw null.
     // R4: allocation stats address.
     Label loop;
-    __ AddImmediate(R7, R0, Context::variable_offset(0) - kHeapObjectTag);
-    __ InitializeFieldsNoBarrier(R0, R7, R3, R8, R9);
+    __ AddImmediate(R711, R0, Context::variable_offset(0) - kHeapObjectTag);
+    __ InitializeFieldsNoBarrier(R0, R711, R3, R8, R9);
     __ IncrementAllocationStatsWithSize(R4, R2, space);
 
     // Done allocating and initializing the context.
     // R0: new object.
     __ Ret();
 
     __ Bind(&slow_case);
   }
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
@@ skipping 85 matching lines @@
 }
 
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   LR : return address.
 //   SP + 0 : type arguments object (only if class is parameterized).
 void StubCode::GenerateAllocationStubForClass(Assembler* assembler,
                                               const Class& cls) {
   // Must load pool pointer before being able to patch.
-  Register new_pp = R7;
+  Register new_pp = R711;
   __ LoadPoolPointer(new_pp);
   // The generated code is different if the class is parameterized.
   const bool is_cls_parameterized = cls.NumTypeArguments() > 0;
   ASSERT(!is_cls_parameterized ||
          (cls.type_arguments_field_offset() != Class::kNoTypeArguments));
   // kInlineInstanceSize is a constant used as a threshold for determining
   // when the object initialization should be done as a loop or as
   // straight line code.
   const int kInlineInstanceSize = 12;
   const intptr_t instance_size = cls.instance_size();
@@ skipping 157 matching lines @@
   if (FLAG_trace_optimized_ic_calls) {
     __ EnterStubFrame();
     __ PushList((1 << R9) | (1 << R8));  // Preserve.
     __ Push(ic_reg);  // Argument.
     __ Push(func_reg);  // Argument.
     __ CallRuntime(kTraceICCallRuntimeEntry, 2);
     __ Drop(2);  // Discard argument;
     __ PopList((1 << R9) | (1 << R8));  // Restore.
     __ LeaveStubFrame();
   }
-  __ ldr(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
-  __ add(R7, R7, Operand(1));
-  __ str(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
+  __ ldr(R711, FieldAddress(func_reg, Function::usage_counter_offset()));
+  __ add(R711, R711, Operand(1));
+  __ str(R711, FieldAddress(func_reg, Function::usage_counter_offset()));
 }
 
 
 // Loads function into 'temp_reg'.
 void StubCode::GenerateUsageCounterIncrement(Assembler* assembler,
                                              Register temp_reg) {
   if (FLAG_optimization_counter_threshold >= 0) {
     Register ic_reg = R9;
     Register func_reg = temp_reg;
     ASSERT(temp_reg == R8);
     __ Comment("Increment function counter");
     __ ldr(func_reg, FieldAddress(ic_reg, ICData::owner_offset()));
-    __ ldr(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
-    __ add(R7, R7, Operand(1));
-    __ str(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
+    __ ldr(R711, FieldAddress(func_reg, Function::usage_counter_offset()));
+    __ add(R711, R711, Operand(1));
+    __ str(R711, FieldAddress(func_reg, Function::usage_counter_offset()));
   }
 }
 
 
 // Note: R9 must be preserved.
 // Attempt a quick Smi operation for known operations ('kind'). The ICData
 // must have been primed with a Smi/Smi check that will be used for counting
 // the invocations.
 static void EmitFastSmiOp(Assembler* assembler,
                           Token::Kind kind,
@@ skipping 121 matching lines @@
   // Loop that checks if there is an IC data match.
   Label loop, update, test, found;
   // R9: IC data object (preserved).
   __ ldr(R8, FieldAddress(R9, ICData::ic_data_offset()));
   // R8: ic_data_array with check entries: classes and target functions.
   __ AddImmediate(R8, R8, Array::data_offset() - kHeapObjectTag);
   // R8: points directly to the first ic data array element.
 
   // Get the receiver's class ID (first read number of arguments from
   // arguments descriptor array and then access the receiver from the stack).
-  __ ldr(R7, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
-  __ sub(R7, R7, Operand(Smi::RawValue(1)));
-  __ ldr(R0, Address(SP, R7, LSL, 1));  // R7 (argument_count - 1) is smi.
+  __ ldr(R711, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
+  __ sub(R711, R711, Operand(Smi::RawValue(1)));
+  __ ldr(R0, Address(SP, R711, LSL, 1));  // R711 (argument_count - 1) is smi.
   __ LoadTaggedClassIdMayBeSmi(R0, R0);
-  // R7: argument_count - 1 (smi).
+  // R711: argument_count - 1 (smi).
   // R0: receiver's class ID (smi).
   __ ldr(R1, Address(R8, 0));  // First class id (smi) to check.
   __ b(&test);
 
   __ Comment("ICData loop");
   __ Bind(&loop);
   for (int i = 0; i < num_args; i++) {
     if (i > 0) {
       // If not the first, load the next argument's class ID.
-      __ AddImmediate(R0, R7, Smi::RawValue(-i));
+      __ AddImmediate(R0, R711, Smi::RawValue(-i));
       __ ldr(R0, Address(SP, R0, LSL, 1));
       __ LoadTaggedClassIdMayBeSmi(R0, R0);
       // R0: next argument class ID (smi).
       __ LoadFromOffset(kWord, R1, R8, i * kWordSize);
       // R1: next class ID to check (smi).
     }
     __ cmp(R0, Operand(R1));  // Class id match?
     if (i < (num_args - 1)) {
       __ b(&update, NE);  // Continue.
     } else {
       // Last check, all checks before matched.
       __ b(&found, EQ);  // Break.
     }
   }
   __ Bind(&update);
   // Reload receiver class ID.  It has not been destroyed when num_args == 1.
   if (num_args > 1) {
-    __ ldr(R0, Address(SP, R7, LSL, 1));
+    __ ldr(R0, Address(SP, R711, LSL, 1));
     __ LoadTaggedClassIdMayBeSmi(R0, R0);
   }
 
   const intptr_t entry_size = ICData::TestEntryLengthFor(num_args) * kWordSize;
   __ AddImmediate(R8, entry_size);  // Next entry.
   __ ldr(R1, Address(R8, 0));  // Next class ID.
 
   __ Bind(&test);
   __ CompareImmediate(R1, Smi::RawValue(kIllegalCid));  // Done?
   __ b(&loop, NE);
 
   __ Comment("IC miss");
   // Compute address of arguments.
-  // R7: argument_count - 1 (smi).
-  __ add(R7, SP, Operand(R7, LSL, 1));  // R7 is Smi.
-  // R7: address of receiver.
+  // R711: argument_count - 1 (smi).
+  __ add(R711, SP, Operand(R711, LSL, 1));  // R711 is Smi.
+  // R711: address of receiver.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ LoadObject(R0, Object::null_object());
   // Preserve IC data object and arguments descriptor array and
   // setup space on stack for result (target code object).
   __ PushList((1 << R0) | (1 << R4) | (1 << R9));
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
-    __ LoadFromOffset(kWord, IP, R7, -i * kWordSize);
+    __ LoadFromOffset(kWord, IP, R711, -i * kWordSize);
     __ Push(IP);
   }
   // Pass IC data object.
   __ Push(R9);
   __ CallRuntime(handle_ic_miss, num_args + 1);
   // Remove the call arguments pushed earlier, including the IC data object.
   __ Drop(num_args + 1);
   // Pop returned function object into R0.
   // Restore arguments descriptor array and IC data array.
   __ PopList((1 << R0) | (1 << R4) | (1 << R9));
@@ skipping 639 matching lines @@
 // Result:
 //  R1: entry point.
 void StubCode::GenerateMegamorphicLookupStub(Assembler* assembler) {
   EmitMegamorphicLookup(assembler, R0, R1, R1);
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM