ARM and MIPS changes which correspond to the initial change submitted in

runtime/vm/stub_code_mips.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_MIPS)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 21 matching lines @@
 //   SP : address of last argument in argument array.
 //   SP + 4*S4 - 4 : address of first argument in argument array.
 //   SP + 4*S4 : address of return value.
 //   S5 : address of the runtime function to call.
 //   S4 : number of arguments to the call.
 void StubCode::GenerateCallToRuntimeStub(Assembler* assembler) {
   const intptr_t isolate_offset = NativeArguments::isolate_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
+  const intptr_t exitframe_last_param_slot_from_fp = 1;
 
   __ SetPrologueOffset();
   __ TraceSimMsg("CallToRuntimeStub");
-  __ EnterStubFrame();
+  __ EnterFrame();
 
   // Load current Isolate pointer from Context structure into A0.
   __ lw(A0, FieldAddress(CTX, Context::isolate_offset()));
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to Dart VM C++ code.
   __ sw(SP, Address(A0, Isolate::top_exit_frame_info_offset()));
 
   // Save current Context pointer into Isolate structure.
   __ sw(CTX, Address(A0, Isolate::top_context_offset()));
@@ skipping 14 matching lines @@
 
   // There are no runtime calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   ASSERT(argc_tag_offset == 1 * kWordSize);
   __ mov(A1, S4);  // Set argc in NativeArguments.
 
   ASSERT(argv_offset == 2 * kWordSize);
   __ sll(A2, S4, 2);
   __ addu(A2, FP, A2);  // Compute argv.
   // Set argv in NativeArguments.
-  __ addiu(A2, A2, Immediate(kParamEndSlotFromFp * kWordSize));
+  __ addiu(A2, A2, Immediate(exitframe_last_param_slot_from_fp * kWordSize));
 
   ASSERT(retval_offset == 3 * kWordSize);
 
   // Call runtime or redirection via simulator.
   __ jalr(S5);
   // Retval is next to 1st argument.
   __ delay_slot()->addiu(A3, A2, Immediate(kWordSize));
   __ TraceSimMsg("CallToRuntimeStub return");
 
   // Reset exit frame information in Isolate structure.
   __ sw(ZR, Address(CTX, Isolate::top_exit_frame_info_offset()));
 
   // Load Context pointer from Isolate structure into A2.
   __ lw(A2, Address(CTX, Isolate::top_context_offset()));
 
   // Load null.
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
 
   // Reset Context pointer in Isolate structure.
   __ sw(TMP, Address(CTX, Isolate::top_context_offset()));
 
   // Cache Context pointer into CTX while executing Dart code.
   __ mov(CTX, A2);
 
-  __ LeaveStubFrameAndReturn();
+  __ LeaveFrameAndReturn();
 }
 
 
 // Print the stop message.
 DEFINE_LEAF_RUNTIME_ENTRY(void, PrintStopMessage, 1, const char* message) {
   OS::Print("Stop message: %s\n", message);
 }
 END_LEAF_RUNTIME_ENTRY
 
 
@@ skipping 16 matching lines @@
 //   A2 : address of first argument in argument array.
 //   A1 : argc_tag including number of arguments and function kind.
 void StubCode::GenerateCallNativeCFunctionStub(Assembler* assembler) {
   const intptr_t isolate_offset = NativeArguments::isolate_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ SetPrologueOffset();
   __ TraceSimMsg("CallNativeCFunctionStub");
-  __ addiu(SP, SP, Immediate(-2 * kWordSize));
-  __ sw(RA, Address(SP, 1 * kWordSize));
-  __ sw(FP, Address(SP, 0 * kWordSize));
-  __ mov(FP, SP);
+  __ EnterFrame();
 
   // Load current Isolate pointer from Context structure into A0.
   __ lw(A0, FieldAddress(CTX, Context::isolate_offset()));
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to native code.
   __ sw(SP, Address(A0, Isolate::top_exit_frame_info_offset()));
 
   // Save current Context pointer into Isolate structure.
   __ sw(CTX, Address(A0, Isolate::top_context_offset()));
@@ skipping 51 matching lines @@
 
   // Load null.
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
 
   // Reset Context pointer in Isolate structure.
   __ sw(TMP, Address(CTX, Isolate::top_context_offset()));
 
   // Cache Context pointer into CTX while executing Dart code.
   __ mov(CTX, A2);
 
-  __ mov(SP, FP);
-  __ lw(RA, Address(SP, 1 * kWordSize));
-  __ lw(FP, Address(SP, 0 * kWordSize));
-  __ Ret();
-  __ delay_slot()->addiu(SP, SP, Immediate(2 * kWordSize));
+  __ LeaveFrameAndReturn();
 }
 
 
 // Input parameters:
 //   RA : return address.
 //   SP : address of return value.
 //   T5 : address of the native function to call.
 //   A2 : address of first argument in argument array.
 //   A1 : argc_tag including number of arguments and function kind.
 void StubCode::GenerateCallBootstrapCFunctionStub(Assembler* assembler) {
   const intptr_t isolate_offset = NativeArguments::isolate_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ SetPrologueOffset();
   __ TraceSimMsg("CallNativeCFunctionStub");
-  __ addiu(SP, SP, Immediate(-2 * kWordSize));
-  __ sw(RA, Address(SP, 1 * kWordSize));
-  __ sw(FP, Address(SP, 0 * kWordSize));
-  __ mov(FP, SP);
+  __ EnterFrame();
 
   // Load current Isolate pointer from Context structure into A0.
   __ lw(A0, FieldAddress(CTX, Context::isolate_offset()));
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to native code.
   __ sw(SP, Address(A0, Isolate::top_exit_frame_info_offset()));
 
   // Save current Context pointer into Isolate structure.
   __ sw(CTX, Address(A0, Isolate::top_context_offset()));
@@ skipping 42 matching lines @@
 
   // Load null.
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
 
   // Reset Context pointer in Isolate structure.
   __ sw(TMP, Address(CTX, Isolate::top_context_offset()));
 
   // Cache Context pointer into CTX while executing Dart code.
   __ mov(CTX, A2);
 
-  __ mov(SP, FP);
-  __ lw(RA, Address(SP, 1 * kWordSize));
-  __ lw(FP, Address(SP, 0 * kWordSize));
-  __ Ret();
-  __ delay_slot()->addiu(SP, SP, Immediate(2 * kWordSize));
+  __ LeaveFrameAndReturn();
 }
 
 
 // Input parameters:
 //   S4: arguments descriptor array.
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
   __ TraceSimMsg("CallStaticFunctionStub");
   __ EnterStubFrame();
   // Setup space on stack for return value and preserve arguments descriptor.
 
@@ skipping 574 matching lines @@
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
 //   RA : points to return address.
 //   A0 : entrypoint of the Dart function to call.
 //   A1 : arguments descriptor array.
 //   A2 : arguments array.
 //   A3 : new context containing the current isolate pointer.
 void StubCode::GenerateInvokeDartCodeStub(Assembler* assembler) {
   // Save frame pointer coming in.
   __ TraceSimMsg("InvokeDartCodeStub");
-  __ EnterStubFrame();
+  __ EnterFrame();
 
   // Save new context and C++ ABI callee-saved registers.
 
   // The new context, the top exit frame, and the old context.
   const intptr_t kPreservedContextSlots = 3;
   const intptr_t kNewContextOffsetFromFp =
       -(1 + kAbiPreservedCpuRegCount + kAbiPreservedFpuRegCount) * kWordSize;
   const intptr_t kPreservedRegSpace =
       kWordSize * (kAbiPreservedCpuRegCount + kAbiPreservedFpuRegCount +
                    kPreservedContextSlots);
 
   __ addiu(SP, SP, Immediate(-kPreservedRegSpace));
   for (int i = S0; i <= S7; i++) {
     Register r = static_cast<Register>(i);
     const intptr_t slot = i - S0 + kPreservedContextSlots;
     __ sw(r, Address(SP, slot * kWordSize));
   }
 
   for (intptr_t i = kAbiFirstPreservedFpuReg;
        i <= kAbiLastPreservedFpuReg; i++) {
     FRegister r = static_cast<FRegister>(i);
     const intptr_t slot =
         kAbiPreservedCpuRegCount + kPreservedContextSlots + i -
         kAbiFirstPreservedFpuReg;
     __ swc1(r, Address(SP, slot * kWordSize));
   }
 
   __ sw(A3, Address(SP, 2 * kWordSize));
 
+  // We now load the pool pointer(PP) as we are about to invoke dart code and we
+  // could potentially invoke some intrinsic functions which need the PP to be
+  // set up.
+  __ LoadPoolPointer();
+
   // The new Context structure contains a pointer to the current Isolate
   // structure. Cache the Context pointer in the CTX register so that it is
   // available in generated code and calls to Isolate::Current() need not be
   // done. The assumption is that this register will never be clobbered by
   // compiled or runtime stub code.
 
   // Cache the new Context pointer into CTX while executing Dart code.
   __ lw(CTX, Address(A3, VMHandles::kOffsetOfRawPtrInHandle));
 
   // Load Isolate pointer from Context structure into temporary register R8.
@@ skipping 83 matching lines @@
     const intptr_t slot =
         kAbiPreservedCpuRegCount + kPreservedContextSlots + i -
         kAbiFirstPreservedFpuReg;
     __ lwc1(r, Address(SP, slot * kWordSize));
   }
 
   __ lw(A3, Address(SP, 2 * kWordSize));
   __ addiu(SP, SP, Immediate(kPreservedRegSpace));
 
   // Restore the frame pointer and return.
-  __ LeaveStubFrameAndReturn();
+  __ LeaveFrameAndReturn();
 }
 
 
 // Called for inline allocation of contexts.
 // Input:
 //   T1: number of context variables.
 // Output:
 //   V0: new allocated RawContext object.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
   __ TraceSimMsg("AllocateContext");
@@ skipping 353 matching lines @@
     __ sw(T7, Address(SP, 1 * kWordSize));
     __ sw(T1, Address(SP, 0 * kWordSize));
   }
   __ CallRuntime(kAllocateObjectRuntimeEntry, 3);  // Allocate object.
   __ TraceSimMsg("AllocationStubForClass return");
   // Pop result (newly allocated object).
   __ lw(V0, Address(SP, 3 * kWordSize));
   __ addiu(SP, SP, Immediate(4 * kWordSize));  // Pop arguments.
   // V0: new object
   // Restore the frame pointer and return.
-  __ LeaveStubFrameAndReturn(RA, true);
+  __ LeaveStubFrameAndReturn(RA);
 }
 
 
 // Called for inline allocation of closures.
 // Input parameters:
 //   RA: return address.
 //   SP + 4 : receiver (null if not an implicit instance closure).
 //   SP + 0 : type arguments object (null if class is no parameterized).
 void StubCode::GenerateAllocationStubForClosure(Assembler* assembler,
                                                 const Function& func) {
@@ skipping 87 matching lines @@
     }
 
     // Set the type arguments field in the newly allocated closure.
     __ lw(T0, Address(FP, kTypeArgumentsFPOffset));
     __ sw(T0, Address(T2, Closure::type_arguments_offset()));
 
     // Done allocating and initializing the instance.
     // V0: new object.
     __ addiu(V0, T2, Immediate(kHeapObjectTag));
 
-    __ LeaveStubFrameAndReturn(RA, true);
+    __ LeaveStubFrameAndReturn(RA);
 
     __ Bind(&slow_case);
   }
 
   // If it's an implicit instance closure we need 4 stack slots, o/w only 3.
   intptr_t num_slots = is_implicit_instance_closure ? 4 : 3;
   __ addiu(SP, SP, Immediate(-num_slots * kWordSize));
   // Setup space on stack for return value.
   __ LoadImmediate(T7, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(T7, Address(SP, (num_slots - 1) * kWordSize));
@@ skipping 15 matching lines @@
   } else {
     ASSERT(func.IsNonImplicitClosureFunction());
     __ CallRuntime(kAllocateClosureRuntimeEntry, 2);
     __ TraceSimMsg("AllocationStubForClosure return");
   }
   __ lw(V0, Address(SP, (num_slots - 1) * kWordSize));  // Pop function object.
   __ addiu(SP, SP, Immediate(num_slots * kWordSize));
 
   // V0: new object
   // Restore the frame pointer.
-  __ LeaveStubFrameAndReturn(RA, true);
+  __ LeaveStubFrameAndReturn(RA);
 }
 
 
 // Called for invoking "dynamic noSuchMethod(Invocation invocation)" function
 // from the entry code of a dart function after an error in passed argument
 // name or number is detected.
 // Input parameters:
 //  RA : return address.
 //  SP : address of last argument.
 //  S5: inline cache data object.
@@ skipping 853 matching lines @@
   const Register right = T0;
   __ lw(left, Address(SP, 1 * kWordSize));
   __ lw(right, Address(SP, 0 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp1, temp2);
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS