AArch64: support compact unwind with swifterror parameters.

[t.p.northover]

Summary

Swifterror parameters are essentially "inout" ones that are passed in x21. Because they're also returned they can't be restored in the epilogue and so must be removed from the callee-saved register list. Unfortunately this leads to a frame layout that compact unwind can't describe (it assumes that if x20 is saved then x21 always will be too).

This patch sort of adds it back into the CSR list, but in epilogues we discard the value by loading xzr instead of x21, which makes the frames look normal again as far as an unwinder is concerned (swifterror isn't live along the unwind path anyway so restoring it there is harmless). The regmask is intentionally left as-is (i.e. with x21 removed).

[t.p.northover]

Ping.

[t.p.northover]

Ping.

llvm/lib/Target/AArch64/AArch64FrameLowering.cpp

static unsigned getPrologueDeath(MachineFunction &MF, unsigned Reg) {
   // Omitting the kill flags is conservatively correct even if the live-in
   // is not used after all.
   bool IsLiveIn = MF.getRegInfo().isLiveIn(Reg);
   return getKillRegState(!IsLiveIn);
 }
 
 static bool produceCompactUnwindFrame(MachineFunction &MF) {
   const AArch64Subtarget &Subtarget = MF.getSubtarget<AArch64Subtarget>();
-  AttributeList Attrs = MF.getFunction().getAttributes();
   return Subtarget.isTargetMachO() &&
-         !(Subtarget.getTargetLowering()->supportSwiftError() &&
-           Attrs.hasAttrSomewhere(Attribute::SwiftError)) &&
          MF.getFunction().getCallingConv() != CallingConv::SwiftTail;
 }
 
 static bool invalidateWindowsRegisterPairing(unsigned Reg1, unsigned Reg2,
                                              bool NeedsWinCFI, bool IsFirst,
                                              const TargetRegisterInfo *TRI) {
   // If we are generating register pairs for a Windows function that requires
   // EH support, then pair consecutive registers only.  There are no unwind
bool AArch64FrameLowering::restoreCalleeSavedRegisters(
   SmallVector<RegPairInfo, 8> RegPairs;
   bool NeedsWinCFI = needsWinCFI(MF);
 
   if (MBBI != MBB.end())
     DL = MBBI->getDebugLoc();
 
   computeCalleeSaveRegisterPairs(MF, CSI, TRI, RegPairs, hasFP(MF));
 
+  AttributeList Attrs = MF.getFunction().getAttributes();
   auto EmitMI = [&](const RegPairInfo &RPI) -> MachineBasicBlock::iterator {
     unsigned Reg1 = RPI.Reg1;
     unsigned Reg2 = RPI.Reg2;
 
+    if (MF.getSubtarget().getTargetLowering()->supportSwiftError() &&
+        Attrs.hasAttrSomewhere(Attribute::SwiftError) && Reg1 == AArch64::X21)
+      Reg1 = AArch64::XZR;
+
     // Issue sequence of restores for cs regs. The last restore may be converted
     // to a post-increment load later by emitEpilogue if the callee-save stack
     // area allocation can't be combined with the local stack area allocation.
     // For example:
     //    ldp     fp, lr, [sp, #32]       // addImm(+4)
     //    ldp     x20, x19, [sp, #16]     // addImm(+2)
     //    ldp     x22, x21, [sp, #0]      // addImm(+0)
     // Note: see comment in spillCalleeSavedRegisters()

llvm/lib/Target/AArch64/AArch64RegisterInfo.cpp

if (MF->getFunction().getCallingConv() ==
     report_fatal_error(
         "Calling convention AArch64_SME_ABI_Support_Routines_PreserveMost_From_X2 is "
         "only supported to improve calls to SME ACLE __arm_sme_state "
         "and is not intended to be used beyond that scope.");
   if (MF->getFunction().getCallingConv() == CallingConv::CXX_FAST_TLS)
     return MF->getInfo<AArch64FunctionInfo>()->isSplitCSR()
                ? CSR_Darwin_AArch64_CXX_TLS_PE_SaveList
                : CSR_Darwin_AArch64_CXX_TLS_SaveList;
-  if (MF->getSubtarget<AArch64Subtarget>().getTargetLowering()
-          ->supportSwiftError() &&
-      MF->getFunction().getAttributes().hasAttrSomewhere(
-          Attribute::SwiftError))
-    return CSR_Darwin_AArch64_AAPCS_SwiftError_SaveList;
   if (MF->getFunction().getCallingConv() == CallingConv::SwiftTail)
     return CSR_Darwin_AArch64_AAPCS_SwiftTail_SaveList;
   if (MF->getFunction().getCallingConv() == CallingConv::PreserveMost)
     return CSR_Darwin_AArch64_RT_MostRegs_SaveList;
   if (MF->getFunction().getCallingConv() == CallingConv::Win64)
     return CSR_Darwin_AArch64_AAPCS_Win64_SaveList;
   return CSR_Darwin_AArch64_AAPCS_SaveList;
 }

llvm/test/CodeGen/AArch64/GlobalISel/swifterror.ll

 ; RUN: llc -verify-machineinstrs -frame-pointer=all -global-isel < %s -mtriple=aarch64-apple-ios | FileCheck %s
+; RUN: llc -mtriple=arm64-apple-macosx %s -frame-pointer=all  -o - -filetype=obj -global-isel | llvm-objdump --unwind-info - | FileCheck %s --check-prefix=CHECK-COMPACT-UNWIND
+
+; Make sure all functions get real compact unwind not DWARF fallback
+; CHECK-COMPACT-UNWIND-NOT: 0x03000000
 
 declare ptr @malloc(i64)
 declare void @free(ptr)
 %swift_error = type {i64, i8}
 
 ; This tests the basic usage of a swifterror parameter. "foo" is the function
 ; that takes a swifterror parameter and "caller" is the caller of "foo".
 define float @foo(ptr swifterror %error_ptr_ref) {

 ; "foo_vararg" is a function that takes a swifterror parameter, it also has
 ; variable number of arguments.
 declare void @llvm.va_start(ptr) nounwind
 define float @foo_vararg(ptr swifterror %error_ptr_ref, ...) {
 ; CHECK-LABEL: foo_vararg:
 ; CHECK: mov w0, #16
 ; CHECK: malloc
 ; CHECK: mov [[ID:w[0-9]+]], #1
-; CHECK: mov x21, x0
-; CHECK-NOT: x21
 ; CHECK: strb [[ID]], [x0, #8]
 ; CHECK-NOT: x21
+; CHECK: mov x21, x0
+; CHECK-NOT: x21
 
 ; First vararg
 ; CHECK: ldr {{w[0-9]+}}, [x[[ARG1:[0-9]+]]]
 ; CHECK-NOT: x21
 ; Second vararg
 ; CHECK: ldr {{w[0-9]+}}, [x[[ARG1]]]
 ; CHECK-NOT: x21
 ; Third vararg

 define swiftcc float @tailcallswifterror_swiftcc(ptr swifterror %error_ptr_ref) {
 entry:
   %0 = tail call swiftcc float @tailcallswifterror_swiftcc(ptr swifterror %error_ptr_ref)
   ret float %0
 }
 
 ; CHECK-LABEL: params_in_reg
 ; Save callee saved registers and swifterror since it will be clobbered by the first call to params_in_reg2.
-; CHECK:  str     x28, [sp
-; CHECK:  stp     x27, x26, [sp
-; CHECK:  stp     x25, x24, [sp
-; CHECK:  stp     x23, x22, [sp
+; CHECK:  stp     x28, x27, [sp
+; CHECK:  stp     x26, x25, [sp
+; CHECK:  stp     x24, x23, [sp
+; CHECK:  stp     x22, x21, [sp
 ; CHECK:  stp     x20, x19, [sp
 ; CHECK:  stp     x29, x30, [sp
 ; Store argument registers.
 ; CHECK:  mov      x20, x1
 ; CHECK:  mov      x22, x2
 ; CHECK:  mov      x23, x3
 ; CHECK:  mov      x24, x4
 ; CHECK:  mov      x25, x5
 ; CHECK:  mov      x26, x6
 ; CHECK:  mov      x27, x7
 ; CHECK:  mov      x28, x21
 ; Setup call.
 ; CHECK:  mov     w0, #1
 ; CHECK:  mov     w1, #2
 ; CHECK:  mov     w2, #3
 ; CHECK:  mov     w3, #4
 ; CHECK:  mov     w4, #5
 ; CHECK:  mov     w5, #6
 ; CHECK:  mov     w6, #7
 ; CHECK:  mov     w7, #8
 ; CHECK:  mov      x21, xzr
-; CHECK:  str     xzr, [sp]
+; CHECK:  stp     xzr, x8, [sp]
 ; CHECK:  bl      _params_in_reg2
 ; Restore original arguments for next call.
 ; CHECK:  mov      x1, x20
 ; CHECK:  mov      x2, x22
 ; CHECK:  mov      x3, x23
 ; CHECK:  mov      x4, x24
 ; CHECK:  mov      x5, x25
 ; CHECK:  mov      x6, x26
 ; CHECK:  mov      x7, x27
 ; Restore original swiftself argument and swifterror %err.
 ; CHECK:  mov      x21, x28
 ; CHECK:  ldr      x8, [sp
 ; CHECK:  bl      _params_in_reg2
 ; Restore calle save registers but don't clober swifterror x21.
-; CHECK-NOT: x21
 ; CHECK:  ldp     x29, x30, [sp
-; CHECK-NOT: x21
 ; CHECK:  ldp     x20, x19, [sp
-; CHECK-NOT: x21
-; CHECK:  ldp     x23, x22, [sp
-; CHECK-NOT: x21
-; CHECK:  ldp     x25, x24, [sp
-; CHECK-NOT: x21
-; CHECK:  ldp     x27, x26, [sp
-; CHECK-NOT: x21
-; CHECK:  ldr     x28, [sp
-; CHECK-NOT: x21
+; CHECK:  ldp     x22, xzr, [sp
+; CHECK:  ldp     x24, x23, [sp
+; CHECK:  ldp     x26, x25, [sp
+; CHECK:  ldp     x28, x27, [sp
 ; CHECK:  ret
 define swiftcc void @params_in_reg(i64, i64, i64, i64, i64, i64, i64, i64, ptr, ptr nocapture swifterror %err) {
   %error_ptr_ref = alloca swifterror ptr, align 8
   store ptr null, ptr %error_ptr_ref
   call swiftcc void @params_in_reg2(i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, ptr  null, ptr nocapture swifterror %error_ptr_ref)
   call swiftcc void @params_in_reg2(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7, ptr  %8, ptr nocapture swifterror %err)
   ret void
 }
 declare swiftcc void @params_in_reg2(i64, i64, i64, i64, i64, i64, i64, i64, ptr , ptr nocapture swifterror %err)
 
 ; CHECK-LABEL: params_and_return_in_reg
 ; Store callee saved registers.
-; CHECK:  stp     x28, x21, [sp, #16
-; CHECK:  stp     x27, x26, [sp
-; CHECK:  stp     x25, x24, [sp
-; CHECK:  stp     x23, x22, [sp
+; CHECK:  stp     x28, x27, [sp, #32
+; CHECK:  stp     x26, x25, [sp
+; CHECK:  stp     x24, x23, [sp
+; CHECK:  stp     x22, x21, [sp
 ; CHECK:  stp     x20, x19, [sp
 ; CHECK:  stp     x29, x30, [sp
 ; Save original arguments.
 ; CHECK:  mov      x20, x1
 ; CHECK:  mov      x22, x2
 ; CHECK:  mov      x23, x3
 ; CHECK:  mov      x24, x4
 ; CHECK:  mov      x25, x5
 ; CHECK:  mov      x26, x6
 ; CHECK:  mov      x27, x7
 ; Setup call arguments.
 ; CHECK:  mov     w0, #1
 ; CHECK:  mov     w1, #2
 ; CHECK:  mov     w2, #3
 ; CHECK:  mov     w3, #4
 ; CHECK:  mov     w4, #5
 ; CHECK:  mov     w5, #6
 ; CHECK:  mov     w6, #7
 ; CHECK:  mov     w7, #8
 ; CHECK:  mov      x21, xzr
 ; CHECK:  bl      _params_in_reg2
 ; Store swifterror %error_ptr_ref.
-; CHECK:  stp     {{x[0-9]+}}, x21, [sp]
+; CHECK:  str      x21, [sp, #16]
 ; Setup call arguments from original arguments.
 ; CHECK:  mov      x0, x19
 ; CHECK:  mov      x1, x20
 ; CHECK:  mov      x2, x22
 ; CHECK:  mov      x3, x23
 ; CHECK:  mov      x4, x24
 ; CHECK:  mov      x5, x25
 ; CHECK:  mov      x6, x26

 ; CHECK:  mov     w1, #2
 ; CHECK:  mov     w2, #3
 ; CHECK:  mov     w3, #4
 ; CHECK:  mov     w4, #5
 ; CHECK:  mov     w5, #6
 ; CHECK:  mov     w6, #7
 ; CHECK:  mov     w7, #8
 ; ... setup call with swiferror %error_ptr_ref.
-; CHECK:  ldr     x21, [sp, #8]
+; CHECK:  ldr     x21, [sp, #16]
 ; CHECK:  bl      _params_in_reg2
 ; Restore return values for return from this function.
 ; CHECK:  mov      x0, x19
 ; CHECK:  mov      x1, x20
 ; CHECK:  mov      x2, x22
 ; CHECK:  mov      x3, x23
 ; CHECK:  mov      x4, x24
 ; CHECK:  mov      x5, x25
 ; CHECK:  mov      x6, x26
 ; CHECK:  mov      x7, x27
-; CHECK:  ldp     x29, x30, [sp
 ; CHECK:  mov      x21, x28
+; CHECK:  ldp     x29, x30, [sp
 ; Restore callee save registers.
 ; CHECK:  ldp     x20, x19, [sp
-; CHECK:  ldp     x23, x22, [sp
-; CHECK:  ldp     x25, x24, [sp
-; CHECK:  ldp     x27, x26, [sp
-; CHECK:  ldr     x28, [sp
+; CHECK:  ldp     x22, xzr, [sp
+; CHECK:  ldp     x24, x23, [sp
+; CHECK:  ldp     x26, x25, [sp
+; CHECK:  ldp     x28, x27, [sp
 ; CHECK:  ret
 define swiftcc { i64, i64, i64, i64, i64, i64, i64, i64 } @params_and_return_in_reg(i64, i64, i64, i64, i64, i64, i64, i64, ptr , ptr nocapture swifterror %err) {
   %error_ptr_ref = alloca swifterror ptr, align 8
   store ptr null, ptr %error_ptr_ref
   call swiftcc void @params_in_reg2(i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, ptr  null, ptr nocapture swifterror %error_ptr_ref)
   %val = call swiftcc  { i64, i64, i64, i64, i64, i64, i64, i64 } @params_and_return_in_reg2(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7, ptr  %8, ptr nocapture swifterror %err)
   call swiftcc void @params_in_reg2(i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, ptr  null, ptr nocapture swifterror %error_ptr_ref)
   ret { i64, i64, i64, i64, i64, i64, i64, i64 } %val

llvm/test/CodeGen/AArch64/swifterror.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -verify-machineinstrs -frame-pointer=all -enable-shrink-wrap=false < %s -mtriple=aarch64-apple-ios -disable-post-ra | FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-APPLE --check-prefix=CHECK-APPLE-AARCH64 %s
 ; RUN: llc -verify-machineinstrs -frame-pointer=all -O0 -fast-isel < %s -mtriple=aarch64-apple-ios -disable-post-ra | FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-O0-AARCH64 %s
 ; RUN: llc -verify-machineinstrs -frame-pointer=all -enable-shrink-wrap=false < %s -mtriple=arm64_32-apple-ios -disable-post-ra | FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-APPLE --check-prefix=CHECK-APPLE-ARM64_32 %s
 ; RUN: llc -verify-machineinstrs -O0 -fast-isel < %s -mtriple=arm64_32-apple-ios -disable-post-ra | FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK-O0-ARM64_32 %s
 
 declare ptr @malloc(i64)
 declare void @free(ptr)
 %swift_error = type {i64, i8}
 
 ; This tests the basic usage of a swifterror parameter. "foo" is the function
 ; that takes a swifterror parameter and "caller" is the caller of "foo".
 define float @foo(ptr swifterror %error_ptr_ref) {
 ; CHECK-APPLE-LABEL: foo:
 ; CHECK-APPLE:       ; %bb.0: ; %entry
-; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-APPLE-NEXT:    mov x29, sp
+; CHECK-APPLE-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    add x29, sp, #16
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-NEXT:    .cfi_offset w29, -16
+; CHECK-APPLE-NEXT:    .cfi_offset w21, -24
+; CHECK-APPLE-NEXT:    .cfi_offset w22, -32
 ; CHECK-APPLE-NEXT:    mov w0, #16
 ; CHECK-APPLE-NEXT:    bl _malloc
 ; CHECK-APPLE-NEXT:    mov w8, #1
 ; CHECK-APPLE-NEXT:    fmov s0, #1.00000000
 ; CHECK-APPLE-NEXT:    mov x21, x0
 ; CHECK-APPLE-NEXT:    strb w8, [x0, #8]
-; CHECK-APPLE-NEXT:    ldp x29, x30, [sp], #16 ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: foo:
 ; CHECK-O0-AARCH64:       ; %bb.0: ; %entry
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-O0-AARCH64-NEXT:    mov x29, sp
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #16
 ; CHECK-O0-AARCH64-NEXT:    mov w0, w8
 ; CHECK-O0-AARCH64-NEXT:    bl _malloc
 ; CHECK-O0-AARCH64-NEXT:    mov x21, x0
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #1
 ; CHECK-O0-AARCH64-NEXT:    strb w8, [x0, #8]
 ; CHECK-O0-AARCH64-NEXT:    fmov s0, #1.00000000
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp], #16 ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: foo:
 ; CHECK-O0-ARM64_32:       ; %bb.0: ; %entry
-; CHECK-O0-ARM64_32-NEXT:    str x30, [sp, #-16]! ; 8-byte Folded Spill
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -16
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-O0-ARM64_32-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -8
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-ARM64_32-NEXT:    mov w8, #16
 ; CHECK-O0-ARM64_32-NEXT:    mov w0, w8
 ; CHECK-O0-ARM64_32-NEXT:    bl _malloc
 ; CHECK-O0-ARM64_32-NEXT:    mov x21, x0
 ; CHECK-O0-ARM64_32-NEXT:    mov w8, #1
 ; CHECK-O0-ARM64_32-NEXT:    strb w8, [x0, #8]
 ; CHECK-O0-ARM64_32-NEXT:    fmov s0, #1.00000000
-; CHECK-O0-ARM64_32-NEXT:    ldr x30, [sp], #16 ; 8-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ret
 
 entry:
   %call = call ptr @malloc(i64 16)
   store ptr %call, ptr %error_ptr_ref
   %tmp = getelementptr inbounds i8, ptr %call, i64 8
   store i8 1, ptr %tmp
   ret float 1.0
handler:
   ret float 1.0
 }
 
 ; "foo_if" is a function that takes a swifterror parameter, it sets swifterror
 ; under a certain condition.
 define float @foo_if(ptr swifterror %error_ptr_ref, i32 %cc) {
 ; CHECK-APPLE-LABEL: foo_if:
 ; CHECK-APPLE:       ; %bb.0: ; %entry
-; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-APPLE-NEXT:    mov x29, sp
+; CHECK-APPLE-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    add x29, sp, #16
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-NEXT:    .cfi_offset w29, -16
+; CHECK-APPLE-NEXT:    .cfi_offset w21, -24
+; CHECK-APPLE-NEXT:    .cfi_offset w22, -32
 ; CHECK-APPLE-NEXT:    cbz w0, LBB3_2
 ; CHECK-APPLE-NEXT:  ; %bb.1: ; %gen_error
 ; CHECK-APPLE-NEXT:    mov w0, #16
 ; CHECK-APPLE-NEXT:    bl _malloc
 ; CHECK-APPLE-NEXT:    mov x21, x0
 ; CHECK-APPLE-NEXT:    mov w8, #1
 ; CHECK-APPLE-NEXT:    fmov s0, #1.00000000
 ; CHECK-APPLE-NEXT:    strb w8, [x0, #8]
-; CHECK-APPLE-NEXT:    ldp x29, x30, [sp], #16 ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ret
+; CHECK-APPLE-NEXT:    b LBB3_3
 ; CHECK-APPLE-NEXT:  LBB3_2:
 ; CHECK-APPLE-NEXT:    movi d0, #0000000000000000
-; CHECK-APPLE-NEXT:    ldp x29, x30, [sp], #16 ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:  LBB3_3: ; %common.ret
+; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: foo_if:
 ; CHECK-O0-AARCH64:       ; %bb.0: ; %entry
-; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #32
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 32
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    add x29, sp, #16
+; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #48
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 48
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #32
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-AARCH64-NEXT:    str x21, [sp, #8] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    cbz w0, LBB3_2
 ; CHECK-O0-AARCH64-NEXT:  ; %bb.1: ; %gen_error
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #16
 ; CHECK-O0-AARCH64-NEXT:    mov w0, w8
 ; CHECK-O0-AARCH64-NEXT:    bl _malloc
 ; CHECK-O0-AARCH64-NEXT:    mov x21, x0
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #1
 ; CHECK-O0-AARCH64-NEXT:    strb w8, [x0, #8]
 ; CHECK-O0-AARCH64-NEXT:    fmov s0, #1.00000000
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    add sp, sp, #32
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    add sp, sp, #48
 ; CHECK-O0-AARCH64-NEXT:    ret
 ; CHECK-O0-AARCH64-NEXT:  LBB3_2: ; %normal
 ; CHECK-O0-AARCH64-NEXT:    ldr x21, [sp, #8] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    movi d0, #0000000000000000
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    add sp, sp, #32
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    add sp, sp, #48
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: foo_if:
 ; CHECK-O0-ARM64_32:       ; %bb.0: ; %entry
-; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #32
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 32
-; CHECK-O0-ARM64_32-NEXT:    str x30, [sp, #16] ; 8-byte Folded Spill
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -16
+; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #48
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 48
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -8
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-ARM64_32-NEXT:    str x21, [sp, #8] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    cbz w0, LBB3_2
 ; CHECK-O0-ARM64_32-NEXT:  ; %bb.1: ; %gen_error
 ; CHECK-O0-ARM64_32-NEXT:    mov w8, #16
 ; CHECK-O0-ARM64_32-NEXT:    mov w0, w8
 ; CHECK-O0-ARM64_32-NEXT:    bl _malloc
 ; CHECK-O0-ARM64_32-NEXT:    mov x21, x0
 ; CHECK-O0-ARM64_32-NEXT:    mov w8, #1
 ; CHECK-O0-ARM64_32-NEXT:    strb w8, [x0, #8]
 ; CHECK-O0-ARM64_32-NEXT:    fmov s0, #1.00000000
-; CHECK-O0-ARM64_32-NEXT:    ldr x30, [sp, #16] ; 8-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #32
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #48
 ; CHECK-O0-ARM64_32-NEXT:    ret
 ; CHECK-O0-ARM64_32-NEXT:  LBB3_2: ; %normal
 ; CHECK-O0-ARM64_32-NEXT:    ldr x21, [sp, #8] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    movi d0, #0000000000000000
-; CHECK-O0-ARM64_32-NEXT:    ldr x30, [sp, #16] ; 8-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #32
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #48
 ; CHECK-O0-ARM64_32-NEXT:    ret
 
 ; spill x21
 ; reload from stack
 entry:
   %cond = icmp ne i32 %cc, 0
   br i1 %cond, label %gen_error, label %normal
 
 gen_error:
   %call = call ptr @malloc(i64 16)
   store ptr %call, ptr %error_ptr_ref
   %tmp = getelementptr inbounds i8, ptr %call, i64 8
   store i8 1, ptr %tmp
   ret float 1.0
 
 normal:
   ret float 0.0
 }
 
 ; "foo_loop" is a function that takes a swifterror parameter, it sets swifterror
 ; under a certain condition inside a loop.
 define float @foo_loop(ptr swifterror %error_ptr_ref, i32 %cc, float %cc2) {
 ; CHECK-APPLE-LABEL: foo_loop:
 ; CHECK-APPLE:       ; %bb.0: ; %entry
-; CHECK-APPLE-NEXT:    stp d9, d8, [sp, #-48]! ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 48
-; CHECK-APPLE-NEXT:    stp x20, x19, [sp, #16] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    add x29, sp, #32
+; CHECK-APPLE-NEXT:    stp d9, d8, [sp, #-64]! ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 64
+; CHECK-APPLE-NEXT:    stp x22, x21, [sp, #16] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x20, x19, [sp, #32] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #48] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    add x29, sp, #48
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-NEXT:    .cfi_offset w29, -16
 ; CHECK-APPLE-NEXT:    .cfi_offset w19, -24
 ; CHECK-APPLE-NEXT:    .cfi_offset w20, -32
-; CHECK-APPLE-NEXT:    .cfi_offset b8, -40
-; CHECK-APPLE-NEXT:    .cfi_offset b9, -48
+; CHECK-APPLE-NEXT:    .cfi_offset w21, -40
+; CHECK-APPLE-NEXT:    .cfi_offset w22, -48
+; CHECK-APPLE-NEXT:    .cfi_offset b8, -56
+; CHECK-APPLE-NEXT:    .cfi_offset b9, -64
 ; CHECK-APPLE-NEXT:    fmov s8, s0
 ; CHECK-APPLE-NEXT:    mov w19, w0
 ; CHECK-APPLE-NEXT:    mov x0, x21
 ; CHECK-APPLE-NEXT:    mov w20, #1
 ; CHECK-APPLE-NEXT:    fmov s9, #1.00000000
 ; CHECK-APPLE-NEXT:    b LBB4_2
 ; CHECK-APPLE-NEXT:  LBB4_1: ; %bb_cont
 ; CHECK-APPLE-NEXT:    ; in Loop: Header=BB4_2 Depth=1
 ; CHECK-APPLE-NEXT:    fcmp s8, s9
 ; CHECK-APPLE-NEXT:    b.gt LBB4_4
 ; CHECK-APPLE-NEXT:  LBB4_2: ; %bb_loop
 ; CHECK-APPLE-NEXT:    ; =>This Inner Loop Header: Depth=1
 ; CHECK-APPLE-NEXT:    cbz w19, LBB4_1
 ; CHECK-APPLE-NEXT:  ; %bb.3: ; %gen_error
 ; CHECK-APPLE-NEXT:    ; in Loop: Header=BB4_2 Depth=1
 ; CHECK-APPLE-NEXT:    mov w0, #16
 ; CHECK-APPLE-NEXT:    bl _malloc
 ; CHECK-APPLE-NEXT:    strb w20, [x0, #8]
 ; CHECK-APPLE-NEXT:    b LBB4_1
 ; CHECK-APPLE-NEXT:  LBB4_4: ; %bb_end
 ; CHECK-APPLE-NEXT:    movi d0, #0000000000000000
 ; CHECK-APPLE-NEXT:    mov x21, x0
-; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldp x20, x19, [sp, #16] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldp d9, d8, [sp], #48 ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #48] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x20, x19, [sp, #32] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp d9, d8, [sp], #64 ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: foo_loop:
 ; CHECK-O0-AARCH64:       ; %bb.0: ; %entry
-; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #48
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 48
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    add x29, sp, #32
+; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #64
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 64
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #48] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #48
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-AARCH64-NEXT:    str s0, [sp, #16] ; 4-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    stur w0, [x29, #-12] ; 4-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    stur x21, [x29, #-8] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    str w0, [sp, #20] ; 4-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    str x21, [sp, #24] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    b LBB4_1
 ; CHECK-O0-AARCH64-NEXT:  LBB4_1: ; %bb_loop
 ; CHECK-O0-AARCH64-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-O0-AARCH64-NEXT:    ldur w8, [x29, #-12] ; 4-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldur x0, [x29, #-8] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldr w8, [sp, #20] ; 4-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldr x0, [sp, #24] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    str x0, [sp, #8] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    cbz w8, LBB4_3
 ; CHECK-O0-AARCH64-NEXT:  ; %bb.2: ; %gen_error
 ; CHECK-O0-AARCH64-NEXT:    ; in Loop: Header=BB4_1 Depth=1
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #16
 ; CHECK-O0-AARCH64-NEXT:    mov w0, w8
 ; CHECK-O0-AARCH64-NEXT:    bl _malloc
 ; CHECK-O0-AARCH64-NEXT:    mov x9, x0
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #1
 ; CHECK-O0-AARCH64-NEXT:    strb w8, [x9, #8]
 ; CHECK-O0-AARCH64-NEXT:    str x0, [sp, #8] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:  LBB4_3: ; %bb_cont
 ; CHECK-O0-AARCH64-NEXT:    ; in Loop: Header=BB4_1 Depth=1
 ; CHECK-O0-AARCH64-NEXT:    ldr s0, [sp, #16] ; 4-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x0, [sp, #8] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    str x0, [sp] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    fmov s1, #1.00000000
 ; CHECK-O0-AARCH64-NEXT:    fcmp s0, s1
-; CHECK-O0-AARCH64-NEXT:    stur x0, [x29, #-8] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    str x0, [sp, #24] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    b.le LBB4_1
 ; CHECK-O0-AARCH64-NEXT:  ; %bb.4: ; %bb_end
 ; CHECK-O0-AARCH64-NEXT:    ldr x21, [sp] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    movi d0, #0000000000000000
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    add sp, sp, #48
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #48] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    add sp, sp, #64
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: foo_loop:
 ; CHECK-O0-ARM64_32:       ; %bb.0: ; %entry
-; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #48
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 48
-; CHECK-O0-ARM64_32-NEXT:    str x30, [sp, #32] ; 8-byte Folded Spill
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -16
+; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #64
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 64
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    stp x29, x30, [sp, #48] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -8
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-ARM64_32-NEXT:    str s0, [sp, #16] ; 4-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str w0, [sp, #20] ; 4-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x21, [sp, #24] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    b LBB4_1
 ; CHECK-O0-ARM64_32-NEXT:  LBB4_1: ; %bb_loop
 ; CHECK-O0-ARM64_32-NEXT:    ; =>This Inner Loop Header: Depth=1
 ; CHECK-O0-ARM64_32-NEXT:    ldr w8, [sp, #20] ; 4-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ldr x0, [sp, #24] ; 8-byte Folded Reload

 ; CHECK-O0-ARM64_32-NEXT:    str x0, [sp] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    fmov s1, #1.00000000
 ; CHECK-O0-ARM64_32-NEXT:    fcmp s0, s1
 ; CHECK-O0-ARM64_32-NEXT:    str x0, [sp, #24] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    b.le LBB4_1
 ; CHECK-O0-ARM64_32-NEXT:  ; %bb.4: ; %bb_end
 ; CHECK-O0-ARM64_32-NEXT:    ldr x21, [sp] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    movi d0, #0000000000000000
-; CHECK-O0-ARM64_32-NEXT:    ldr x30, [sp, #32] ; 8-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #48
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #48] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #64
 ; CHECK-O0-ARM64_32-NEXT:    ret
 
 ; spill x21
 ; spill x0
 ; reload from stack
 
 ; spill x21
 ; reload from stack

 
 %struct.S = type { i32, i32, i32, i32, i32, i32 }
 
 ; "foo_sret" is a function that takes a swifterror parameter, it also has a sret
 ; parameter.
 define void @foo_sret(ptr sret(%struct.S) %agg.result, i32 %val1, ptr swifterror %error_ptr_ref) {
 ; CHECK-APPLE-LABEL: foo_sret:
 ; CHECK-APPLE:       ; %bb.0: ; %entry
-; CHECK-APPLE-NEXT:    stp x20, x19, [sp, #-32]! ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 32
-; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    add x29, sp, #16
+; CHECK-APPLE-NEXT:    stp x22, x21, [sp, #-48]! ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 48
+; CHECK-APPLE-NEXT:    stp x20, x19, [sp, #16] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    add x29, sp, #32
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-NEXT:    .cfi_offset w29, -16
 ; CHECK-APPLE-NEXT:    .cfi_offset w19, -24
 ; CHECK-APPLE-NEXT:    .cfi_offset w20, -32
+; CHECK-APPLE-NEXT:    .cfi_offset w21, -40
+; CHECK-APPLE-NEXT:    .cfi_offset w22, -48
 ; CHECK-APPLE-NEXT:    mov w19, w0
 ; CHECK-APPLE-NEXT:    mov x20, x8
 ; CHECK-APPLE-NEXT:    mov w0, #16
 ; CHECK-APPLE-NEXT:    bl _malloc
 ; CHECK-APPLE-NEXT:    mov w8, #1
 ; CHECK-APPLE-NEXT:    mov x21, x0
 ; CHECK-APPLE-NEXT:    strb w8, [x0, #8]
 ; CHECK-APPLE-NEXT:    str w19, [x20, #4]
-; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldp x20, x19, [sp], #32 ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x20, x19, [sp, #16] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x22, xzr, [sp], #48 ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: foo_sret:
 ; CHECK-O0-AARCH64:       ; %bb.0: ; %entry
-; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #32
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 32
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    add x29, sp, #16
+; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #48
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 48
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #32
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
-; CHECK-O0-AARCH64-NEXT:    stur w0, [x29, #-4] ; 4-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -32
+; CHECK-O0-AARCH64-NEXT:    str w0, [sp, #12] ; 4-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x8, [sp] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #16
 ; CHECK-O0-AARCH64-NEXT:    mov w0, w8
 ; CHECK-O0-AARCH64-NEXT:    bl _malloc
 ; CHECK-O0-AARCH64-NEXT:    ldr x8, [sp] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    mov x10, x0
-; CHECK-O0-AARCH64-NEXT:    ldur w0, [x29, #-4] ; 4-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldr w0, [sp, #12] ; 4-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    mov x21, x10
 ; CHECK-O0-AARCH64-NEXT:    mov w9, #1
 ; CHECK-O0-AARCH64-NEXT:    strb w9, [x10, #8]
 ; CHECK-O0-AARCH64-NEXT:    str w0, [x8, #4]
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    add sp, sp, #32
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    add sp, sp, #48
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: foo_sret:
 ; CHECK-O0-ARM64_32:       ; %bb.0: ; %entry
-; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #32
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 32
-; CHECK-O0-ARM64_32-NEXT:    str x30, [sp, #16] ; 8-byte Folded Spill
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -16
+; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #48
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 48
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -8
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-ARM64_32-NEXT:    str w0, [sp, #12] ; 4-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x8, [sp] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    mov w8, #16
 ; CHECK-O0-ARM64_32-NEXT:    mov w0, w8
 ; CHECK-O0-ARM64_32-NEXT:    bl _malloc
 ; CHECK-O0-ARM64_32-NEXT:    ldr x8, [sp] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    mov x10, x0
 ; CHECK-O0-ARM64_32-NEXT:    ldr w0, [sp, #12] ; 4-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    mov x21, x10
 ; CHECK-O0-ARM64_32-NEXT:    mov w9, #1
 ; CHECK-O0-ARM64_32-NEXT:    strb w9, [x10, #8]
 ; CHECK-O0-ARM64_32-NEXT:    str w0, [x8, #4]
-; CHECK-O0-ARM64_32-NEXT:    ldr x30, [sp, #16] ; 8-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #32
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #48
 ; CHECK-O0-ARM64_32-NEXT:    ret
 
 ; spill x8
 ; reload from stack
 entry:
   %call = call ptr @malloc(i64 16)
   store ptr %call, ptr %error_ptr_ref
   %tmp = getelementptr inbounds i8, ptr %call, i64 8

 }
 
 ; "foo_vararg" is a function that takes a swifterror parameter, it also has
 ; variable number of arguments.
 declare void @llvm.va_start(ptr) nounwind
 define float @foo_vararg(ptr swifterror %error_ptr_ref, ...) {
 ; CHECK-APPLE-AARCH64-LABEL: foo_vararg:
 ; CHECK-APPLE-AARCH64:       ; %bb.0: ; %entry
-; CHECK-APPLE-AARCH64-NEXT:    sub sp, sp, #48
-; CHECK-APPLE-AARCH64-NEXT:    .cfi_def_cfa_offset 48
-; CHECK-APPLE-AARCH64-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
-; CHECK-APPLE-AARCH64-NEXT:    add x29, sp, #32
+; CHECK-APPLE-AARCH64-NEXT:    sub sp, sp, #64
+; CHECK-APPLE-AARCH64-NEXT:    .cfi_def_cfa_offset 64
+; CHECK-APPLE-AARCH64-NEXT:    stp x22, x21, [sp, #32] ; 16-byte Folded Spill
+; CHECK-APPLE-AARCH64-NEXT:    stp x29, x30, [sp, #48] ; 16-byte Folded Spill
+; CHECK-APPLE-AARCH64-NEXT:    add x29, sp, #48
 ; CHECK-APPLE-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-AARCH64-NEXT:    .cfi_offset w29, -16
+; CHECK-APPLE-AARCH64-NEXT:    .cfi_offset w21, -24
+; CHECK-APPLE-AARCH64-NEXT:    .cfi_offset w22, -32
 ; CHECK-APPLE-AARCH64-NEXT:    mov w0, #16
 ; CHECK-APPLE-AARCH64-NEXT:    bl _malloc
 ; CHECK-APPLE-AARCH64-NEXT:    mov w8, #1
 ; CHECK-APPLE-AARCH64-NEXT:    add x9, x29, #16
 ; CHECK-APPLE-AARCH64-NEXT:    ldr w10, [x29, #16]
 ; CHECK-APPLE-AARCH64-NEXT:    orr x9, x9, #0x8
 ; CHECK-APPLE-AARCH64-NEXT:    strb w8, [x0, #8]
-; CHECK-APPLE-AARCH64-NEXT:    stur w10, [x29, #-12]
+; CHECK-APPLE-AARCH64-NEXT:    str w10, [sp, #20]
 ; CHECK-APPLE-AARCH64-NEXT:    ldr w8, [x9], #8
 ; CHECK-APPLE-AARCH64-NEXT:    str w8, [sp, #16]
 ; CHECK-APPLE-AARCH64-NEXT:    ldr w8, [x9], #8
 ; CHECK-APPLE-AARCH64-NEXT:    fmov s0, #1.00000000
 ; CHECK-APPLE-AARCH64-NEXT:    mov x21, x0
-; CHECK-APPLE-AARCH64-NEXT:    stur x9, [x29, #-8]
+; CHECK-APPLE-AARCH64-NEXT:    str x9, [sp, #24]
 ; CHECK-APPLE-AARCH64-NEXT:    str w8, [sp, #12]
-; CHECK-APPLE-AARCH64-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
-; CHECK-APPLE-AARCH64-NEXT:    add sp, sp, #48
+; CHECK-APPLE-AARCH64-NEXT:    ldp x29, x30, [sp, #48] ; 16-byte Folded Reload
+; CHECK-APPLE-AARCH64-NEXT:    ldp x22, xzr, [sp, #32] ; 16-byte Folded Reload
+; CHECK-APPLE-AARCH64-NEXT:    add sp, sp, #64
 ; CHECK-APPLE-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: foo_vararg:
 ; CHECK-O0-AARCH64:       ; %bb.0: ; %entry
-; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #48
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 48
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    add x29, sp, #32
+; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #64
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 64
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #48] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #48
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #16
 ; CHECK-O0-AARCH64-NEXT:    mov w0, w8
 ; CHECK-O0-AARCH64-NEXT:    bl _malloc
 ; CHECK-O0-AARCH64-NEXT:    mov x21, x0
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #1
 ; CHECK-O0-AARCH64-NEXT:    strb w8, [x0, #8]
 ; CHECK-O0-AARCH64-NEXT:    add x8, x29, #16
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-8]
-; CHECK-O0-AARCH64-NEXT:    ldur x8, [x29, #-8]
+; CHECK-O0-AARCH64-NEXT:    str x8, [sp, #24]
+; CHECK-O0-AARCH64-NEXT:    ldr x8, [sp, #24]
 ; CHECK-O0-AARCH64-NEXT:    add x9, x8, #8
-; CHECK-O0-AARCH64-NEXT:    stur x9, [x29, #-8]
+; CHECK-O0-AARCH64-NEXT:    str x9, [sp, #24]
 ; CHECK-O0-AARCH64-NEXT:    ldr w8, [x8]
-; CHECK-O0-AARCH64-NEXT:    stur w8, [x29, #-12]
-; CHECK-O0-AARCH64-NEXT:    ldur x8, [x29, #-8]
+; CHECK-O0-AARCH64-NEXT:    str w8, [sp, #20]
+; CHECK-O0-AARCH64-NEXT:    ldr x8, [sp, #24]
 ; CHECK-O0-AARCH64-NEXT:    add x9, x8, #8
-; CHECK-O0-AARCH64-NEXT:    stur x9, [x29, #-8]
+; CHECK-O0-AARCH64-NEXT:    str x9, [sp, #24]
 ; CHECK-O0-AARCH64-NEXT:    ldr w8, [x8]
 ; CHECK-O0-AARCH64-NEXT:    str w8, [sp, #16]
-; CHECK-O0-AARCH64-NEXT:    ldur x8, [x29, #-8]
+; CHECK-O0-AARCH64-NEXT:    ldr x8, [sp, #24]
 ; CHECK-O0-AARCH64-NEXT:    add x9, x8, #8
-; CHECK-O0-AARCH64-NEXT:    stur x9, [x29, #-8]
+; CHECK-O0-AARCH64-NEXT:    str x9, [sp, #24]
 ; CHECK-O0-AARCH64-NEXT:    ldr w8, [x8]
 ; CHECK-O0-AARCH64-NEXT:    str w8, [sp, #12]
 ; CHECK-O0-AARCH64-NEXT:    fmov s0, #1.00000000
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    add sp, sp, #48
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #48] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    add sp, sp, #64
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-APPLE-ARM64_32-LABEL: foo_vararg:
 ; CHECK-APPLE-ARM64_32:       ; %bb.0: ; %entry
-; CHECK-APPLE-ARM64_32-NEXT:    sub sp, sp, #48
-; CHECK-APPLE-ARM64_32-NEXT:    .cfi_def_cfa_offset 48
-; CHECK-APPLE-ARM64_32-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
-; CHECK-APPLE-ARM64_32-NEXT:    add x29, sp, #32
+; CHECK-APPLE-ARM64_32-NEXT:    sub sp, sp, #64
+; CHECK-APPLE-ARM64_32-NEXT:    .cfi_def_cfa_offset 64
+; CHECK-APPLE-ARM64_32-NEXT:    stp x22, x21, [sp, #32] ; 16-byte Folded Spill
+; CHECK-APPLE-ARM64_32-NEXT:    stp x29, x30, [sp, #48] ; 16-byte Folded Spill
+; CHECK-APPLE-ARM64_32-NEXT:    add x29, sp, #48
 ; CHECK-APPLE-ARM64_32-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-ARM64_32-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-APPLE-ARM64_32-NEXT:    .cfi_offset w21, -24
+; CHECK-APPLE-ARM64_32-NEXT:    .cfi_offset w22, -32
 ; CHECK-APPLE-ARM64_32-NEXT:    mov w0, #16
 ; CHECK-APPLE-ARM64_32-NEXT:    bl _malloc
 ; CHECK-APPLE-ARM64_32-NEXT:    mov w8, #1
 ; CHECK-APPLE-ARM64_32-NEXT:    add x9, x29, #16
 ; CHECK-APPLE-ARM64_32-NEXT:    orr w10, w9, #0x4
 ; CHECK-APPLE-ARM64_32-NEXT:    and x11, x9, #0xfffffff0
 ; CHECK-APPLE-ARM64_32-NEXT:    strb w8, [x0, #8]
-; CHECK-APPLE-ARM64_32-NEXT:    stur w10, [x29, #-8]
+; CHECK-APPLE-ARM64_32-NEXT:    str w10, [sp, #24]
 ; CHECK-APPLE-ARM64_32-NEXT:    ldr w8, [x11]
 ; CHECK-APPLE-ARM64_32-NEXT:    orr w11, w9, #0x8
-; CHECK-APPLE-ARM64_32-NEXT:    stp w8, w11, [x29, #-12]
+; CHECK-APPLE-ARM64_32-NEXT:    stp w8, w11, [sp, #20]
 ; CHECK-APPLE-ARM64_32-NEXT:    orr w8, w9, #0xc
 ; CHECK-APPLE-ARM64_32-NEXT:    ldr w9, [x10]
-; CHECK-APPLE-ARM64_32-NEXT:    stur w8, [x29, #-8]
+; CHECK-APPLE-ARM64_32-NEXT:    str w8, [sp, #24]
 ; CHECK-APPLE-ARM64_32-NEXT:    str w9, [sp, #16]
 ; CHECK-APPLE-ARM64_32-NEXT:    ldr w8, [x11]
 ; CHECK-APPLE-ARM64_32-NEXT:    fmov s0, #1.00000000
 ; CHECK-APPLE-ARM64_32-NEXT:    mov x21, x0
 ; CHECK-APPLE-ARM64_32-NEXT:    str w8, [sp, #12]
-; CHECK-APPLE-ARM64_32-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
-; CHECK-APPLE-ARM64_32-NEXT:    add sp, sp, #48
+; CHECK-APPLE-ARM64_32-NEXT:    ldp x29, x30, [sp, #48] ; 16-byte Folded Reload
+; CHECK-APPLE-ARM64_32-NEXT:    ldp x22, xzr, [sp, #32] ; 16-byte Folded Reload
+; CHECK-APPLE-ARM64_32-NEXT:    add sp, sp, #64
 ; CHECK-APPLE-ARM64_32-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: foo_vararg:
 ; CHECK-O0-ARM64_32:       ; %bb.0: ; %entry
-; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #48
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 48
-; CHECK-O0-ARM64_32-NEXT:    str x30, [sp, #32] ; 8-byte Folded Spill
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -16
+; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #64
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 64
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    stp x29, x30, [sp, #48] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -8
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-ARM64_32-NEXT:    mov w8, #16
 ; CHECK-O0-ARM64_32-NEXT:    mov w0, w8
 ; CHECK-O0-ARM64_32-NEXT:    bl _malloc
 ; CHECK-O0-ARM64_32-NEXT:    mov x21, x0
 ; CHECK-O0-ARM64_32-NEXT:    mov w8, #1
 ; CHECK-O0-ARM64_32-NEXT:    strb w8, [x0, #8]
-; CHECK-O0-ARM64_32-NEXT:    add x8, sp, #48
+; CHECK-O0-ARM64_32-NEXT:    add x8, sp, #64
 ; CHECK-O0-ARM64_32-NEXT:    ; kill: def $w8 killed $w8 killed $x8
 ; CHECK-O0-ARM64_32-NEXT:    str w8, [sp, #24]
 ; CHECK-O0-ARM64_32-NEXT:    ldr w8, [sp, #24]
 ; CHECK-O0-ARM64_32-NEXT:    ; kill: def $x8 killed $w8
 ; CHECK-O0-ARM64_32-NEXT:    mov w9, w8
 ; CHECK-O0-ARM64_32-NEXT:    add w9, w9, #4
 ; CHECK-O0-ARM64_32-NEXT:    str w9, [sp, #24]
 ; CHECK-O0-ARM64_32-NEXT:    ldr w8, [x8]
 ; CHECK-O0-ARM64_32-NEXT:    str w8, [sp, #20]
 ; CHECK-O0-ARM64_32-NEXT:    ldr w8, [sp, #24]
 ; CHECK-O0-ARM64_32-NEXT:    ; kill: def $x8 killed $w8
 ; CHECK-O0-ARM64_32-NEXT:    mov w9, w8
 ; CHECK-O0-ARM64_32-NEXT:    add w9, w9, #4
 ; CHECK-O0-ARM64_32-NEXT:    str w9, [sp, #24]
 ; CHECK-O0-ARM64_32-NEXT:    ldr w8, [x8]
 ; CHECK-O0-ARM64_32-NEXT:    str w8, [sp, #16]
 ; CHECK-O0-ARM64_32-NEXT:    ldr w8, [sp, #24]
 ; CHECK-O0-ARM64_32-NEXT:    ; kill: def $x8 killed $w8
 ; CHECK-O0-ARM64_32-NEXT:    mov w9, w8
 ; CHECK-O0-ARM64_32-NEXT:    add w9, w9, #4
 ; CHECK-O0-ARM64_32-NEXT:    str w9, [sp, #24]
 ; CHECK-O0-ARM64_32-NEXT:    ldr w8, [x8]
 ; CHECK-O0-ARM64_32-NEXT:    str w8, [sp, #12]
 ; CHECK-O0-ARM64_32-NEXT:    fmov s0, #1.00000000
-; CHECK-O0-ARM64_32-NEXT:    ldr x30, [sp, #32] ; 8-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #48
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #48] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #64
 ; CHECK-O0-ARM64_32-NEXT:    ret
 
 ; First vararg
 ; Third vararg
 ; Second vararg
 
 
 
handler:
   call void @free(ptr %error_from_foo)
   ret float 1.0
 }
 
 ; Check that we don't blow up on tail calling swifterror argument functions.
 define float @tailcallswifterror(ptr swifterror %error_ptr_ref) {
 ; CHECK-APPLE-LABEL: tailcallswifterror:
 ; CHECK-APPLE:       ; %bb.0: ; %entry
-; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-APPLE-NEXT:    mov x29, sp
+; CHECK-APPLE-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    add x29, sp, #16
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-NEXT:    .cfi_offset w29, -16
+; CHECK-APPLE-NEXT:    .cfi_offset w21, -24
+; CHECK-APPLE-NEXT:    .cfi_offset w22, -32
 ; CHECK-APPLE-NEXT:    bl _tailcallswifterror
-; CHECK-APPLE-NEXT:    ldp x29, x30, [sp], #16 ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: tailcallswifterror:
 ; CHECK-O0-AARCH64:       ; %bb.0: ; %entry
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-O0-AARCH64-NEXT:    mov x29, sp
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-AARCH64-NEXT:    bl _tailcallswifterror
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp], #16 ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: tailcallswifterror:
 ; CHECK-O0-ARM64_32:       ; %bb.0: ; %entry
-; CHECK-O0-ARM64_32-NEXT:    str x30, [sp, #-16]! ; 8-byte Folded Spill
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -16
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-O0-ARM64_32-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -8
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-ARM64_32-NEXT:    bl _tailcallswifterror
-; CHECK-O0-ARM64_32-NEXT:    ldr x30, [sp], #16 ; 8-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ret
 entry:
   %0 = tail call float @tailcallswifterror(ptr swifterror %error_ptr_ref)
   ret float %0
 }
 define swiftcc float @tailcallswifterror_swiftcc(ptr swifterror %error_ptr_ref) {
 ; CHECK-APPLE-LABEL: tailcallswifterror_swiftcc:
 ; CHECK-APPLE:       ; %bb.0: ; %entry
-; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-APPLE-NEXT:    mov x29, sp
+; CHECK-APPLE-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    add x29, sp, #16
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-NEXT:    .cfi_offset w29, -16
+; CHECK-APPLE-NEXT:    .cfi_offset w21, -24
+; CHECK-APPLE-NEXT:    .cfi_offset w22, -32
 ; CHECK-APPLE-NEXT:    bl _tailcallswifterror_swiftcc
-; CHECK-APPLE-NEXT:    ldp x29, x30, [sp], #16 ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: tailcallswifterror_swiftcc:
 ; CHECK-O0-AARCH64:       ; %bb.0: ; %entry
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-O0-AARCH64-NEXT:    mov x29, sp
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-AARCH64-NEXT:    bl _tailcallswifterror_swiftcc
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp], #16 ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: tailcallswifterror_swiftcc:
 ; CHECK-O0-ARM64_32:       ; %bb.0: ; %entry
-; CHECK-O0-ARM64_32-NEXT:    str x30, [sp, #-16]! ; 8-byte Folded Spill
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -16
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-O0-ARM64_32-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -8
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-ARM64_32-NEXT:    bl _tailcallswifterror_swiftcc
-; CHECK-O0-ARM64_32-NEXT:    ldr x30, [sp], #16 ; 8-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ret
 entry:
   %0 = tail call swiftcc float @tailcallswifterror_swiftcc(ptr swifterror %error_ptr_ref)
   ret float %0
 }
 
 define swiftcc void @swifterror_clobber(ptr nocapture swifterror %err) {
 ; CHECK-APPLE-LABEL: swifterror_clobber:
 ; CHECK-APPLE:       ; %bb.0:
-; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 16
-; CHECK-APPLE-NEXT:    mov x29, sp
+; CHECK-APPLE-NEXT:    stp x22, x21, [sp, #-32]! ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    add x29, sp, #16
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-NEXT:    .cfi_offset w29, -16
+; CHECK-APPLE-NEXT:    .cfi_offset w21, -24
+; CHECK-APPLE-NEXT:    .cfi_offset w22, -32
 ; CHECK-APPLE-NEXT:    mov x8, x21
 ; CHECK-APPLE-NEXT:    ; InlineAsm Start
 ; CHECK-APPLE-NEXT:    nop
 ; CHECK-APPLE-NEXT:    ; InlineAsm End
 ; CHECK-APPLE-NEXT:    mov x21, x8
-; CHECK-APPLE-NEXT:    ldp x29, x30, [sp], #16 ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x22, xzr, [sp], #32 ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: swifterror_clobber:
 ; CHECK-O0-AARCH64:       ; %bb.0:
-; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #32
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 32
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    add x29, sp, #16
+; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #48
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 48
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #32
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-AARCH64-NEXT:    str x21, [sp, #8] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    ; InlineAsm Start
 ; CHECK-O0-AARCH64-NEXT:    nop
 ; CHECK-O0-AARCH64-NEXT:    ; InlineAsm End
 ; CHECK-O0-AARCH64-NEXT:    ldr x21, [sp, #8] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    add sp, sp, #32
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    add sp, sp, #48
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: swifterror_clobber:
 ; CHECK-O0-ARM64_32:       ; %bb.0:
-; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #16
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 16
+; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #32
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -8
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -16
 ; CHECK-O0-ARM64_32-NEXT:    str x21, [sp, #8] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    ; InlineAsm Start
 ; CHECK-O0-ARM64_32-NEXT:    nop
 ; CHECK-O0-ARM64_32-NEXT:    ; InlineAsm End
 ; CHECK-O0-ARM64_32-NEXT:    ldr x21, [sp, #8] ; 8-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #16
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #32
 ; CHECK-O0-ARM64_32-NEXT:    ret
   call void asm sideeffect "nop", "~{x21}"()
   ret void
 }
 
 define swiftcc void @swifterror_reg_clobber(ptr nocapture %err) {
 ; CHECK-APPLE-LABEL: swifterror_reg_clobber:
 ; CHECK-APPLE:       ; %bb.0:

 ; CHECK-O0-ARM64_32-NEXT:    ret
   call void asm sideeffect "nop", "~{x21}"()
   ret void
 }
 
 define swiftcc void @params_in_reg(i64, i64, i64, i64, i64, i64, i64, i64, ptr swiftself, ptr nocapture swifterror %err) {
 ; CHECK-APPLE-LABEL: params_in_reg:
 ; CHECK-APPLE:       ; %bb.0:
-; CHECK-APPLE-NEXT:    sub sp, sp, #112
-; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 112
-; CHECK-APPLE-NEXT:    stp x21, x28, [sp, #8] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    stp x27, x26, [sp, #32] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    stp x25, x24, [sp, #48] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    stp x23, x22, [sp, #64] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    stp x20, x19, [sp, #80] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #96] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    add x29, sp, #96
+; CHECK-APPLE-NEXT:    sub sp, sp, #128
+; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 128
+; CHECK-APPLE-NEXT:    stp x28, x27, [sp, #32] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x26, x25, [sp, #48] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x24, x23, [sp, #64] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x22, x21, [sp, #80] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x20, x19, [sp, #96] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #112] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    add x29, sp, #112
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-NEXT:    .cfi_offset w29, -16
 ; CHECK-APPLE-NEXT:    .cfi_offset w19, -24
 ; CHECK-APPLE-NEXT:    .cfi_offset w20, -32
-; CHECK-APPLE-NEXT:    .cfi_offset w22, -40
-; CHECK-APPLE-NEXT:    .cfi_offset w23, -48
-; CHECK-APPLE-NEXT:    .cfi_offset w24, -56
-; CHECK-APPLE-NEXT:    .cfi_offset w25, -64
-; CHECK-APPLE-NEXT:    .cfi_offset w26, -72
-; CHECK-APPLE-NEXT:    .cfi_offset w27, -80
+; CHECK-APPLE-NEXT:    .cfi_offset w21, -40
+; CHECK-APPLE-NEXT:    .cfi_offset w22, -48
+; CHECK-APPLE-NEXT:    .cfi_offset w23, -56
+; CHECK-APPLE-NEXT:    .cfi_offset w24, -64
+; CHECK-APPLE-NEXT:    .cfi_offset w25, -72
+; CHECK-APPLE-NEXT:    .cfi_offset w26, -80
+; CHECK-APPLE-NEXT:    .cfi_offset w27, -88
 ; CHECK-APPLE-NEXT:    .cfi_offset w28, -96
-; CHECK-APPLE-NEXT:    str x20, [sp] ; 8-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x20, x21, [sp, #8] ; 16-byte Folded Spill
 ; CHECK-APPLE-NEXT:    mov x23, x7
 ; CHECK-APPLE-NEXT:    mov x24, x6
 ; CHECK-APPLE-NEXT:    mov x25, x5
 ; CHECK-APPLE-NEXT:    mov x26, x4
 ; CHECK-APPLE-NEXT:    mov x27, x3
 ; CHECK-APPLE-NEXT:    mov x28, x2
 ; CHECK-APPLE-NEXT:    mov x19, x1
 ; CHECK-APPLE-NEXT:    mov x22, x0

 ; CHECK-APPLE-NEXT:    mov x0, x22
 ; CHECK-APPLE-NEXT:    mov x1, x19
 ; CHECK-APPLE-NEXT:    mov x2, x28
 ; CHECK-APPLE-NEXT:    mov x3, x27
 ; CHECK-APPLE-NEXT:    mov x4, x26
 ; CHECK-APPLE-NEXT:    mov x5, x25
 ; CHECK-APPLE-NEXT:    mov x6, x24
 ; CHECK-APPLE-NEXT:    mov x7, x23
-; CHECK-APPLE-NEXT:    ldp x20, x21, [sp] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x20, x21, [sp, #8] ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    bl _params_in_reg2
-; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #96] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldp x20, x19, [sp, #80] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldp x23, x22, [sp, #64] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldp x25, x24, [sp, #48] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldp x27, x26, [sp, #32] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldr x28, [sp, #16] ; 8-byte Folded Reload
-; CHECK-APPLE-NEXT:    add sp, sp, #112
+; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #112] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x20, x19, [sp, #96] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x22, xzr, [sp, #80] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x24, x23, [sp, #64] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x26, x25, [sp, #48] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x28, x27, [sp, #32] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    add sp, sp, #128
 ; CHECK-APPLE-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: params_in_reg:
 ; CHECK-O0-AARCH64:       ; %bb.0:
-; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #128
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 128
-; CHECK-O0-AARCH64-NEXT:    str x20, [sp, #96] ; 8-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #112] ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    add x29, sp, #112
+; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #144
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 144
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #96] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stp x20, x19, [sp, #112] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #128] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #128
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w19, -24
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w20, -32
-; CHECK-O0-AARCH64-NEXT:    stur x21, [x29, #-32] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -40
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -48
+; CHECK-O0-AARCH64-NEXT:    stur x21, [x29, #-48] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x20, [sp, #8] ; 8-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    stur x7, [x29, #-40] ; 8-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    stur x6, [x29, #-48] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stur x7, [x29, #-56] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    str x6, [sp, #64] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x5, [sp, #56] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x4, [sp, #48] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x3, [sp, #40] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x2, [sp, #32] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x1, [sp, #24] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x0, [sp, #16] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    ; implicit-def: $x0
 ; CHECK-O0-AARCH64-NEXT:    mov x20, xzr

 ; CHECK-O0-AARCH64-NEXT:    bl _params_in_reg2
 ; CHECK-O0-AARCH64-NEXT:    ldr x20, [sp, #8] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x0, [sp, #16] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x1, [sp, #24] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x2, [sp, #32] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x3, [sp, #40] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x4, [sp, #48] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x5, [sp, #56] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldur x6, [x29, #-48] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldur x7, [x29, #-40] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldr x6, [sp, #64] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldur x7, [x29, #-56] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x21
-; CHECK-O0-AARCH64-NEXT:    ldur x21, [x29, #-32] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldur x21, [x29, #-48] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    bl _params_in_reg2
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #112] ; 16-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldr x20, [sp, #96] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    add sp, sp, #128
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #128] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x20, x19, [sp, #112] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp, #96] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    add sp, sp, #144
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: params_in_reg:
 ; CHECK-O0-ARM64_32:       ; %bb.0:
-; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #112
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 112
-; CHECK-O0-ARM64_32-NEXT:    stp x20, x30, [sp, #96] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #144
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 144
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #96] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    stp x20, x19, [sp, #112] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    stp x29, x30, [sp, #128] ; 16-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -8
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w20, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w19, -24
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w20, -32
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -40
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -48
 ; CHECK-O0-ARM64_32-NEXT:    str x21, [sp, #80] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x20, [sp, #8] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x7, [sp, #72] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x6, [sp, #64] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x5, [sp, #56] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x4, [sp, #48] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x3, [sp, #40] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x2, [sp, #32] ; 8-byte Folded Spill

 ; CHECK-O0-ARM64_32-NEXT:    ldr x3, [sp, #40] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ldr x4, [sp, #48] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ldr x5, [sp, #56] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ldr x6, [sp, #64] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ldr x7, [sp, #72] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    mov x8, x21
 ; CHECK-O0-ARM64_32-NEXT:    ldr x21, [sp, #80] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    bl _params_in_reg2
-; CHECK-O0-ARM64_32-NEXT:    ldp x20, x30, [sp, #96] ; 16-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #112
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #128] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x20, x19, [sp, #112] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp, #96] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #144
 ; CHECK-O0-ARM64_32-NEXT:    ret
   %error_ptr_ref = alloca swifterror ptr, align 8
   store ptr null, ptr %error_ptr_ref
   call swiftcc void @params_in_reg2(i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, ptr swiftself null, ptr nocapture swifterror %error_ptr_ref)
   call swiftcc void @params_in_reg2(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7, ptr swiftself %8, ptr nocapture swifterror %err)
   ret void
 }
 declare swiftcc void @params_in_reg2(i64, i64, i64, i64, i64, i64, i64, i64, ptr swiftself, ptr nocapture swifterror %err)
 
 define swiftcc { i64, i64, i64, i64, i64, i64, i64, i64 } @params_and_return_in_reg(i64, i64, i64, i64, i64, i64, i64, i64, ptr swiftself, ptr nocapture swifterror %err) {
 ; CHECK-APPLE-LABEL: params_and_return_in_reg:
 ; CHECK-APPLE:       ; %bb.0:
 ; CHECK-APPLE-NEXT:    sub sp, sp, #128
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 128
-; CHECK-APPLE-NEXT:    stp x20, x28, [sp, #24] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    stp x27, x26, [sp, #48] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    stp x25, x24, [sp, #64] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    stp x23, x22, [sp, #80] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x28, x27, [sp, #32] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x26, x25, [sp, #48] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x24, x23, [sp, #64] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x22, x21, [sp, #80] ; 16-byte Folded Spill
 ; CHECK-APPLE-NEXT:    stp x20, x19, [sp, #96] ; 16-byte Folded Spill
 ; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #112] ; 16-byte Folded Spill
 ; CHECK-APPLE-NEXT:    add x29, sp, #112
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-NEXT:    .cfi_offset w29, -16
 ; CHECK-APPLE-NEXT:    .cfi_offset w19, -24
 ; CHECK-APPLE-NEXT:    .cfi_offset w20, -32
-; CHECK-APPLE-NEXT:    .cfi_offset w22, -40
-; CHECK-APPLE-NEXT:    .cfi_offset w23, -48
-; CHECK-APPLE-NEXT:    .cfi_offset w24, -56
-; CHECK-APPLE-NEXT:    .cfi_offset w25, -64
-; CHECK-APPLE-NEXT:    .cfi_offset w26, -72
-; CHECK-APPLE-NEXT:    .cfi_offset w27, -80
+; CHECK-APPLE-NEXT:    .cfi_offset w21, -40
+; CHECK-APPLE-NEXT:    .cfi_offset w22, -48
+; CHECK-APPLE-NEXT:    .cfi_offset w23, -56
+; CHECK-APPLE-NEXT:    .cfi_offset w24, -64
+; CHECK-APPLE-NEXT:    .cfi_offset w25, -72
+; CHECK-APPLE-NEXT:    .cfi_offset w26, -80
+; CHECK-APPLE-NEXT:    .cfi_offset w27, -88
 ; CHECK-APPLE-NEXT:    .cfi_offset w28, -96
 ; CHECK-APPLE-NEXT:    mov x23, x21
-; CHECK-APPLE-NEXT:    str x7, [sp, #16] ; 8-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x7, x20, [sp, #8] ; 16-byte Folded Spill
 ; CHECK-APPLE-NEXT:    mov x24, x6
 ; CHECK-APPLE-NEXT:    mov x25, x5
 ; CHECK-APPLE-NEXT:    mov x26, x4
 ; CHECK-APPLE-NEXT:    mov x27, x3
 ; CHECK-APPLE-NEXT:    mov x28, x2
 ; CHECK-APPLE-NEXT:    mov x19, x1
 ; CHECK-APPLE-NEXT:    mov x22, x0
 ; CHECK-APPLE-NEXT:    mov w0, #1
 ; CHECK-APPLE-NEXT:    mov w1, #2
 ; CHECK-APPLE-NEXT:    mov w2, #3
 ; CHECK-APPLE-NEXT:    mov w3, #4
 ; CHECK-APPLE-NEXT:    mov w4, #5
 ; CHECK-APPLE-NEXT:    mov w5, #6
 ; CHECK-APPLE-NEXT:    mov w6, #7
 ; CHECK-APPLE-NEXT:    mov w7, #8
 ; CHECK-APPLE-NEXT:    mov x20, xzr
 ; CHECK-APPLE-NEXT:    mov x21, xzr
 ; CHECK-APPLE-NEXT:    bl _params_in_reg2
-; CHECK-APPLE-NEXT:    str x21, [sp, #8] ; 8-byte Folded Spill
+; CHECK-APPLE-NEXT:    str x21, [sp] ; 8-byte Folded Spill
 ; CHECK-APPLE-NEXT:    mov x0, x22
 ; CHECK-APPLE-NEXT:    mov x1, x19
 ; CHECK-APPLE-NEXT:    mov x2, x28
 ; CHECK-APPLE-NEXT:    mov x3, x27
 ; CHECK-APPLE-NEXT:    mov x4, x26
 ; CHECK-APPLE-NEXT:    mov x5, x25
 ; CHECK-APPLE-NEXT:    mov x6, x24
-; CHECK-APPLE-NEXT:    ldp x7, x20, [sp, #16] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x7, x20, [sp, #8] ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    mov x21, x23
 ; CHECK-APPLE-NEXT:    bl _params_and_return_in_reg2
 ; CHECK-APPLE-NEXT:    mov x19, x0
 ; CHECK-APPLE-NEXT:    mov x22, x1
 ; CHECK-APPLE-NEXT:    mov x24, x2
 ; CHECK-APPLE-NEXT:    mov x25, x3
 ; CHECK-APPLE-NEXT:    mov x26, x4
 ; CHECK-APPLE-NEXT:    mov x27, x5
 ; CHECK-APPLE-NEXT:    mov x28, x6
 ; CHECK-APPLE-NEXT:    mov x23, x7
-; CHECK-APPLE-NEXT:    str x21, [sp, #24] ; 8-byte Folded Spill
+; CHECK-APPLE-NEXT:    str x21, [sp, #16] ; 8-byte Folded Spill
 ; CHECK-APPLE-NEXT:    mov w0, #1
 ; CHECK-APPLE-NEXT:    mov w1, #2
 ; CHECK-APPLE-NEXT:    mov w2, #3
 ; CHECK-APPLE-NEXT:    mov w3, #4
 ; CHECK-APPLE-NEXT:    mov w4, #5
 ; CHECK-APPLE-NEXT:    mov w5, #6
 ; CHECK-APPLE-NEXT:    mov w6, #7
 ; CHECK-APPLE-NEXT:    mov w7, #8
 ; CHECK-APPLE-NEXT:    mov x20, xzr
-; CHECK-APPLE-NEXT:    ldr x21, [sp, #8] ; 8-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldr x21, [sp] ; 8-byte Folded Reload
 ; CHECK-APPLE-NEXT:    bl _params_in_reg2
 ; CHECK-APPLE-NEXT:    mov x0, x19
 ; CHECK-APPLE-NEXT:    mov x1, x22
 ; CHECK-APPLE-NEXT:    mov x2, x24
 ; CHECK-APPLE-NEXT:    mov x3, x25
 ; CHECK-APPLE-NEXT:    mov x4, x26
 ; CHECK-APPLE-NEXT:    mov x5, x27
 ; CHECK-APPLE-NEXT:    mov x6, x28
 ; CHECK-APPLE-NEXT:    mov x7, x23
-; CHECK-APPLE-NEXT:    ldp x21, x28, [sp, #24] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldr x21, [sp, #16] ; 8-byte Folded Reload
 ; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #112] ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    ldp x20, x19, [sp, #96] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldp x23, x22, [sp, #80] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldp x25, x24, [sp, #64] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldp x27, x26, [sp, #48] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x22, xzr, [sp, #80] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x24, x23, [sp, #64] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x26, x25, [sp, #48] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x28, x27, [sp, #32] ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    add sp, sp, #128
 ; CHECK-APPLE-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: params_and_return_in_reg:
 ; CHECK-O0-AARCH64:       ; %bb.0:
-; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #272
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 272
-; CHECK-O0-AARCH64-NEXT:    stp x28, x20, [sp, #240] ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #256] ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    add x29, sp, #256
+; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #288
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 288
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #240] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stp x20, x19, [sp, #256] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #272] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #272
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
-; CHECK-O0-AARCH64-NEXT:    .cfi_offset w20, -24
-; CHECK-O0-AARCH64-NEXT:    .cfi_offset w28, -32
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w19, -24
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w20, -32
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -40
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -48
 ; CHECK-O0-AARCH64-NEXT:    str x21, [sp, #72] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x20, [sp] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x7, [sp, #64] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x6, [sp, #56] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x5, [sp, #48] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x4, [sp, #40] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x3, [sp, #32] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    str x2, [sp, #24] ; 8-byte Folded Spill

 ; CHECK-O0-AARCH64-NEXT:    mov w8, #5
 ; CHECK-O0-AARCH64-NEXT:    mov w4, w8
 ; CHECK-O0-AARCH64-NEXT:    str x4, [sp, #120] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #6
 ; CHECK-O0-AARCH64-NEXT:    mov w5, w8
 ; CHECK-O0-AARCH64-NEXT:    str x5, [sp, #128] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #7
 ; CHECK-O0-AARCH64-NEXT:    mov w6, w8
-; CHECK-O0-AARCH64-NEXT:    stur x6, [x29, #-120] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    str x6, [sp, #136] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov w8, #8
 ; CHECK-O0-AARCH64-NEXT:    mov w7, w8
-; CHECK-O0-AARCH64-NEXT:    stur x7, [x29, #-112] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stur x7, [x29, #-128] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    bl _params_in_reg2
 ; CHECK-O0-AARCH64-NEXT:    ldr x20, [sp] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x0, [sp, #8] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x1, [sp, #16] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x2, [sp, #24] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x3, [sp, #32] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x4, [sp, #40] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x5, [sp, #48] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x6, [sp, #56] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    ldr x7, [sp, #64] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x21
 ; CHECK-O0-AARCH64-NEXT:    ldr x21, [sp, #72] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-104] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-120] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    bl _params_and_return_in_reg2
 ; CHECK-O0-AARCH64-NEXT:    ldr x20, [sp, #80] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x0
 ; CHECK-O0-AARCH64-NEXT:    ldr x0, [sp, #88] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-96] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-112] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x1
 ; CHECK-O0-AARCH64-NEXT:    ldr x1, [sp, #96] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-88] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-104] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x2
 ; CHECK-O0-AARCH64-NEXT:    ldr x2, [sp, #104] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-80] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-96] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x3
 ; CHECK-O0-AARCH64-NEXT:    ldr x3, [sp, #112] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-72] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-88] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x4
 ; CHECK-O0-AARCH64-NEXT:    ldr x4, [sp, #120] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-64] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-80] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x5
 ; CHECK-O0-AARCH64-NEXT:    ldr x5, [sp, #128] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-56] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-72] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x6
-; CHECK-O0-AARCH64-NEXT:    ldur x6, [x29, #-120] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-48] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    ldr x6, [sp, #136] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-64] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x7
-; CHECK-O0-AARCH64-NEXT:    ldur x7, [x29, #-112] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-40] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    ldur x7, [x29, #-128] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-56] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x21
-; CHECK-O0-AARCH64-NEXT:    ldur x21, [x29, #-104] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-32] ; 8-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    ldur x21, [x29, #-120] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    stur x8, [x29, #-48] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    bl _params_in_reg2
-; CHECK-O0-AARCH64-NEXT:    ldur x0, [x29, #-96] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldur x1, [x29, #-88] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldur x2, [x29, #-80] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldur x3, [x29, #-72] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldur x4, [x29, #-64] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldur x5, [x29, #-56] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldur x6, [x29, #-48] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldur x7, [x29, #-40] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldur x0, [x29, #-112] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldur x1, [x29, #-104] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldur x2, [x29, #-96] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldur x3, [x29, #-88] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldur x4, [x29, #-80] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldur x5, [x29, #-72] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldur x6, [x29, #-64] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldur x7, [x29, #-56] ; 8-byte Folded Reload
 ; CHECK-O0-AARCH64-NEXT:    mov x8, x21
-; CHECK-O0-AARCH64-NEXT:    ldur x21, [x29, #-32] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #256] ; 16-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldp x28, x20, [sp, #240] ; 16-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    add sp, sp, #272
+; CHECK-O0-AARCH64-NEXT:    ldur x21, [x29, #-48] ; 8-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #272] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x20, x19, [sp, #256] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp, #240] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    add sp, sp, #288
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: params_and_return_in_reg:
 ; CHECK-O0-ARM64_32:       ; %bb.0:
-; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #272
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 272
-; CHECK-O0-ARM64_32-NEXT:    str x28, [sp, #240] ; 8-byte Folded Spill
-; CHECK-O0-ARM64_32-NEXT:    stp x20, x30, [sp, #256] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #288
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 288
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #240] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    stp x20, x19, [sp, #256] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    stp x29, x30, [sp, #272] ; 16-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -8
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w20, -16
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w28, -32
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w19, -24
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w20, -32
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -40
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -48
 ; CHECK-O0-ARM64_32-NEXT:    str x21, [sp, #72] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x20, [sp] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x7, [sp, #64] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x6, [sp, #56] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x5, [sp, #48] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x4, [sp, #40] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x3, [sp, #32] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    str x2, [sp, #24] ; 8-byte Folded Spill

 ; CHECK-O0-ARM64_32-NEXT:    ldr x2, [sp, #176] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ldr x3, [sp, #184] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ldr x4, [sp, #192] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ldr x5, [sp, #200] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ldr x6, [sp, #208] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    ldr x7, [sp, #216] ; 8-byte Folded Reload
 ; CHECK-O0-ARM64_32-NEXT:    mov x8, x21
 ; CHECK-O0-ARM64_32-NEXT:    ldr x21, [sp, #224] ; 8-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    ldp x20, x30, [sp, #256] ; 16-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    ldr x28, [sp, #240] ; 8-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #272
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #272] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x20, x19, [sp, #256] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp, #240] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #288
 ; CHECK-O0-ARM64_32-NEXT:    ret
   %error_ptr_ref = alloca swifterror ptr, align 8
   store ptr null, ptr %error_ptr_ref
   call swiftcc void @params_in_reg2(i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, ptr swiftself null, ptr nocapture swifterror %error_ptr_ref)
   %val = call swiftcc  { i64, i64, i64, i64, i64, i64, i64, i64 } @params_and_return_in_reg2(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7, ptr swiftself %8, ptr nocapture swifterror %err)
   call swiftcc void @params_in_reg2(i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, ptr swiftself null, ptr nocapture swifterror %error_ptr_ref)
   ret { i64, i64, i64, i64, i64, i64, i64, i64 } %val
 }
 
 declare swiftcc { i64, i64, i64, i64, i64, i64, i64, i64 } @params_and_return_in_reg2(i64, i64, i64, i64, i64, i64, i64, i64, ptr swiftself, ptr nocapture swifterror %err)
 
 declare void @acallee(ptr)
 
 ; Make sure we don't tail call if the caller returns a swifterror value. We
 ; would have to move into the swifterror register before the tail call.
 define swiftcc void @tailcall_from_swifterror(ptr swifterror %error_ptr_ref) {
 ; CHECK-APPLE-LABEL: tailcall_from_swifterror:
 ; CHECK-APPLE:       ; %bb.0: ; %entry
-; CHECK-APPLE-NEXT:    str x19, [sp, #-32]! ; 8-byte Folded Spill
-; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 32
-; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
-; CHECK-APPLE-NEXT:    add x29, sp, #16
+; CHECK-APPLE-NEXT:    stp x22, x21, [sp, #-48]! ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    .cfi_def_cfa_offset 48
+; CHECK-APPLE-NEXT:    stp x20, x19, [sp, #16] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-APPLE-NEXT:    add x29, sp, #32
 ; CHECK-APPLE-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-APPLE-NEXT:    .cfi_offset w30, -8
 ; CHECK-APPLE-NEXT:    .cfi_offset w29, -16
-; CHECK-APPLE-NEXT:    .cfi_offset w19, -32
+; CHECK-APPLE-NEXT:    .cfi_offset w19, -24
+; CHECK-APPLE-NEXT:    .cfi_offset w20, -32
+; CHECK-APPLE-NEXT:    .cfi_offset w21, -40
+; CHECK-APPLE-NEXT:    .cfi_offset w22, -48
 ; CHECK-APPLE-NEXT:    mov x19, x21
 ; CHECK-APPLE-NEXT:    mov x0, xzr
 ; CHECK-APPLE-NEXT:    bl _acallee
 ; CHECK-APPLE-NEXT:    mov x21, x19
-; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
-; CHECK-APPLE-NEXT:    ldr x19, [sp], #32 ; 8-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x20, x19, [sp, #16] ; 16-byte Folded Reload
+; CHECK-APPLE-NEXT:    ldp x22, xzr, [sp], #48 ; 16-byte Folded Reload
 ; CHECK-APPLE-NEXT:    ret
 ;
 ; CHECK-O0-AARCH64-LABEL: tailcall_from_swifterror:
 ; CHECK-O0-AARCH64:       ; %bb.0: ; %entry
-; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #32
-; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 32
-; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
-; CHECK-O0-AARCH64-NEXT:    add x29, sp, #16
+; CHECK-O0-AARCH64-NEXT:    sub sp, sp, #48
+; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa_offset 48
+; CHECK-O0-AARCH64-NEXT:    stp x22, x21, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-AARCH64-NEXT:    add x29, sp, #32
 ; CHECK-O0-AARCH64-NEXT:    .cfi_def_cfa w29, 16
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w30, -8
 ; CHECK-O0-AARCH64-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-AARCH64-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-AARCH64-NEXT:    str x21, [sp, #8] ; 8-byte Folded Spill
 ; CHECK-O0-AARCH64-NEXT:    mov x0, xzr
 ; CHECK-O0-AARCH64-NEXT:    bl _acallee
 ; CHECK-O0-AARCH64-NEXT:    ldr x21, [sp, #8] ; 8-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
-; CHECK-O0-AARCH64-NEXT:    add sp, sp, #32
+; CHECK-O0-AARCH64-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-AARCH64-NEXT:    add sp, sp, #48
 ; CHECK-O0-AARCH64-NEXT:    ret
 ;
 ; CHECK-O0-ARM64_32-LABEL: tailcall_from_swifterror:
 ; CHECK-O0-ARM64_32:       ; %bb.0: ; %entry
-; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #32
-; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 32
-; CHECK-O0-ARM64_32-NEXT:    str x30, [sp, #16] ; 8-byte Folded Spill
-; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -16
+; CHECK-O0-ARM64_32-NEXT:    sub sp, sp, #48
+; CHECK-O0-ARM64_32-NEXT:    .cfi_def_cfa_offset 48
+; CHECK-O0-ARM64_32-NEXT:    stp x22, x21, [sp, #16] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w30, -8
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w29, -16
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w21, -24
+; CHECK-O0-ARM64_32-NEXT:    .cfi_offset w22, -32
 ; CHECK-O0-ARM64_32-NEXT:    str x21, [sp, #8] ; 8-byte Folded Spill
 ; CHECK-O0-ARM64_32-NEXT:    mov x0, xzr
 ; CHECK-O0-ARM64_32-NEXT:    bl _acallee
 ; CHECK-O0-ARM64_32-NEXT:    ldr x21, [sp, #8] ; 8-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    ldr x30, [sp, #16] ; 8-byte Folded Reload
-; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #32
+; CHECK-O0-ARM64_32-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    ldp x22, xzr, [sp, #16] ; 16-byte Folded Reload
+; CHECK-O0-ARM64_32-NEXT:    add sp, sp, #48
 ; CHECK-O0-ARM64_32-NEXT:    ret
 entry:
   tail call void @acallee(ptr null)
   ret void
 }
 
 declare swiftcc void @foo2(ptr swifterror)