Remove stack_frame_<arch>.cc files.

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/compiler.h"
@@ skipping 223 matching lines @@
   __ LeaveStubFrame();
   // Jump to the dart function.
   __ ldr(R0, FieldAddress(R0, Code::instructions_offset()));
   __ AddImmediate(R0, R0, Instructions::HeaderSize() - kHeapObjectTag);
   __ bx(R0);
 }
 
 
 // Input parameters:
 //   R2: smi-tagged argument count, may be zero.
-//   FP[kLastParamSlotIndex]: last argument.
+//   FP[kParamEndSlotFromFp + 1]: last argument.
 static void PushArgumentsArray(Assembler* assembler) {
   // Allocate array to store arguments of caller.
   __ LoadImmediate(R1, reinterpret_cast<intptr_t>(Object::null()));
   // R1: null element type for raw Array.
   // R2: smi-tagged argument count, may be zero.
   __ BranchLink(&StubCode::AllocateArrayLabel());
   // R0: newly allocated array.
   // R2: smi-tagged argument count, may be zero (was preserved by the stub).
   __ Push(R0);  // Array is in R0 and on top of stack.
   __ add(R1, FP, ShifterOperand(R2, LSL, 1));
-  __ AddImmediate(R1, (kLastParamSlotIndex - 1) * kWordSize);
+  __ AddImmediate(R1, kParamEndSlotFromFp * kWordSize);
   __ AddImmediate(R3, R0, Array::data_offset() - kHeapObjectTag);
   // R1: address of first argument on stack.
   // R3: address of first argument in array.
   Label loop;
   __ Bind(&loop);
   __ subs(R2, R2, ShifterOperand(Smi::RawValue(1)));  // R2 is Smi.
   __ ldr(IP, Address(R1, 0), PL);
   __ str(IP, Address(R3, 0), PL);
   __ AddImmediate(R1, -kWordSize, PL);
   __ AddImmediate(R3, kWordSize, PL);
   __ b(&loop, PL);
 }
 
 
 // Input parameters:
 //   R5: ic-data.
 //   R4: arguments descriptor array.
 // Note: The receiver object is the first argument to the function being
 //       called, the stub accesses the receiver from this location directly
 //       when trying to resolve the call.
 void StubCode::GenerateInstanceFunctionLookupStub(Assembler* assembler) {
   __ EnterStubFrame();
 
   // Load the receiver.
   __ ldr(R2, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
   __ add(IP, FP, ShifterOperand(R2, LSL, 1));  // R2 is Smi.
-  __ ldr(R6, Address(IP, (kLastParamSlotIndex - 1) * kWordSize));
+  __ ldr(R6, Address(IP, kParamEndSlotFromFp * kWordSize));
 
   // Push space for the return value.
   // Push the receiver.
   // Push IC data object.
   // Push arguments descriptor array.
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
   __ PushList((1 << R4) | (1 << R5) | (1 << R6) | (1 << IP));
 
   // R2: Smi-tagged arguments array length.
   PushArgumentsArray(assembler);
@@ skipping 392 matching lines @@
 
   // Save the top exit frame info. Use R5 as a temporary register.
   // StackFrameIterator reads the top exit frame info saved in this frame.
   __ LoadFromOffset(kLoadWord, R5, R8, Isolate::top_exit_frame_info_offset());
   __ LoadImmediate(R6, 0);
   __ StoreToOffset(kStoreWord, R6, R8, Isolate::top_exit_frame_info_offset());
 
   // Save the old Context pointer. Use R4 as a temporary register.
   // Note that VisitObjectPointers will find this saved Context pointer during
   // GC marking, since it traverses any information between SP and
-  // FP - kExitLinkOffsetInEntryFrame.
+  // FP - kExitLinkSlotFromEntryFp.
   // EntryFrame::SavedContext reads the context saved in this frame.
   __ LoadFromOffset(kLoadWord, R4, R8, Isolate::top_context_offset());
 
-  // The constants kSavedContextOffsetInEntryFrame and
-  // kExitLinkOffsetInEntryFrame must be kept in sync with the code below.
+  // The constants kSavedContextSlotFromEntryFp and
+  // kExitLinkSlotFromEntryFp must be kept in sync with the code below.
+  ASSERT(kExitLinkSlotFromEntryFp == -9);
+  ASSERT(kSavedContextSlotFromEntryFp == -10);
   __ PushList((1 << R4) | (1 << R5));
 
   // The stack pointer is restored after the call to this location.
-  const intptr_t kSavedContextOffsetInEntryFrame = -10 * kWordSize;
+  const intptr_t kSavedContextSlotFromEntryFp = -10 * kWordSize;
 
   // Load arguments descriptor array into R4, which is passed to Dart code.
   __ ldr(R4, Address(R1, VMHandles::kOffsetOfRawPtrInHandle));
 
   // Load number of arguments into R5.
   __ ldr(R5, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
   __ SmiUntag(R5);
 
   // Compute address of 'arguments array' data area into R2.
   __ ldr(R2, Address(R2, VMHandles::kOffsetOfRawPtrInHandle));
@@ skipping 15 matching lines @@
   __ Bind(&done_push_arguments);
 
   // Call the Dart code entrypoint.
   __ blx(R0);  // R4 is the arguments descriptor array.
 
   // Read the saved new Context pointer.
   __ ldr(CTX, Address(FP, kNewContextOffset));
   __ ldr(CTX, Address(CTX, VMHandles::kOffsetOfRawPtrInHandle));
 
   // Get rid of arguments pushed on the stack.
-  __ AddImmediate(SP, FP, kSavedContextOffsetInEntryFrame);
+  __ AddImmediate(SP, FP, kSavedContextSlotFromEntryFp);
 
   // Load Isolate pointer from Context structure into CTX. Drop Context.
   __ ldr(CTX, FieldAddress(CTX, Context::isolate_offset()));
 
   // Restore the saved Context pointer into the Isolate structure.
   // Uses R4 as a temporary register for this.
   // Restore the saved top exit frame info back into the Isolate structure.
   // Uses R5 as a temporary register for this.
   __ PopList((1 << R4) | (1 << R5));
   __ StoreToOffset(kStoreWord, R4, CTX, Isolate::top_context_offset());
@@ skipping 1172 matching lines @@
   __ Bind(&reference_compare);
   __ cmp(left, ShifterOperand(right));
   __ Bind(&done);
   __ PopList((1 << R0) | (1 << R1) | (1 << R2));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM