Arm64: Ensure that csp is always aligned to 16 byte values even if jssp is not.

src/arm64/macro-assembler-arm64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "v8.h"
 
 #if V8_TARGET_ARCH_ARM64
 
 #include "bootstrapper.h"
 #include "codegen.h"
@@ skipping 782 matching lines @@
   // instruction, not even into the zero register.
   ASSERT(!AreAliased(dst0, dst1, dst2, dst3));
   ASSERT(AreSameSizeAndType(dst0, dst1, dst2, dst3));
   ASSERT(dst0.IsValid());
 
   int count = 1 + dst1.IsValid() + dst2.IsValid() + dst3.IsValid();
   int size = dst0.SizeInBytes();
 
   PrepareForPop(count, size);
   PopHelper(count, size, dst0, dst1, dst2, dst3);
-
-  if (!csp.Is(StackPointer()) && emit_debug_code()) {
-    // It is safe to leave csp where it is when unwinding the JavaScript stack,
-    // but if we keep it matching StackPointer, the simulator can detect memory
-    // accesses in the now-free part of the stack.
-    Mov(csp, StackPointer());

[jbramley, 2014/05/01 15:17:10]

It would be better to leave this here (or replace it with the new
SyncSystemStackPointer). Calling SyncSystemStackPointer in PrepareForPop works,
but it makes the check less strict than it could be. (I'd like this check to be
as strict as possible because bugs in this area would be hard to reproduce.)

[rmcilroy, 2014/05/01 18:29:11]

I see what you mean, but actually, looking at it again I actually think
PrepareForPop should be called after the PopHelper - it doesn't actually prepare
anything it just asserts that the stack is in a valid state and I think this
makes more sense to do after the PopHelper has been run.  I've made a change to
call it PushPreamble and PopPostamble and moved the calls about as appropriate. 
Wdyt?

-  }
 }
 
 
 void MacroAssembler::PushPopQueue::PushQueued() {
   if (queued_.empty()) return;
 
   masm_->PrepareForPush(size_);
 
   int count = queued_.size();
   int index = 0;
@@ skipping 68 matching lines @@
   // order to maintain the 16-byte alignment for csp.
   while (!registers.IsEmpty()) {
     int count_before = registers.Count();
     const CPURegister& dst0 = registers.PopLowestIndex();
     const CPURegister& dst1 = registers.PopLowestIndex();
     const CPURegister& dst2 = registers.PopLowestIndex();
     const CPURegister& dst3 = registers.PopLowestIndex();
     int count = count_before - registers.Count();
     PopHelper(count, size, dst0, dst1, dst2, dst3);
   }
-
-  if (!csp.Is(StackPointer()) && emit_debug_code()) {
-    // It is safe to leave csp where it is when unwinding the JavaScript stack,
-    // but if we keep it matching StackPointer, the simulator can detect memory
-    // accesses in the now-free part of the stack.
-    Mov(csp, StackPointer());
-  }
 }
 
 
 void MacroAssembler::PushMultipleTimes(CPURegister src, int count) {
   int size = src.SizeInBytes();
 
   PrepareForPush(count, size);
 
   if (FLAG_optimize_for_size && count > 8) {
     UseScratchRegisterScope temps(this);
@@ skipping 182 matching lines @@
   if (csp.Is(StackPointer())) {
     // If the current stack pointer is csp, then it must be aligned to 16 bytes
     // on entry and the total size of the specified registers must also be a
     // multiple of 16 bytes.
     if (total_size.IsImmediate()) {
       ASSERT((total_size.immediate() % 16) == 0);
     }
 
     // Don't check access size for non-immediate sizes. It's difficult to do
     // well, and it will be caught by hardware (or the simulator) anyway.
+  } else if (emit_debug_code()) {
+    // It is safe to leave csp where it is when unwinding the JavaScript stack,
+    // but if we keep it matching StackPointer, the simulator can detect memory
+    // accesses in the now-free part of the stack.
+    SyncSystemStackPointer();
   }
 }
 
 
 void MacroAssembler::Poke(const CPURegister& src, const Operand& offset) {
   if (offset.IsImmediate()) {
     ASSERT(offset.immediate() >= 0);
   } else if (emit_debug_code()) {
     Cmp(xzr, offset);
     Check(le, kStackAccessBelowStackPointer);
@@ skipping 76 matching lines @@
 
   ldp(d8, d9, tos);
   ldp(d10, d11, tos);
   ldp(d12, d13, tos);
   ldp(d14, d15, tos);
 }
 
 
 void MacroAssembler::AssertStackConsistency() {
   if (emit_debug_code()) {
-    if (csp.Is(StackPointer())) {
-      // We can't check the alignment of csp without using a scratch register
-      // (or clobbering the flags), but the processor (or simulator) will abort
-      // if it is not properly aligned during a load.
-      ldr(xzr, MemOperand(csp, 0));
-    } else if (FLAG_enable_slow_asserts) {
+    // Always check the alignment of csp since it could have been bumped even if
+    // it is not the stack pointer. We can't check the alignment of csp without
+    // using a scratch register (or clobbering the flags), but the processor
+    // (or simulator) will abort if it is not properly aligned during a load.
+    ldr(xzr, MemOperand(csp, 0));
+    if (FLAG_enable_slow_asserts && !csp.Is(StackPointer())) {
       Label ok;
       // Check that csp <= StackPointer(), preserving all registers and NZCV.
       sub(StackPointer(), csp, StackPointer());
       cbz(StackPointer(), &ok);                 // Ok if csp == StackPointer().
       tbnz(StackPointer(), kXSignBit, &ok);     // Ok if csp < StackPointer().
 
       Abort(kTheCurrentStackPointerIsBelowCsp);
 
       bind(&ok);
       // Restore StackPointer().
@@ skipping 3996 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64