VM: Fix ARM64 assembler tests that assumed there was a stack red zone

runtime/vm/assembler_arm64_test.cc

 // Copyright (c) 2013, 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"
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/os.h"
 #include "vm/unit_test.h"
 #include "vm/virtual_memory.h"
 
 namespace dart {
 
 #define __ assembler->
 
+
+// Copies the stack pointer to our "SP", actually R15.  Also moves the real SP
+// down so that we can do push and pop in tests.  The Linux ABI does not seem
+// to have a red zone.
+static void SetUpStackFrame(Assembler* assembler) {
+  __ SetupDartSP();
+  __ EnterFrame(0);
+}
+
+
+static void TearDownStackFrame(Assembler* assembler) {
+  __ LeaveFrame();
+  __ RestoreCSP();
+}
+
+
 ASSEMBLER_TEST_GENERATE(Simple, assembler) {
   __ add(R0, ZR, Operand(ZR));
   __ add(R0, R0, Operand(42));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Simple, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
@@ skipping 353 matching lines @@
 
 
 ASSEMBLER_TEST_RUN(WordOverflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 // Loads and Stores.
 ASSEMBLER_TEST_GENERATE(SimpleLoadStore, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ movz(R0, Immediate(43), 0);
   __ movz(R1, Immediate(42), 0);
   __ str(R1, Address(SP, -1 * kWordSize, Address::PreIndex));
   __ ldr(R0, Address(SP, 1 * kWordSize, Address::PostIndex));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(SimpleLoadStore, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(SimpleLoadStoreHeapTag, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ movz(R0, Immediate(43), 0);
   __ movz(R1, Immediate(42), 0);
   __ add(R2, SP, Operand(1));
   __ str(R1, Address(R2, -1));
   __ ldr(R0, Address(R2, -1));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(SimpleLoadStoreHeapTag, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadStoreLargeIndex, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ movz(R0, Immediate(43), 0);
   __ movz(R1, Immediate(42), 0);
   // Largest negative offset that can fit in the signed 9-bit immediate field.
   __ str(R1, Address(SP, -32 * kWordSize, Address::PreIndex));
   // Largest positive kWordSize aligned offset that we can fit.
   __ ldr(R0, Address(SP, 31 * kWordSize, Address::PostIndex));
   // Correction.
   __ add(SP, SP, Operand(kWordSize));  // Restore SP.
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadStoreLargeIndex, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadStoreLargeOffset, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ movz(R0, Immediate(43), 0);
   __ movz(R1, Immediate(42), 0);
   __ sub(SP, SP, Operand(512 * kWordSize));
   __ str(R1, Address(SP, 512 * kWordSize, Address::Offset));
   __ add(SP, SP, Operand(512 * kWordSize));
   __ ldr(R0, Address(SP));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadStoreLargeOffset, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadStoreExtReg, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ movz(R0, Immediate(43), 0);
   __ movz(R1, Immediate(42), 0);
   __ movz(R2, Immediate(0xfff8), 0);
   __ movk(R2, Immediate(0xffff), 1);  // R2 <- -8 (int32_t).
   // This should sign extend R2, and add to SP to get address,
   // i.e. SP - kWordSize.
   __ str(R1, Address(SP, R2, SXTW));
   __ sub(SP, SP, Operand(kWordSize));
   __ ldr(R0, Address(SP));
   __ add(SP, SP, Operand(kWordSize));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadStoreExtReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadStoreScaledReg, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ movz(R0, Immediate(43), 0);
   __ movz(R1, Immediate(42), 0);
   __ movz(R2, Immediate(10), 0);
   __ sub(SP, SP, Operand(10 * kWordSize));
   // Store R1 into SP + R2 * kWordSize.
   __ str(R1, Address(SP, R2, UXTX, Address::Scaled));
   __ ldr(R0, Address(SP, R2, UXTX, Address::Scaled));
   __ add(SP, SP, Operand(10 * kWordSize));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadStoreScaledReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadSigned32Bit, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadImmediate(R1, 0xffffffff);
   __ str(R1, Address(SP, -4, Address::PreIndex, kWord), kWord);
   __ ldr(R0, Address(SP), kWord);
   __ ldr(R1, Address(SP, 4, Address::PostIndex, kWord), kWord);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadSigned32Bit, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(SimpleLoadStorePair, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadImmediate(R2, 43);
   __ LoadImmediate(R3, 42);
   __ stp(R2, R3, Address(SP, -2 * kWordSize, Address::PairPreIndex));
   __ ldp(R0, R1, Address(SP, 2 * kWordSize, Address::PairPostIndex));
   __ sub(R0, R0, Operand(R1));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(SimpleLoadStorePair, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadStorePairOffset, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadImmediate(R2, 43);
   __ LoadImmediate(R3, 42);
   __ sub(SP, SP, Operand(4 * kWordSize));
   __ stp(R2, R3, Address::Pair(SP, 2 * kWordSize));
   __ ldp(R0, R1, Address::Pair(SP, 2 * kWordSize));
   __ add(SP, SP, Operand(4 * kWordSize));
   __ sub(R0, R0, Operand(R1));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadStorePairOffset, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Semaphore, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ movz(R0, Immediate(40), 0);
   __ movz(R1, Immediate(42), 0);
   __ Push(R0);
   Label retry;
   __ Bind(&retry);
   __ ldxr(R0, SP);
   __ stxr(TMP, R1, SP);  // IP == 0, success
   __ cmp(TMP, Operand(0));
   __ b(&retry, NE);  // NE if context switch occurred between ldrex and strex.
   __ Pop(R0);        // 42
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Semaphore, test) {
   EXPECT(test != NULL);
   typedef intptr_t (*Semaphore)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Semaphore, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FailedSemaphore, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ movz(R0, Immediate(40), 0);
   __ movz(R1, Immediate(42), 0);
   __ Push(R0);
   __ ldxr(R0, SP);
   __ clrex();            // Simulate a context switch.
   __ stxr(TMP, R1, SP);  // IP == 1, failure
   __ Pop(R0);            // 40
   __ add(R0, R0, Operand(TMP));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FailedSemaphore, test) {
   EXPECT(test != NULL);
   typedef intptr_t (*FailedSemaphore)() DART_UNUSED;
   EXPECT_EQ(41, EXECUTE_TEST_CODE_INT64(FailedSemaphore, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Semaphore32, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
+  __ EnterFrame(0);
   __ movz(R0, Immediate(40), 0);
   __ add(R0, R0, Operand(R0, LSL, 32));
   __ Push(R0);
 
   __ movz(R0, Immediate(40), 0);
   __ movz(R1, Immediate(42), 0);
 
   Label retry;
   __ Bind(&retry);
   __ ldxr(R0, SP, kWord);
   // 32 bit operation should ignore the high word of R0 that was pushed on the
   // stack.
   __ stxr(TMP, R1, SP, kWord);  // IP == 0, success
   __ cmp(TMP, Operand(0));
   __ b(&retry, NE);  // NE if context switch occurred between ldrex and strex.
   __ Pop(R0);        // 42 + 42 * 2**32
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Semaphore32, test) {
   EXPECT(test != NULL);
   typedef intptr_t (*Semaphore32)() DART_UNUSED;
   // Lower word has been atomically switched from 40 to 42k, whereas upper word
   // is unchanged at 40.
   EXPECT_EQ(42 + (40l << 32),
             EXECUTE_TEST_CODE_INT64(Semaphore32, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FailedSemaphore32, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
+  __ EnterFrame(0);
   __ movz(R0, Immediate(40), 0);
   __ add(R0, R0, Operand(R0, LSL, 32));
   __ Push(R0);
 
   __ movz(R0, Immediate(40), 0);
   __ movz(R1, Immediate(42), 0);
 
   __ ldxr(R0, SP, kWord);
   __ clrex();                   // Simulate a context switch.
   __ stxr(TMP, R1, SP, kWord);  // IP == 1, failure
   __ Pop(R0);                   // 40
   __ add(R0, R0, Operand(TMP));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FailedSemaphore32, test) {
   EXPECT(test != NULL);
   typedef intptr_t (*FailedSemaphore32)() DART_UNUSED;
   // Lower word has had the failure code (1) added to it.  Upper word is
   // unchanged at 40.
   EXPECT_EQ(41 + (40l << 32),
@@ skipping 1249 matching lines @@
 static void LeaveTestFrame(Assembler* assembler) {
   __ PopAndUntagPP();
   __ Pop(THR);
   __ Pop(CODE_REG);
   __ LeaveFrame();
 }
 
 
 // Loading immediate values with the object pool.
 ASSEMBLER_TEST_GENERATE(LoadImmediatePPSmall, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   EnterTestFrame(assembler);
   __ LoadImmediate(R0, 42);
   LeaveTestFrame(assembler);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediatePPSmall, test) {
   EXPECT_EQ(42, test->InvokeWithCodeAndThread<int64_t>());
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediatePPMed, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   EnterTestFrame(assembler);
   __ LoadImmediate(R0, 0xf1234123);
   LeaveTestFrame(assembler);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediatePPMed, test) {
   EXPECT_EQ(0xf1234123, test->InvokeWithCodeAndThread<int64_t>());
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediatePPMed2, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   EnterTestFrame(assembler);
   __ LoadImmediate(R0, 0x4321f1234124);
   LeaveTestFrame(assembler);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediatePPMed2, test) {
   EXPECT_EQ(0x4321f1234124, test->InvokeWithCodeAndThread<int64_t>());
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadImmediatePPLarge, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   EnterTestFrame(assembler);
   __ LoadImmediate(R0, 0x9287436598237465);
   LeaveTestFrame(assembler);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediatePPLarge, test) {
   EXPECT_EQ(static_cast<int64_t>(0x9287436598237465),
             test->InvokeWithCodeAndThread<int64_t>());
 }
 
 
 // LoadObject null.
 ASSEMBLER_TEST_GENERATE(LoadObjectNull, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   EnterTestFrame(assembler);
   __ LoadObject(R0, Object::null_object());
   LeaveTestFrame(assembler);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadObjectNull, test) {
   EXPECT_EQ(Object::null(), test->InvokeWithCodeAndThread<RawObject*>());
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadObjectTrue, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   EnterTestFrame(assembler);
   __ LoadObject(R0, Bool::True());
   LeaveTestFrame(assembler);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadObjectTrue, test) {
   EXPECT_EQ(Bool::True().raw(), test->InvokeWithCodeAndThread<RawObject*>());
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadObjectFalse, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   EnterTestFrame(assembler);
   __ LoadObject(R0, Bool::False());
   LeaveTestFrame(assembler);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadObjectFalse, test) {
   EXPECT_EQ(Bool::False().raw(), test->InvokeWithCodeAndThread<RawObject*>());
 }
 
 
 ASSEMBLER_TEST_GENERATE(CSelTrue, assembler) {
@@ skipping 167 matching lines @@
 
 ASSEMBLER_TEST_RUN(Fmovsr, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   int64_t result = EXECUTE_TEST_CODE_INT64(Int64Return, test->entry());
   const uint32_t one = bit_cast<uint32_t, float>(1.0f);
   EXPECT_EQ(one, static_cast<uint32_t>(result));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdPrePostIndex, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V1, 42.0);
   __ fstrd(V1, Address(SP, -1 * kWordSize, Address::PreIndex));
   __ fldrd(V0, Address(SP, 1 * kWordSize, Address::PostIndex));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdPrePostIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrsFstrsPrePostIndex, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V1, 42.0);
   __ fcvtsd(V2, V1);
   __ fstrs(V2, Address(SP, -1 * kWordSize, Address::PreIndex));
   __ fldrs(V3, Address(SP, 1 * kWordSize, Address::PostIndex));
   __ fcvtds(V0, V3);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrsFstrsPrePostIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrqFstrqPrePostIndex, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V1, 21.0);
   __ LoadDImmediate(V2, 21.0);
   __ LoadImmediate(R1, 42);
   __ Push(R1);
   __ PushDouble(V1);
   __ PushDouble(V2);
   __ fldrq(V3, Address(SP, 2 * kWordSize, Address::PostIndex));
   __ Pop(R0);
   __ fstrq(V3, Address(SP, -2 * kWordSize, Address::PreIndex));
   __ PopDouble(V0);
   __ PopDouble(V1);
   __ faddd(V0, V0, V1);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrqFstrqPrePostIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
@@ skipping 152 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Fsubd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdHeapTag, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V0, 43.0);
   __ LoadDImmediate(V1, 42.0);
   __ AddImmediate(SP, SP, -1 * kWordSize);
   __ add(R2, SP, Operand(1));
   __ fstrd(V1, Address(R2, -1));
   __ fldrd(V0, Address(R2, -1));
   __ AddImmediate(SP, 1 * kWordSize);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdHeapTag, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdLargeIndex, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V0, 43.0);
   __ LoadDImmediate(V1, 42.0);
   // Largest negative offset that can fit in the signed 9-bit immediate field.
   __ fstrd(V1, Address(SP, -32 * kWordSize, Address::PreIndex));
   // Largest positive kWordSize aligned offset that we can fit.
   __ fldrd(V0, Address(SP, 31 * kWordSize, Address::PostIndex));
   // Correction.
   __ add(SP, SP, Operand(kWordSize));  // Restore SP.
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdLargeIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdLargeOffset, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V0, 43.0);
   __ LoadDImmediate(V1, 42.0);
   __ sub(SP, SP, Operand(512 * kWordSize));
   __ fstrd(V1, Address(SP, 512 * kWordSize, Address::Offset));
   __ add(SP, SP, Operand(512 * kWordSize));
   __ fldrd(V0, Address(SP));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdLargeOffset, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdExtReg, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V0, 43.0);
   __ LoadDImmediate(V1, 42.0);
   __ movz(R2, Immediate(0xfff8), 0);
   __ movk(R2, Immediate(0xffff), 1);  // R2 <- -8 (int32_t).
   // This should sign extend R2, and add to SP to get address,
   // i.e. SP - kWordSize.
   __ fstrd(V1, Address(SP, R2, SXTW));
   __ sub(SP, SP, Operand(kWordSize));
   __ fldrd(V0, Address(SP));
   __ add(SP, SP, Operand(kWordSize));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdExtReg, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdScaledReg, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V0, 43.0);
   __ LoadDImmediate(V1, 42.0);
   __ movz(R2, Immediate(10), 0);
   __ sub(SP, SP, Operand(10 * kWordSize));
   // Store V1 into SP + R2 * kWordSize.
   __ fstrd(V1, Address(SP, R2, UXTX, Address::Scaled));
   __ fldrd(V0, Address(SP, R2, UXTX, Address::Scaled));
   __ add(SP, SP, Operand(10 * kWordSize));
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(FldrdFstrdScaledReg, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
@@ skipping 434 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(Vdivd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(2.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vdupd, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V0, 21.0);
   __ vdupd(V1, V0, 0);
 
   const int dword_bytes = 1 << Log2OperandSizeBytes(kDWord);
   const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord);
   __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex));
 
   __ fldrd(V2, Address(SP, 1 * dword_bytes, Address::PostIndex));
   __ fldrd(V3, Address(SP, 1 * dword_bytes, Address::PostIndex));
 
   __ faddd(V0, V2, V3);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vdupd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vdups, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V0, 21.0);
   __ fcvtsd(V0, V0);
   __ vdups(V1, V0, 0);
 
   const int sword_bytes = 1 << Log2OperandSizeBytes(kSWord);
   const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord);
   __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex));
 
   __ fldrs(V3, Address(SP, 1 * sword_bytes, Address::PostIndex));
   __ fldrs(V2, Address(SP, 1 * sword_bytes, Address::PostIndex));
   __ fldrs(V1, Address(SP, 1 * sword_bytes, Address::PostIndex));
   __ fldrs(V0, Address(SP, 1 * sword_bytes, Address::PostIndex));
 
   __ fcvtds(V0, V0);
   __ fcvtds(V1, V1);
   __ fcvtds(V2, V2);
   __ fcvtds(V3, V3);
 
   __ faddd(V0, V1, V1);
   __ faddd(V0, V0, V2);
   __ faddd(V0, V0, V3);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vdups, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(84.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vinsd, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V5, 42.0);
   __ vinsd(V1, 1, V5, 0);  // V1[1] <- V0[0].
 
   const int dword_bytes = 1 << Log2OperandSizeBytes(kDWord);
   const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord);
   __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex));
 
   __ fldrd(V2, Address(SP, 1 * dword_bytes, Address::PostIndex));
   __ fldrd(V3, Address(SP, 1 * dword_bytes, Address::PostIndex));
 
   __ fmovdd(V0, V3);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vinsd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(Vinss, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ LoadDImmediate(V0, 21.0);
   __ fcvtsd(V0, V0);
   __ vinss(V1, 3, V0, 0);
   __ vinss(V1, 1, V0, 0);
 
   const int sword_bytes = 1 << Log2OperandSizeBytes(kSWord);
   const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord);
   __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex));
 
   __ fldrs(V3, Address(SP, 1 * sword_bytes, Address::PostIndex));
   __ fldrs(V2, Address(SP, 1 * sword_bytes, Address::PostIndex));
   __ fldrs(V1, Address(SP, 1 * sword_bytes, Address::PostIndex));
   __ fldrs(V0, Address(SP, 1 * sword_bytes, Address::PostIndex));
 
   __ fcvtds(V0, V0);
   __ fcvtds(V1, V1);
   __ fcvtds(V2, V2);
   __ fcvtds(V3, V3);
 
   __ faddd(V0, V0, V1);
   __ faddd(V0, V0, V2);
   __ faddd(V0, V0, V3);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Vinss, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
 }
 
 
@@ skipping 775 matching lines @@
   EXPECT_FLOAT_EQ(1.0 / sqrt(147000.0), res, 0.0001);
 }
 
 
 // Called from assembler_test.cc.
 // LR: return address.
 // R0: value.
 // R1: growable array.
 // R2: current thread.
 ASSEMBLER_TEST_GENERATE(StoreIntoObject, assembler) {
-  __ SetupDartSP();
+  SetUpStackFrame(assembler);
   __ Push(CODE_REG);
   __ Push(THR);
   __ Push(LR);
   __ mov(THR, R2);
   __ StoreIntoObject(R1, FieldAddress(R1, GrowableObjectArray::data_offset()),
                      R0);
   __ Pop(LR);
   __ Pop(THR);
   __ Pop(CODE_REG);
-  __ RestoreCSP();
+  TearDownStackFrame(assembler);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined(TARGET_ARCH_ARM64)