Fixes to run "Hello, world!" on arm64 hardware.

runtime/vm/stub_code_arm64.cc

 // Copyright (c) 2014, 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_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 33 matching lines @@
 
   __ SetPrologueOffset();
   __ Comment("CallToRuntimeStub");
   __ EnterFrame(0);
 
   // Load current Isolate pointer from Context structure into R0.
   __ LoadFieldFromOffset(R0, CTX, Context::isolate_offset(), kNoPP);
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to Dart VM C++ code.
-  __ mov(TMP, SP);  // Can't directly store SP.
-  __ StoreToOffset(TMP, R0, Isolate::top_exit_frame_info_offset(), kNoPP);
+  __ StoreToOffset(SP, R0, Isolate::top_exit_frame_info_offset(), kNoPP);
 
   // Save current Context pointer into Isolate structure.
   __ StoreToOffset(CTX, R0, Isolate::top_context_offset(), kNoPP);
 
   // Cache Isolate pointer into CTX while executing runtime code.
   __ mov(CTX, R0);
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
     __ LoadFromOffset(R8, R0, Isolate::vm_tag_offset(), kNoPP);
     __ CompareImmediate(R8, VMTag::kScriptTagId, kNoPP);
     __ b(&ok, EQ);
     __ Stop("Not coming from Dart code.");
     __ Bind(&ok);
   }
 #endif
 
   // Mark that the isolate is executing VM code.
   __ StoreToOffset(R5, R0, Isolate::vm_tag_offset(), kNoPP);
 
   // Reserve space for arguments and align frame before entering C++ world.
   // NativeArguments are passed in registers.
   __ Comment("align stack");
+  // Reserve space for arguments.
   ASSERT(sizeof(NativeArguments) == 4 * kWordSize);
-  __ ReserveAlignedFrameSpace(4 * kWordSize);  // Reserve space for arguments.
+  __ ReserveAlignedFrameSpace(sizeof(NativeArguments));
 
   // Pass NativeArguments structure by value and call runtime.
   // Registers R0, R1, R2, and R3 are used.
 
   ASSERT(isolate_offset == 0 * kWordSize);
   // Set isolate in NativeArgs: R0 already contains CTX.
 
   // 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(R1, R4);  // Set argc in NativeArguments.
 
   ASSERT(argv_offset == 2 * kWordSize);
   __ add(R2, ZR, Operand(R4, LSL, 3));
   __ add(R2, FP, Operand(R2));  // Compute argv.
   // Set argv in NativeArguments.
   __ AddImmediate(R2, R2, exitframe_last_param_slot_from_fp * kWordSize,
                   kNoPP);
 
     ASSERT(retval_offset == 3 * kWordSize);
   __ AddImmediate(R3, R2, kWordSize, kNoPP);
 
-  // TODO(zra): Check that the ABI allows calling through this register.
+  __ StoreToOffset(R0, SP, isolate_offset, kNoPP);
+  __ StoreToOffset(R1, SP, argc_tag_offset, kNoPP);
+  __ StoreToOffset(R2, SP, argv_offset, kNoPP);
+  __ StoreToOffset(R3, SP, retval_offset, kNoPP);
+  __ mov(R0, SP);  // Pass the pointer to the NativeArguments.
+
+  // We are entering runtime code, so the C stack pointer must be restored from
+  // the stack limit to the top of the stack. We cache the stack limit address
+  // in a callee-saved register.
+  __ mov(R26, CSP);
+  __ mov(CSP, SP);
+
   __ blr(R5);
+  __ Comment("CallToRuntimeStub return");
+
+  // Restore SP and CSP.
+  __ mov(SP, CSP);
+  __ mov(CSP, R26);
 
   // Retval is next to 1st argument.
-  __ Comment("CallToRuntimeStub return");
-
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(R2, VMTag::kScriptTagId, kNoPP);
   __ StoreToOffset(R2, CTX, Isolate::vm_tag_offset(), kNoPP);
 
   // Reset exit frame information in Isolate structure.
   __ StoreToOffset(ZR, CTX, Isolate::top_exit_frame_info_offset(), kNoPP);
 
   // Load Context pointer from Isolate structure into A2.
   __ LoadFromOffset(R2, CTX, Isolate::top_context_offset(), kNoPP);
 
@@ skipping 28 matching lines @@
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ EnterFrame(0);
 
   // Load current Isolate pointer from Context structure into R0.
   __ LoadFieldFromOffset(R0, CTX, Context::isolate_offset(), kNoPP);
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to native code.
-  __ mov(TMP, SP);
-  __ StoreToOffset(TMP, R0, Isolate::top_exit_frame_info_offset(), kNoPP);
+  __ StoreToOffset(SP, R0, Isolate::top_exit_frame_info_offset(), kNoPP);
 
   // Save current Context pointer into Isolate structure.
   __ StoreToOffset(CTX, R0, Isolate::top_context_offset(), kNoPP);
 
   // Cache Isolate pointer into CTX while executing native code.
   __ mov(CTX, R0);
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
@@ skipping 33 matching lines @@
 
   // Passing the structure by value as in runtime calls would require changing
   // Dart API for native functions.
   // For now, space is reserved on the stack and we pass a pointer to it.
   __ StoreToOffset(R0, SP, isolate_offset, kNoPP);
   __ StoreToOffset(R1, SP, argc_tag_offset, kNoPP);
   __ StoreToOffset(R2, SP, argv_offset, kNoPP);
   __ StoreToOffset(R3, SP, retval_offset, kNoPP);
   __ mov(R0, SP);  // Pass the pointer to the NativeArguments.
 
+  // We are entering runtime code, so the C stack pointer must be restored from
+  // the stack limit to the top of the stack. We cache the stack limit address
+  // in the Dart SP register, which is callee-saved in the C ABI.
+  __ mov(R26, CSP);
+  __ mov(CSP, SP);
+
   // Call native function (setsup scope if not leaf function).
   Label leaf_call;
   Label done;
   __ TestImmediate(R1, NativeArguments::AutoSetupScopeMask(), kNoPP);
   __ b(&leaf_call, EQ);
 
   __ mov(R1, R5);  // Pass the function entrypoint to call.
   // Call native function invocation wrapper or redirection via simulator.
 #if defined(USING_SIMULATOR)
   uword entry = reinterpret_cast<uword>(NativeEntry::NativeCallWrapper);
   entry = Simulator::RedirectExternalReference(
       entry, Simulator::kNativeCall, NativeEntry::kNumCallWrapperArguments);
   __ LoadImmediate(R2, entry, kNoPP);
   __ blr(R2);
 #else
   __ BranchLink(&NativeEntry::NativeCallWrapperLabel(), kNoPP);
 #endif
   __ b(&done);
 
   __ Bind(&leaf_call);
   // Call native function or redirection via simulator.
   __ blr(R5);
 
   __ Bind(&done);
+  // Restore SP and CSP.
+  __ mov(SP, CSP);
+  __ mov(CSP, R26);
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(R2, VMTag::kScriptTagId, kNoPP);
   __ StoreToOffset(R2, CTX, Isolate::vm_tag_offset(), kNoPP);
 
   // Reset exit frame information in Isolate structure.
   __ StoreToOffset(ZR, CTX, Isolate::top_exit_frame_info_offset(), kNoPP);
 
   // Load Context pointer from Isolate structure into R2.
   __ LoadFromOffset(R2, CTX, Isolate::top_context_offset(), kNoPP);
@@ skipping 22 matching lines @@
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ EnterFrame(0);
 
   // Load current Isolate pointer from Context structure into R0.
   __ LoadFieldFromOffset(R0, CTX, Context::isolate_offset(), kNoPP);
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to native code.
-  __ mov(TMP, SP);  // Can't store SP directly, first copy to TMP.
-  __ StoreToOffset(TMP, R0, Isolate::top_exit_frame_info_offset(), kNoPP);
+  __ StoreToOffset(SP, R0, Isolate::top_exit_frame_info_offset(), kNoPP);
 
   // Save current Context pointer into Isolate structure.
   __ StoreToOffset(CTX, R0, Isolate::top_context_offset(), kNoPP);
 
   // Cache Isolate pointer into CTX while executing native code.
   __ mov(CTX, R0);
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
@@ skipping 33 matching lines @@
 
   // Passing the structure by value as in runtime calls would require changing
   // Dart API for native functions.
   // For now, space is reserved on the stack and we pass a pointer to it.
   __ StoreToOffset(R0, SP, isolate_offset, kNoPP);
   __ StoreToOffset(R1, SP, argc_tag_offset, kNoPP);
   __ StoreToOffset(R2, SP, argv_offset, kNoPP);
   __ StoreToOffset(R3, SP, retval_offset, kNoPP);
   __ mov(R0, SP);  // Pass the pointer to the NativeArguments.
 
+  // We are entering runtime code, so the C stack pointer must be restored from
+  // the stack limit to the top of the stack. We cache the stack limit address
+  // in the Dart SP register, which is callee-saved in the C ABI.
+  __ mov(R26, CSP);
+  __ mov(CSP, SP);
+
   // Call native function or redirection via simulator.
   __ blr(R5);
 
+  // Restore SP and CSP.
+  __ mov(SP, CSP);
+  __ mov(CSP, R26);
+
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(R2, VMTag::kScriptTagId, kNoPP);
   __ StoreToOffset(R2, CTX, Isolate::vm_tag_offset(), kNoPP);
 
   // Reset exit frame information in Isolate structure.
   __ StoreToOffset(ZR, CTX, Isolate::top_exit_frame_info_offset(), kNoPP);
 
   // Load Context pointer from Isolate structure into R2.
   __ LoadFromOffset(R2, CTX, Isolate::top_context_offset(), kNoPP);
 
@@ skipping 133 matching lines @@
 
   // Push registers in their enumeration order: lowest register number at
   // lowest address.
   for (intptr_t i = kNumberOfCpuRegisters - 1; i >= 0; i--) {
     const Register r = static_cast<Register>(i);
     __ str(r, Address(SP, -1 * kWordSize, Address::PreIndex));
   }
 
   for (intptr_t reg_idx = kNumberOfVRegisters - 1; reg_idx >= 0; reg_idx--) {
     VRegister vreg = static_cast<VRegister>(reg_idx);
-    // TODO(zra): Save whole V registers. For now, push twice.
-    __ PushDouble(vreg);
-    __ PushDouble(vreg);
+    __ PushQuad(vreg);
   }
 
   __ mov(R0, SP);  // Pass address of saved registers block.
   __ ReserveAlignedFrameSpace(0);
   __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry, 1);
   // Result (R0) is stack-size (FP - SP) in bytes.
 
   if (preserve_result) {
     // Restore result into R1 temporarily.
     __ LoadFromOffset(R1, FP, saved_result_slot_from_fp * kWordSize, kNoPP);
   }
 
   // There is a Dart Frame on the stack. We must restore PP and leave frame.
   __ LeaveDartFrame();
-  __ sub(TMP, FP, Operand(R0));
-  __ mov(SP, TMP);
+  __ sub(SP, FP, Operand(R0));
 
   // DeoptimizeFillFrame expects a Dart frame, i.e. EnterDartFrame(0), but there
   // is no need to set the correct PC marker or load PP, since they get patched.
   __ EnterFrame(0);
   __ Push(ZR);
   __ TagAndPushPP();
 
   if (preserve_result) {
     __ Push(R1);  // Preserve result as first local.
   }
@@ skipping 21 matching lines @@
   // Result tells stub how many bytes to remove from the expression stack
   // of the bottom-most frame. They were used as materialization arguments.
   __ Pop(R1);
   __ SmiUntag(R1);
   if (preserve_result) {
     __ Pop(R0);  // Restore result.
     __ Drop(1);  // Workaround for dropped stack slot during GC.
   }
   __ LeaveStubFrame();
   // Remove materialization arguments.
-  __ add(TMP, SP, Operand(R1, UXTX, 0));
-  __ mov(SP, TMP);
+  __ add(SP, SP, Operand(R1));
   __ ret();
 }
 
 
 void StubCode::GenerateDeoptimizeLazyStub(Assembler* assembler) {
   // Correct return address to point just after the call that is being
   // deoptimized.
   __ AddImmediate(LR, LR, -CallPattern::kLengthInBytes, kNoPP);
   GenerateDeoptimizationSequence(assembler, true);  // Preserve R0.
 }
@@ skipping 179 matching lines @@
 
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
 //   LR : points to return address.
 //   R0 : entrypoint of the Dart function to call.
 //   R1 : arguments descriptor array.
 //   R2 : arguments array.
 //   R3 : new context containing the current isolate pointer.
 void StubCode::GenerateInvokeDartCodeStub(Assembler* assembler) {
   __ Comment("InvokeDartCodeStub");
+  // Copy the C stack pointer (R31) into the stack pointer we'll actually use
+  // to access the stack.
+  __ mov(SP, CSP);
   __ EnterFrame(0);
 
   // The new context, saved vm tag, the top exit frame, and the old context.
   const intptr_t kNewContextOffsetFromFp =
       -(1 + kAbiPreservedCpuRegCount + kAbiPreservedFpuRegCount) * kWordSize;
 
   // Save the callee-saved registers.
   for (int i = kAbiFirstPreservedCpuReg; i <= kAbiLastPreservedCpuReg; i++) {
     const Register r = static_cast<Register>(i);
     // We use str instead of the Push macro because we will be pushing the PP
@@ skipping 18 matching lines @@
 
   // 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.
   __ LoadFromOffset(CTX, R3, VMHandles::kOffsetOfRawPtrInHandle, PP);
 
-  // Load Isolate pointer from Context structure into temporary register R4.
+  // Load Isolate pointer from Context structure into temporary register R5.
   __ LoadFieldFromOffset(R5, CTX, Context::isolate_offset(), PP);
 
+  // Load the stack limit address into the C stack pointer register.
+  __ LoadFromOffset(CSP, R5, Isolate::stack_limit_offset(), PP);
+
+  // Cache the new Context pointer into CTX while executing Dart code.
+  __ LoadFromOffset(CTX, R3, VMHandles::kOffsetOfRawPtrInHandle, PP);
+
   // Save the current VMTag on the stack.
   ASSERT(kSavedVMTagSlotFromEntryFp == -20);
   __ LoadFromOffset(R4, R5, Isolate::vm_tag_offset(), PP);
   __ Push(R4);
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(R6, VMTag::kScriptTagId, PP);
   __ StoreToOffset(R6, R5, Isolate::vm_tag_offset(), PP);
 
   // Save the top exit frame info. Use R6 as a temporary register.
@@ skipping 75 matching lines @@
   for (int i = kAbiLastPreservedFpuReg; i >= kAbiFirstPreservedFpuReg; i--) {
     const VRegister r = static_cast<VRegister>(i);
     __ PopDouble(r);
   }
 
   // Restore C++ ABI callee-saved registers.
   for (int i = kAbiLastPreservedCpuReg; i >= kAbiFirstPreservedCpuReg; i--) {
     Register r = static_cast<Register>(i);
     // We use ldr instead of the Pop macro because we will be popping the PP
     // register when it is not holding a pool-pointer since we are returning to
-    // C++ code.
+    // C++ code. We also skip the dart stack pointer SP, since we are still
+    // using it as the stack pointer.
     __ ldr(r, Address(SP, 1 * kWordSize, Address::PostIndex));
   }
 
-  // Restore the frame pointer and return.
+  // Restore the frame pointer and C stack pointer and return.
   __ LeaveFrame();
+  __ mov(CSP, SP);
   __ ret();
 }
 
 
 // Called for inline allocation of contexts.
 // Input:
 //   R1: number of context variables.
 // Output:
 //   R0: new allocated RawContext object.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
@@ skipping 876 matching lines @@
 // TOS + 1: instantiator type arguments.
 // TOS + 2: instance.
 // TOS + 3: cache array.
 // Result in RCX: null -> not found, otherwise result (true or false).
 void StubCode::GenerateSubtype3TestCacheStub(Assembler* assembler) {
   GenerateSubtypeNTestCacheStub(assembler, 3);
 }
 
 
 void StubCode::GenerateGetStackPointerStub(Assembler* assembler) {
-  __ Stop("GenerateGetStackPointerStub");
+  __ mov(R0, SP);
+  __ ret();
 }
 
 
 void StubCode::GenerateJumpToExceptionHandlerStub(Assembler* assembler) {
   __ Stop("GenerateJumpToExceptionHandlerStub");
 }
 
 
 // Calls to the runtime to optimize the given function.
 // R6: function to be re-optimized.
@@ skipping 124 matching lines @@
   const Register right = R0;
   __ LoadFromOffset(left, SP, 1 * kWordSize, kNoPP);
   __ LoadFromOffset(right, SP, 0 * kWordSize, kNoPP);
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64