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

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 106 matching lines @@
       LogicalImmediate(rd, rn, n, imm_s, imm_r, op);
     } else {
       // Immediate can't be encoded: synthesize using move immediate.
       Register temp = temps.AcquireSameSizeAs(rn);
       Mov(temp, immediate);
       if (rd.Is(csp)) {
         // If rd is the stack pointer we cannot use it as the destination
         // register so we use the temp register as an intermediate again.
         Logical(temp, rn, temp, op);
         Mov(csp, temp);
-        AssertStackConsistency();
       } else {
         Logical(rd, rn, temp, op);
       }
     }
 
   } else if (operand.IsExtendedRegister()) {
     ASSERT(operand.reg().SizeInBits() <= rd.SizeInBits());
     // Add/sub extended supports shift <= 4. We want to support exactly the
     // same modes here.
     ASSERT(operand.shift_amount() <= 4);
@@ skipping 87 matching lines @@
           movk(temp, imm16, 16 * i);
         }
       }
     }
     ASSERT(first_mov_done);
 
     // Move the temporary if the original destination register was the stack
     // pointer.
     if (rd.IsSP()) {
       mov(rd, temp);
-      AssertStackConsistency();
     }
   }
 }
 
 
 void MacroAssembler::Mov(const Register& rd,
                          const Operand& operand,
                          DiscardMoveMode discard_mode) {
   ASSERT(allow_macro_instructions_);
   ASSERT(!rd.IsZero());
@@ skipping 516 matching lines @@
 // Abstracted stack operations.
 
 
 void MacroAssembler::Push(const CPURegister& src0, const CPURegister& src1,
                           const CPURegister& src2, const CPURegister& src3) {
   ASSERT(AreSameSizeAndType(src0, src1, src2, src3));
 
   int count = 1 + src1.IsValid() + src2.IsValid() + src3.IsValid();
   int size = src0.SizeInBytes();
 
-  PushPreamble(count, size);
+  PrepareForPush(count, size);
   PushHelper(count, size, src0, src1, src2, src3);
 }
 
 
 void MacroAssembler::Push(const CPURegister& src0, const CPURegister& src1,
                           const CPURegister& src2, const CPURegister& src3,
                           const CPURegister& src4, const CPURegister& src5,
                           const CPURegister& src6, const CPURegister& src7) {
   ASSERT(AreSameSizeAndType(src0, src1, src2, src3, src4, src5, src6, src7));
 
   int count = 5 + src5.IsValid() + src6.IsValid() + src6.IsValid();
   int size = src0.SizeInBytes();
 
-  PushPreamble(count, size);
+  PrepareForPush(count, size);
   PushHelper(4, size, src0, src1, src2, src3);
   PushHelper(count - 4, size, src4, src5, src6, src7);
 }
 
 
 void MacroAssembler::Pop(const CPURegister& dst0, const CPURegister& dst1,
                          const CPURegister& dst2, const CPURegister& dst3) {
   // It is not valid to pop into the same register more than once in one
   // 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);
-  PopPostamble(count, size);
+
+  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::PushPopQueue::PushQueued() {
   if (queued_.empty()) return;
 
-  masm_->PushPreamble(size_);
+  masm_->PrepareForPush(size_);
 
   int count = queued_.size();
   int index = 0;
   while (index < count) {
     // PushHelper can only handle registers with the same size and type, and it
     // can handle only four at a time. Batch them up accordingly.
     CPURegister batch[4] = {NoReg, NoReg, NoReg, NoReg};
     int batch_index = 0;
     do {
       batch[batch_index++] = queued_[index++];
     } while ((batch_index < 4) && (index < count) &&
              batch[0].IsSameSizeAndType(queued_[index]));
 
     masm_->PushHelper(batch_index, batch[0].SizeInBytes(),
                       batch[0], batch[1], batch[2], batch[3]);
   }
 
   queued_.clear();
 }
 
 
 void MacroAssembler::PushPopQueue::PopQueued() {
   if (queued_.empty()) return;
 
+  masm_->PrepareForPop(size_);
+
   int count = queued_.size();
   int index = 0;
   while (index < count) {
     // PopHelper can only handle registers with the same size and type, and it
     // can handle only four at a time. Batch them up accordingly.
     CPURegister batch[4] = {NoReg, NoReg, NoReg, NoReg};
     int batch_index = 0;
     do {
       batch[batch_index++] = queued_[index++];
     } while ((batch_index < 4) && (index < count) &&
              batch[0].IsSameSizeAndType(queued_[index]));
 
     masm_->PopHelper(batch_index, batch[0].SizeInBytes(),
                      batch[0], batch[1], batch[2], batch[3]);
   }
 
-  masm_->PopPostamble(size_);
   queued_.clear();
 }
 
 
 void MacroAssembler::PushCPURegList(CPURegList registers) {
   int size = registers.RegisterSizeInBytes();
 
-  PushPreamble(registers.Count(), size);
+  PrepareForPush(registers.Count(), size);
   // Push up to four registers at a time because if the current stack pointer is
   // csp and reg_size is 32, registers must be pushed in blocks of four in order
   // to maintain the 16-byte alignment for csp.
   while (!registers.IsEmpty()) {
     int count_before = registers.Count();
     const CPURegister& src0 = registers.PopHighestIndex();
     const CPURegister& src1 = registers.PopHighestIndex();
     const CPURegister& src2 = registers.PopHighestIndex();
     const CPURegister& src3 = registers.PopHighestIndex();
     int count = count_before - registers.Count();
     PushHelper(count, size, src0, src1, src2, src3);
   }
 }
 
 
 void MacroAssembler::PopCPURegList(CPURegList registers) {
   int size = registers.RegisterSizeInBytes();
 
+  PrepareForPop(registers.Count(), size);
   // Pop up to four registers at a time because if the current stack pointer is
   // csp and reg_size is 32, registers must be pushed in blocks of four in
   // 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);
   }
-  PopPostamble(registers.Count(), size);
+
+  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();
 
-  PushPreamble(count, size);
+  PrepareForPush(count, size);
 
   if (FLAG_optimize_for_size && count > 8) {
     UseScratchRegisterScope temps(this);
     Register temp = temps.AcquireX();
 
     Label loop;
     __ Mov(temp, count / 2);
     __ Bind(&loop);
     PushHelper(2, size, src, src, NoReg, NoReg);
     __ Subs(temp, temp, 1);
@@ skipping 15 matching lines @@
   }
   if (count == 1) {
     PushHelper(1, size, src, NoReg, NoReg, NoReg);
     count -= 1;
   }
   ASSERT(count == 0);
 }
 
 
 void MacroAssembler::PushMultipleTimes(CPURegister src, Register count) {
-  PushPreamble(Operand(count, UXTW, WhichPowerOf2(src.SizeInBytes())));
+  PrepareForPush(Operand(count, UXTW, WhichPowerOf2(src.SizeInBytes())));
 
   UseScratchRegisterScope temps(this);
   Register temp = temps.AcquireSameSizeAs(count);
 
   if (FLAG_optimize_for_size) {
     Label loop, done;
 
     Subs(temp, count, 1);
     B(mi, &done);
 
@@ skipping 105 matching lines @@
       // for csp at all times.
       ldp(dst2, dst3, MemOperand(StackPointer(), 2 * size));
       ldp(dst0, dst1, MemOperand(StackPointer(), 4 * size, PostIndex));
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
-void MacroAssembler::PushPreamble(Operand total_size) {
+void MacroAssembler::PrepareForPush(Operand total_size) {
   // TODO(jbramley): This assertion generates too much code in some debug tests.
   // AssertStackConsistency();
   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 {
     // Even if the current stack pointer is not the system stack pointer (csp),
     // the system stack pointer will still be modified in order to comply with
     // ABI rules about accessing memory below the system stack pointer.
     BumpSystemStackPointer(total_size);
   }
 }
 
 
-void MacroAssembler::PopPostamble(Operand total_size) {
+void MacroAssembler::PrepareForPop(Operand total_size) {
   AssertStackConsistency();
   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()) || CpuFeatures::IsSupported(ALWAYS_ALIGN_CSP)) {
-      // Always check the alignment of csp if ALWAYS_ALIGN_CSP is true, 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.
+    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 && !csp.Is(StackPointer())) {
+    } else if (FLAG_enable_slow_asserts) {
       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 4016 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64