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

src/arm64/macro-assembler-arm64.h

 // 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.
 
 #ifndef V8_ARM64_MACRO_ASSEMBLER_ARM64_H_
 #define V8_ARM64_MACRO_ASSEMBLER_ARM64_H_
 
 #include <vector>
 
 #include "v8globals.h"
@@ skipping 700 matching lines @@
   // it will be encoded in the event marker.
   inline void AnnotateInstrumentation(const char* marker_name);
 
   // If emit_debug_code() is true, emit a run-time check to ensure that
   // StackPointer() does not point below the system stack pointer.
   //
   // Whilst it is architecturally legal for StackPointer() to point below csp,
   // it can be evidence of a potential bug because the ABI forbids accesses
   // below csp.
   //
+  // If StackPointer() is the system stack pointer (csp), or csp_was_modified is
+  // true and ALWAYS_ALIGN_CSP is enabled, then csp will be dereferenced to
+  // cause the processor (or simulator) to abort if it is not properly aligned.
+  //
   // If emit_debug_code() is false, this emits no code.
-  //
-  // If StackPointer() is the system stack pointer, this emits no code.
-  void AssertStackConsistency();
+  void AssertStackConsistency(bool csp_was_modified);

[ulan, 2014/05/08 08:18:43]

Nit: we usually pass flags as enums with descriptive names, that improves
readability at call-sites.

 
   // Preserve the callee-saved registers (as defined by AAPCS64).
   //
   // Higher-numbered registers are pushed before lower-numbered registers, and
   // thus get higher addresses.
   // Floating-point registers are pushed before general-purpose registers, and
   // thus get higher addresses.
   //
   // Note that registers are not checked for invalid values. Use this method
   // only if you know that the GC won't try to examine the values on the stack.
@@ skipping 36 matching lines @@
     Bic(csp, StackPointer(), sp_alignment - 1);
     SetStackPointer(csp);
   }
 
   // Push the system stack pointer (csp) down to allow the same to be done to
   // the current stack pointer (according to StackPointer()). This must be
   // called _before_ accessing the memory.
   //
   // This is necessary when pushing or otherwise adding things to the stack, to
   // satisfy the AAPCS64 constraint that the memory below the system stack
-  // pointer is not accessed.
+  // pointer is not accessed.  The amount pushed will be increased as necessary
+  // to ensure csp remains aligned to 16 bytes.
   //
   // This method asserts that StackPointer() is not csp, since the call does
   // not make sense in that context.
   inline void BumpSystemStackPointer(const Operand& space);
 
+  // Re-synchronizes the system stack pointer (csp) with the current stack
+  // pointer (according to StackPointer()).  This function will ensure the
+  // new value of the system stack pointer is remains aligned to 16 bytes, and
+  // is lower than or equal to the value of the current stack pointer.
+  //
+  // This method asserts that StackPointer() is not csp, since the call does
+  // not make sense in that context.
+  inline void SyncSystemStackPointer();
+
   // Helpers ------------------------------------------------------------------
   // Root register.
   inline void InitializeRootRegister();
 
   void AssertFPCRState(Register fpcr = NoReg);
   void ConfigureFPCR();
   void CanonicalizeNaN(const FPRegister& dst, const FPRegister& src);
   void CanonicalizeNaN(const FPRegister& reg) {
     CanonicalizeNaN(reg, reg);
   }
@@ skipping 1216 matching lines @@
   // block of registers.
   //
   // Note that size is per register, and is specified in bytes.
   void PushHelper(int count, int size,
                   const CPURegister& src0, const CPURegister& src1,
                   const CPURegister& src2, const CPURegister& src3);
   void PopHelper(int count, int size,
                  const CPURegister& dst0, const CPURegister& dst1,
                  const CPURegister& dst2, const CPURegister& dst3);
 
-  // Perform necessary maintenance operations before a push or pop.
+  // Perform necessary maintenance operations before a push or after a pop.
   //
   // Note that size is specified in bytes.
-  void PrepareForPush(Operand total_size);
-  void PrepareForPop(Operand total_size);
+  void PushPreamble(Operand total_size);
+  void PopPostamble(Operand total_size);
 
-  void PrepareForPush(int count, int size) { PrepareForPush(count * size); }
-  void PrepareForPop(int count, int size) { PrepareForPop(count * size); }
+  void PushPreamble(int count, int size) { PushPreamble(count * size); }
+  void PopPostamble(int count, int size) { PopPostamble(count * size); }
 
   // Call Printf. On a native build, a simple call will be generated, but if the
   // simulator is being used then a suitable pseudo-instruction is used. The
   // arguments and stack (csp) must be prepared by the caller as for a normal
   // AAPCS64 call to 'printf'.
   //
   // The 'type' argument specifies the type of the optional arguments.
   void CallPrintf(CPURegister::RegisterType type = CPURegister::kNoRegister);
 
   // Helper for throwing exceptions.  Compute a handler address and jump to
@@ skipping 243 matching lines @@
 #error "Unsupported option"
 #define CODE_COVERAGE_STRINGIFY(x) #x
 #define CODE_COVERAGE_TOSTRING(x) CODE_COVERAGE_STRINGIFY(x)
 #define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__)
 #define ACCESS_MASM(masm) masm->stop(__FILE_LINE__); masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 #endif  // V8_ARM64_MACRO_ASSEMBLER_ARM64_H_