Bump the C stack pointer when building Dart frames to maintain the ARM64 ABI requirements without g…

runtime/vm/assembler_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"  // NOLINT
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/longjump.h"
@@ skipping 1108 matching lines @@
   ldr(TMP, FieldAddress(CODE_REG, Code::saved_instructions_offset()));
   cmp(R0, Operand(TMP));
   b(&instructions_ok, EQ);
   brk(1);
   Bind(&instructions_ok);
   Pop(R0);
 #endif
 }
 
 
+void Assembler::SetupDartSP() {
+  mov(SP, CSP);
+}
+
+
+void Assembler::RestoreCSP() {
+  mov(CSP, SP);
+}
+
+
 void Assembler::EnterFrame(intptr_t frame_size) {
+  // The ARM64 ABI requires at all times
+  //   - stack limit < CSP <= stack base
+  //   - CSP mod 16 = 0
+  //   - we do not access stack memory below CSP
+  // Pratically, this means we need to keep the C stack pointer ahead of the
+  // Dart stack pointer and 16-byte aligned for signal handlers. If we knew the
+  // real stack limit, we could just set CSP to a value near it during
+  // SetupDartSP, but we do not know the real stack limit for the initial
+  // thread or threads created by the embedder.
+  const intptr_t kMaxDartFrameSize = 256;

[rmacnak, 2016/05/27 04:44:51]

Not sure where in the compiler to check this isn't exceeded.

[Vyacheslav Egorov (Google), 2016/05/27 15:34:52]

It's not that easy. 

FlowGraphCompiler::StackSize can give you the size of fixed portion of the
frame, but you will have to track the dynamic size (e.g. expression stack in the
unoptimized version and pushed arguments in the optimized version) manually. 

If you need a guidance of how to implement that - I am happy to help. It can be
modeled after FlowGraphCompiler::FrameStateUpdateWith() except that you need to
just track the frame height instead of tracking the representations of pushed
values. You would also need to carry information from predecessors to
successors.

+  sub(TMP, SP, Operand(kMaxDartFrameSize));
+  andi(CSP, TMP, Immediate(~15));
+
   PushPair(LR, FP);
   mov(FP, SP);
 
   if (frame_size > 0) {
     sub(SP, SP, Operand(frame_size));
   }
 }
 
 
 void Assembler::LeaveFrame() {
@@ skipping 305 matching lines @@
     add(base, array, Operand(index, LSL, shift));
   }
   const OperandSize size = Address::OperandSizeFor(cid);
   ASSERT(Address::CanHoldOffset(offset, Address::Offset, size));
   return Address(base, offset, Address::Offset, size);
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64