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

runtime/vm/stub_code_arm64.cc

Index: runtime/vm/stub_code_arm64.cc
===================================================================
--- runtime/vm/stub_code_arm64.cc	(revision 36919)
+++ runtime/vm/stub_code_arm64.cc	(working copy)
@@ -51,8 +51,7 @@
 
   // 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);
@@ -77,8 +76,9 @@
   // 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.
@@ -101,12 +101,26 @@
     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);
@@ -155,8 +169,7 @@
 
   // 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);
@@ -210,6 +223,12 @@
   __ 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;
@@ -234,6 +253,9 @@
   __ 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);
@@ -276,8 +298,7 @@
 
   // 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);
@@ -331,9 +352,19 @@
   __ 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);
@@ -487,9 +518,7 @@
 
   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.
@@ -504,8 +533,7 @@
 
   // 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.
@@ -547,8 +575,7 @@
   }
   __ LeaveStubFrame();
   // Remove materialization arguments.
-  __ add(TMP, SP, Operand(R1, UXTX, 0));
-  __ mov(SP, TMP);
+  __ add(SP, SP, Operand(R1));
   __ ret();
 }
 
@@ -748,6 +775,9 @@
 //   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);

[regis, 2014/06/03 17:38:22]

From this point on, CSP will not be updated anymore until we return from Dart
code into C code. Dart code will effectively use the stack space below the stack
pointer known to the system. Are we sure this is safe? What about interrupts
that could use the stack? The system usually keeps a red zone below the stack
pointer that it will not touch, but Dart code will definitely use the stack
below the red zone.

[zra, 2014/06/03 18:09:49]

See comment below.

   __ EnterFrame(0);
 
   // The new context, saved vm tag, the top exit frame, and the old context.
@@ -786,9 +816,15 @@
   // 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);

[zra, 2014/06/03 18:09:49]

CSP is updated here to be the isolate's stack limit. Except for the frame setup
code above, the Dart stack pointer SP will never go below the system stack
pointer. I could move this up before we use the stack to save the callee-saved
registers, but since this arrangement hasn't caused problems, I thought it would
be best to perturb the frame setup code as little as possible.

[regis, 2014/06/03 18:52:15]

I had missed this write to CSP. This is good. I would still protect the stack up
to this point by subtracting the frame size from CSP before the EnterFrame
above. An estimated size is good enough, i.e. a constant multiple of 16 and
larger than the size of all registers you are pushing.

To be safe, you should do the same in all tests copying CSP to SP. Maybe you
could have a new EnterFrame flavor (EnterSafeFrame?) that takes a size to
reserve. You could use it here too.

+
+  // 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);
@@ -884,12 +920,14 @@
     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();
 }
 
@@ -1786,7 +1824,8 @@
 
 
 void StubCode::GenerateGetStackPointerStub(Assembler* assembler) {
-  __ Stop("GenerateGetStackPointerStub");
+  __ mov(R0, SP);
+  __ ret();
 }