// AIX assembler does not support cfi directives.
const bool needsCFI = MF.needsFrameMoves() && !Subtarget.isAIXABI();
+ const bool HasFastMFLR = Subtarget.hasFastMFLR();
+
// Get processor type.
bool isPPC64 = Subtarget.isPPC64();
// Get the ABI.
// Generate the instruction to store the LR. In the case where ROP protection
// is required the register holding the LR should not be killed as it will be
// used by the hash store instruction.
- if (MustSaveLR) {
+ auto SaveLR = [&](int64_t Offset) {
+ assert(MustSaveLR && "LR is not required to be saved!");
BuildMI(MBB, StackUpdateLoc, dl, StoreInst)
.addReg(ScratchReg, getKillRegState(!HasROPProtect))
- .addImm(LROffset)
+ .addImm(Offset)
.addReg(SPReg);
// Add the ROP protection Hash Store instruction.
.addImm(ImmOffset)
.addReg(SPReg);
}
- }
+ };
+
+ if (MustSaveLR && HasFastMFLR)
+ SaveLR(LROffset);
if (MustSaveCR &&
!(SingleScratchReg && MustSaveLR)) {
}
// Skip the rest if this is a leaf function & all spills fit in the Red Zone.
- if (!FrameSize)
+ if (!FrameSize) {
+ if (MustSaveLR && !HasFastMFLR)
+ SaveLR(LROffset);
return;
+ }
// Adjust stack pointer: r1 += NegFrameSize.
// If there is a preferred stack alignment, align R1 now
// Have we generated a STUX instruction to claim stack frame? If so,
// the negated frame size will be placed in ScratchReg.
- bool HasSTUX = false;
+ bool HasSTUX =
+ (TLI.hasInlineStackProbe(MF) && FrameSize > TLI.getStackProbeSize(MF)) ||
+ (HasBP && MaxAlign > 1) || isLargeFrame;
+
+ // If we use STUX to update the stack pointer, we need the two scratch
+ // registers TempReg and ScratchReg, we have to save LR here which is stored
+ // in ScratchReg.
+ if (HasSTUX && MustSaveLR && !HasFastMFLR)
+ SaveLR(LROffset);
// If FrameSize <= TLI.getStackProbeSize(MF), as POWER ABI requires backchain
// pointer is always stored at SP, we will get a free probe due to an essential
BuildMI(MBB, MBBI, dl, TII.get(PPC::SUBF), ScratchReg)
.addReg(ScratchReg)
.addReg(SPReg);
- HasSTUX = true;
}
} else {
// This condition must be kept in sync with canUseAsPrologue.
.addReg(SPReg, RegState::Kill)
.addReg(SPReg)
.addReg(ScratchReg);
- HasSTUX = true;
-
} else if (!isLargeFrame) {
BuildMI(MBB, StackUpdateLoc, dl, StoreUpdtInst, SPReg)
.addReg(SPReg)
.addImm(NegFrameSize)
.addReg(SPReg);
-
} else {
TII.materializeImmPostRA(MBB, MBBI, dl, ScratchReg, NegFrameSize);
BuildMI(MBB, MBBI, dl, StoreUpdtIdxInst, SPReg)
.addReg(SPReg, RegState::Kill)
.addReg(SPReg)
.addReg(ScratchReg);
- HasSTUX = true;
}
}
}
}
+ // Save the LR now.
+ if (!HasSTUX && MustSaveLR && !HasFastMFLR)
+ SaveLR(LROffset + FrameSize);
+
// Add Call Frame Information for the instructions we generated above.
if (needsCFI) {
unsigned CFIIndex;
; CHECK-LABEL: main:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -16(1)
+; CHECK-NEXT: stw 0, 20(1)
; CHECK-NEXT: .cfi_def_cfa_offset 16
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: bl foo
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
; CHECK-NEXT: std 31, -8(1)
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -176(1)
+; CHECK-NEXT: std 0, 192(1)
; CHECK-NEXT: .cfi_def_cfa_offset 176
; CHECK-NEXT: .cfi_offset r31, -8
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-LABEL: __fixunstfdi:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -464(1)
; CHECK-NEXT: mfcr 12
-; CHECK-NEXT: stw 29, 412(1) # 4-byte Folded Spill
+; CHECK-NEXT: stw 0, 468(1)
; CHECK-NEXT: lis 3, .LCPI0_0@ha
+; CHECK-NEXT: stw 29, 412(1) # 4-byte Folded Spill
; CHECK-NEXT: stw 30, 416(1) # 4-byte Folded Spill
; CHECK-NEXT: stw 12, 408(1)
; CHECK-NEXT: stfd 2, 376(1)
; CHECK-LABEL: g:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -16(1)
+; CHECK-NEXT: stw 0, 20(1)
; CHECK-NEXT: lwz 3, 0(1)
; CHECK-NEXT: lwz 3, 0(3)
; CHECK-NEXT: lwz 3, 4(3)
; CHECK-PWR8-NEXT: .cfi_offset r15, -136
; CHECK-PWR8-NEXT: std r14, -144(r1) # 8-byte Folded Spill
; CHECK-PWR8-NEXT: std r15, -136(r1) # 8-byte Folded Spill
-; CHECK-PWR8-NEXT: std r0, 16(r1)
; CHECK-PWR8-NEXT: stdu r1, -176(r1)
; CHECK-PWR8-NEXT: #APP
; CHECK-PWR8-NEXT: add r3, r3, r4
; CHECK-PWR8-NEXT: #NO_APP
+; CHECK-PWR8-NEXT: std r0, 192(r1)
; CHECK-PWR8-NEXT: extsw r3, r3
; CHECK-PWR8-NEXT: bl callee
; CHECK-PWR8-NEXT: nop
; CHECK-PWR9-NEXT: .cfi_offset r15, -136
; CHECK-PWR9-NEXT: std r14, -144(r1) # 8-byte Folded Spill
; CHECK-PWR9-NEXT: std r15, -136(r1) # 8-byte Folded Spill
-; CHECK-PWR9-NEXT: std r0, 16(r1)
; CHECK-PWR9-NEXT: stdu r1, -176(r1)
; CHECK-PWR9-NEXT: #APP
; CHECK-PWR9-NEXT: add r3, r3, r4
; CHECK-PWR9-NEXT: #NO_APP
; CHECK-PWR9-NEXT: extsw r3, r3
+; CHECK-PWR9-NEXT: std r0, 192(r1)
; CHECK-PWR9-NEXT: bl callee
; CHECK-PWR9-NEXT: nop
; CHECK-PWR9-NEXT: addi r1, r1, 176
; CHECK-PWR8-NEXT: .cfi_offset f15, -136
; CHECK-PWR8-NEXT: stfd f14, -144(r1) # 8-byte Folded Spill
; CHECK-PWR8-NEXT: stfd f15, -136(r1) # 8-byte Folded Spill
-; CHECK-PWR8-NEXT: std r0, 16(r1)
; CHECK-PWR8-NEXT: stdu r1, -176(r1)
; CHECK-PWR8-NEXT: #APP
; CHECK-PWR8-NEXT: add r3, r3, r4
; CHECK-PWR8-NEXT: #NO_APP
+; CHECK-PWR8-NEXT: std r0, 192(r1)
; CHECK-PWR8-NEXT: extsw r3, r3
; CHECK-PWR8-NEXT: bl callee
; CHECK-PWR8-NEXT: nop
; CHECK-PWR9-NEXT: .cfi_offset f15, -136
; CHECK-PWR9-NEXT: stfd f14, -144(r1) # 8-byte Folded Spill
; CHECK-PWR9-NEXT: stfd f15, -136(r1) # 8-byte Folded Spill
-; CHECK-PWR9-NEXT: std r0, 16(r1)
; CHECK-PWR9-NEXT: stdu r1, -176(r1)
; CHECK-PWR9-NEXT: #APP
; CHECK-PWR9-NEXT: add r3, r3, r4
; CHECK-PWR9-NEXT: #NO_APP
; CHECK-PWR9-NEXT: extsw r3, r3
+; CHECK-PWR9-NEXT: std r0, 192(r1)
; CHECK-PWR9-NEXT: bl callee
; CHECK-PWR9-NEXT: nop
; CHECK-PWR9-NEXT: addi r1, r1, 176
; CHECK-PWR8-LABEL: caller3:
; CHECK-PWR8: # %bb.0: # %entry
; CHECK-PWR8-NEXT: mflr r0
-; CHECK-PWR8-NEXT: std r0, 16(r1)
; CHECK-PWR8-NEXT: stdu r1, -240(r1)
+; CHECK-PWR8-NEXT: std r0, 256(r1)
; CHECK-PWR8-NEXT: .cfi_def_cfa_offset 240
; CHECK-PWR8-NEXT: .cfi_offset lr, 16
; CHECK-PWR8-NEXT: .cfi_offset v20, -192
; CHECK-PWR9-LABEL: caller3:
; CHECK-PWR9: # %bb.0: # %entry
; CHECK-PWR9-NEXT: mflr r0
-; CHECK-PWR9-NEXT: std r0, 16(r1)
; CHECK-PWR9-NEXT: stdu r1, -224(r1)
+; CHECK-PWR9-NEXT: std r0, 240(r1)
; CHECK-PWR9-NEXT: .cfi_def_cfa_offset 224
; CHECK-PWR9-NEXT: .cfi_offset lr, 16
; CHECK-PWR9-NEXT: .cfi_offset v20, -192
; CHECK-PWR8-LABEL: caller4:
; CHECK-PWR8: # %bb.0: # %entry
; CHECK-PWR8-NEXT: mflr r0
-; CHECK-PWR8-NEXT: std r0, 16(r1)
; CHECK-PWR8-NEXT: stdu r1, -240(r1)
+; CHECK-PWR8-NEXT: std r0, 256(r1)
; CHECK-PWR8-NEXT: .cfi_def_cfa_offset 240
; CHECK-PWR8-NEXT: .cfi_offset lr, 16
; CHECK-PWR8-NEXT: .cfi_offset v20, -192
; CHECK-PWR9-LABEL: caller4:
; CHECK-PWR9: # %bb.0: # %entry
; CHECK-PWR9-NEXT: mflr r0
-; CHECK-PWR9-NEXT: std r0, 16(r1)
; CHECK-PWR9-NEXT: stdu r1, -224(r1)
+; CHECK-PWR9-NEXT: std r0, 240(r1)
; CHECK-PWR9-NEXT: .cfi_def_cfa_offset 224
; CHECK-PWR9-NEXT: .cfi_offset lr, 16
; CHECK-PWR9-NEXT: .cfi_offset v20, -192
; CHECK-PWR8-LABEL: caller_mixed:
; CHECK-PWR8: # %bb.0: # %entry
; CHECK-PWR8-NEXT: mflr r0
-; CHECK-PWR8-NEXT: std r0, 16(r1)
; CHECK-PWR8-NEXT: stdu r1, -528(r1)
+; CHECK-PWR8-NEXT: std r0, 544(r1)
; CHECK-PWR8-NEXT: .cfi_def_cfa_offset 528
; CHECK-PWR8-NEXT: .cfi_offset lr, 16
; CHECK-PWR8-NEXT: .cfi_offset r14, -288
; CHECK-PWR9-LABEL: caller_mixed:
; CHECK-PWR9: # %bb.0: # %entry
; CHECK-PWR9-NEXT: mflr r0
-; CHECK-PWR9-NEXT: std r0, 16(r1)
; CHECK-PWR9-NEXT: stdu r1, -512(r1)
+; CHECK-PWR9-NEXT: std r0, 528(r1)
; CHECK-PWR9-NEXT: .cfi_def_cfa_offset 512
; CHECK-PWR9-NEXT: .cfi_offset lr, 16
; CHECK-PWR9-NEXT: .cfi_offset r14, -288
; PPC32-LINUX-LABEL: foo
; PPC32-LINUX: mflr 0
-; PPC32-LINUX: stw 0, 4(1)
; PPC32-LINUX: stwu 1, -32(1)
; PPC32-LINUX: stw 31, 28(1)
+; PPC32-LINUX: stw 0, 36(1)
; PPC32-LINUX: mr 31, 1
; PPC32-LINUX: addi 3, 31, 32
; PPC32-LINUX: stwux 3, 1, 10
; PPC32-LINUX: blr
; PPC64-LABEL: foo
-; PPC64: mflr 0
-; PPC64: std 31, -8(1)
-; PPC64: std 0, 16(1)
-; PPC64: stdu 1, -160(1)
-; PPC64: mr 31, 1
-; PPC64: addi 3, 31, 160
-; PPC64: stdux 3, 1, 10
+; PPC64: mflr 0
+; PPC64: std 31, -8(1)
+; PPC64: stdu 1, -160(1)
+; PPC64-DAG: mr 31, 1
+; PPC64-DAG: std 0, 176(1)
+; PPC64: addi 3, 31, 160
+; PPC64: stdux 3, 1, 10
; Allocated area is referred by stack pointer.
; PPC64: addi 11, 1, 128
; PPC32-AIX: mflr 0
; PPC32-AIX: stw 31, -4(1)
-; PPC32-AIX: stw 0, 8(1)
; PPC32-AIX: stwu 1, -80(1)
; PPC32-AIX: mr 31, 1
+; PPC32-AIX: stw 0, 88(1)
; PPC32-AIX: addi 3, 31, 80
; PPC32-AIX: stwux 3, 1, 10
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
; CHECK-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -48(1)
; CHECK-NEXT: std 2, 24(1)
+; CHECK-NEXT: std 0, 64(1)
; CHECK-NEXT: mr 30, 3
; CHECK-NEXT: ld 12, 0(3)
; CHECK-NEXT: mtctr 12
; CHECK-LE-LABEL: test_Array:
; CHECK-LE: # %bb.0: # %entry
; CHECK-LE-NEXT: mflr r0
-; CHECK-LE-NEXT: std r0, 16(r1)
; CHECK-LE-NEXT: stdu r1, -176(r1)
; CHECK-LE-NEXT: addis r4, r2, Arr1@toc@ha
; CHECK-LE-NEXT: li r3, 0
+; CHECK-LE-NEXT: std r0, 192(r1)
; CHECK-LE-NEXT: li r6, 65
; CHECK-LE-NEXT: addi r5, r1, 46
; CHECK-LE-NEXT: addi r4, r4, Arr1@toc@l
; CHECK-BE-LABEL: test_Array:
; CHECK-BE: # %bb.0: # %entry
; CHECK-BE-NEXT: mflr r0
-; CHECK-BE-NEXT: std r0, 16(r1)
; CHECK-BE-NEXT: stdu r1, -256(r1)
; CHECK-BE-NEXT: addis r5, r2, Arr1@toc@ha
; CHECK-BE-NEXT: li r3, 0
; CHECK-BE-NEXT: addi r5, r5, Arr1@toc@l
+; CHECK-BE-NEXT: std r0, 272(r1)
; CHECK-BE-NEXT: addi r4, r1, 126
; CHECK-BE-NEXT: li r6, 65
; CHECK-BE-NEXT: stw r3, 124(r1)
; CHECK-LABEL: main:
; CHECK: # %bb.0: # %L.entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -48(1)
; CHECK-NEXT: li 3, -32477
+; CHECK-NEXT: std 0, 64(1)
; CHECK-NEXT: li 4, 234
; CHECK-NEXT: addi 6, 1, 46
; CHECK-NEXT: sth 3, 46(1)
; CHECK-P7-LABEL: main:
; CHECK-P7: # %bb.0: # %L.entry
; CHECK-P7-NEXT: mflr 0
-; CHECK-P7-NEXT: std 0, 16(1)
; CHECK-P7-NEXT: stdu 1, -48(1)
; CHECK-P7-NEXT: li 3, -32477
; CHECK-P7-NEXT: lis 5, 0
; CHECK-P7-NEXT: addi 4, 1, 46
; CHECK-P7-NEXT: li 7, 0
+; CHECK-P7-NEXT: std 0, 64(1)
; CHECK-P7-NEXT: sth 3, 46(1)
; CHECK-P7-NEXT: li 6, 234
-; CHECK-P7-NEXT: ori 5, 5, 33059
; CHECK-P7-NEXT: rlwinm 3, 4, 3, 27, 27
+; CHECK-P7-NEXT: ori 5, 5, 33059
; CHECK-P7-NEXT: ori 7, 7, 65535
; CHECK-P7-NEXT: sync
; CHECK-P7-NEXT: slw 6, 6, 3
; ASM32PWR4: stwu 1, -128(1)
; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C2(2)
+; ASM32PWR4-NEXT: stw 0, 136(1)
; ASM32PWR4-NEXT: lfd 1, 0([[REG]])
; ASM32PWR4-DAG: stfd 1, 56(1)
; ASM32PWR4-DAG: stfd 1, 64(1)
; ASM64PWR4: stdu 1, -160(1)
; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C2(2)
+; ASM64PWR4-NEXT: std 0, 176(1)
; ASM64PWR4-NEXT: lfd 1, 0([[REG]])
; ASM64PWR4-DAG: stfd 1, 112(1)
; ASM64PWR4-DAG: stfd 1, 120(1)
; ASM32PWR4: stwu 1, -80(1)
; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C1(2)
+; ASM32PWR4-NEXT: stw 0, 88(1)
; ASM32PWR4-NEXT: lfs 1, 0([[REG]])
; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C2(2)
; ASM32PWR4-NEXT: stfd 1, 64(1)
; ASM64PWR4: stdu 1, -128(1)
; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C1(2)
+; ASM64PWR4-NEXT: std 0, 144(1)
; ASM64PWR4-NEXT: lfs 1, 0([[REG]])
; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C2(2)
; ASM64PWR4-NEXT: stfd 1, 112(1)
; ASM32PWR4: stwu 1, -80(1)
; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C1(2)
+; ASM32PWR4-NEXT: stw 0, 88(1)
; ASM32PWR4-NEXT: li 6, 42
; ASM32PWR4-NEXT: lfs 1, 0([[REG]])
; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C2(2)
; ASM64PWR4: stdu 1, -128(1)
; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C1(2)
+; ASM64PWR4-NEXT: std 0, 144(1)
; ASM64PWR4-NEXT: li 5, 42
; ASM64PWR4-NEXT: lfs 1, 0([[REG]])
; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C2(2)
; ASM64PWR4: stdu 1, -128(1)
; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C1(2)
+; ASM64PWR4-NEXT: std 0, 144(1)
; ASM64PWR4-NEXT: li 5, 42
; ASM64PWR4-NEXT: lfs 1, 0([[REG]])
; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C2(2)
; ASM32PWR4: stwu 1, -64(1)
; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C1(2)
+; ASM32PWR4-NEXT: stw 0, 72(1)
; ASM32PWR4-NEXT: lfs 1, 0([[REG]])
; ASM32PWR4-NEXT: li 3, 42
; ASM32PWR4-NEXT: stfs 1, 60(1)
; ASM64PWR4: stdu 1, -128(1)
; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C1(2)
+; ASM64PWR4-NEXT: std 0, 144(1)
; ASM64PWR4-NEXT: lfs 1, 0([[REG]])
; ASM64PWR4-NEXT: li 3, 42
; ASM64PWR4-NEXT: stfs 1, 124(1)
; CHECKASM-LABEL: .caller_ints_stack:
; ASM32PWR4: mflr 0
-; ASM32PWR4-DAG: stw 0, 8(1)
-; ASM32PWR4-DAG: stwu 1, -96(1)
+; ASM32PWR4-NEXT: stwu 1, -96(1)
+; ASM32PWR4-DAG: stw 0, 104(1)
; ASM32PWR4-DAG: li 3, 1
; ASM32PWR4-DAG: li 4, 2
; ASM32PWR4-DAG: li 5, 3
; ASM32PWR4-NEXT: blr
; ASM64PWR4: mflr 0
-; ASM64PWR4-DAG: std 0, 16(1)
-; ASM64PWR4-DAG: stdu 1, -176(1)
+; ASM64PWR4-NEXT: stdu 1, -176(1)
+; ASM64PWR4-DAG: std 0, 192(1)
; ASM64PWR4-DAG: li 3, 1
; ASM64PWR4-DAG: li 4, 2
; ASM64PWR4-DAG: li 5, 3
; CHECKASM-LABEL: .caller_fpr_stack:
; ASM32PWR4: mflr 0
-; ASM32PWR4-DAG: stw 0, 8(1)
-; ASM32PWR4-DAG: stwu 1, -144(1)
+; ASM32PWR4-NEXT: stwu 1, -144(1)
+; ASM32PWR4-DAG: stw 0, 152(1)
; ASM32PWR4-DAG: lwz [[REGF1ADDR:[0-9]+]], L..C20(2)
; ASM32PWR4-DAG: lwz [[REGF1:[0-9]+]], 0([[REGF1ADDR]])
; ASM32PWR4-DAG: lwz [[REGDADDR:[0-9]+]], L..C19(2)
; ASM32PWR4-NEXT: bl .test_fpr_stack
; ASM64PWR4: mflr 0
-; ASM64PWR4-DAG: std 0, 16(1)
-; ASM64PWR4-DAG: stdu 1, -176(1)
+; ASM64PWR4-NEXT: stdu 1, -176(1)
+; ASM64PWR4-DAG: std 0, 192(1)
; ASM64PWR4-DAG: ld [[REGF1ADDR:[0-9]+]], L..C18(2)
; ASM64PWR4-DAG: lwz [[REGF1:[0-9]+]], 0([[REGF1ADDR]])
; ASM64PWR4-DAG: ld [[REGDADDR:[0-9]+]], L..C19(2)
; CHEKASM-LABEL: .mix_floats_caller:
; ASM32PWR4: mflr 0
-; ASM32PWR4-DAG: stw 0, 8(1)
-; ASM32PWR4-DAG: stwu 1, -176(1)
+; ASM32PWR4-NEXT: stwu 1, -176(1)
+; ASM32PWR4-DAG: stw 0, 184(1)
; ASM32PWR4-DAG: stw [[REG:[0-9]+]], 56(1)
; ASM32PWR4-DAG: stw [[REG:[0-9]+]], 60(1)
; ASM32PWR4-DAG: stw [[REG:[0-9]+]], 64(1)
; ASM32PWR4: bl .mix_floats
; ASM64PWR4: mflr 0
-; ASM64PWR4-DAG: std 0, 16(1)
-; ASM64PWR4-DAG: stdu 1, -240(1)
+; ASM64PWR4-NEXT: stdu 1, -240(1)
+; ASM64PWR4-DAG: std 0, 256(1)
; ASM64PWR4-DAG: std [[REG:[0-9]+]], 112(1)
; ASM64PWR4-DAG: std [[REG:[0-9]+]], 120(1)
; ASM64PWR4-DAG: std [[REG:[0-9]+]], 128(1)
; ASM32BIT-DAG: addi 3, 1, 56
; ASM32BIT-DAG: lwz 4, L..C{{[0-9]+}}(2)
; ASM32BIT-DAG: li 5, 256
+; ASM32BIT-DAG: stw 0, 328(1)
; ASM32BIT-NEXT: bl .memcpy[PR]
; ASM32BIT: bl .test_byval_mem2
; ASM32BIT: addi 1, 1, 320
; ASM64BIT-DAG: addi 3, 1, 112
; ASM64BIT-DAG: ld 4, L..C{{[0-9]+}}(2)
; ASM64BIT-DAG: li 5, 256
+; ASM64BIT-DAG: std 0, 384(1)
; ASM64BIT-NEXT: bl .memcpy[PR]
; ASM64BIT: bl .test_byval_mem2
; ASM64BIT: addi 1, 1, 368
; 32BIT-NEXT: ADJCALLSTACKUP 316, 0, implicit-def dead $r1, implicit $r1
; ASM32BIT: stwu 1, -320(1)
-; ASM32BIT-NEXT: stw [[REG1:[0-9]+]], {{[0-9]+}}(1)
-; ASM32BIT: lwz [[REG1]], L..C{{[0-9]+}}(2)
+; ASM32BIT-NEXT: stw 0, 328(1)
+; ASM32BIT-DAG: stw [[REG1:[0-9]+]], {{[0-9]+}}(1)
+; ASM32BIT-DAG: lwz [[REG1]], L..C{{[0-9]+}}(2)
; ASM32BIT-DAG: lhz [[REG2:[0-9]+]], 28([[REG1]])
; ASM32BIT-DAG: sth [[REG2]], 56(1)
; ASM32BIT-DAG: lbz [[REG3:[0-9]+]], 30([[REG1]])
; ASM32: stwu 1, -64(1)
; ASM32-NEXT: lwz [[REG:[0-9]+]], L..C{{[0-9]+}}(2)
+; ASM32-NEXT: stw 0, 72(1)
; ASM32-NEXT: lbz 3, 0([[REG]])
; ASM32-NEXT: slwi 3, 3, 24
; ASM32-NEXT: bl .test_byval_1Byte
; 64BIT-NEXT: BL8_NOP <mcsymbol .test_byval_1Byte>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x2, implicit-def $r1
; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
-; ASM64: std 0, 16(1)
-; ASM64-NEXT: stdu 1, -128(1)
+; ASM64: stdu 1, -128(1)
; ASM64-NEXT: ld [[REG:[0-9]+]], L..C{{[0-9]+}}(2)
+; ASM64-NEXT: std 0, 144(1)
; ASM64-NEXT: lbz 3, 0([[REG]])
; ASM64-NEXT: sldi 3, 3, 56
; ASM64-NEXT: bl .test_byval_1Byte
; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
-; ASM64: std 0, 16(1)
-; ASM64-NEXT: stdu 1, -112(1)
+; ASM64: stdu 1, -112(1)
+; ASM64-DAG: std 0, 128(1)
; ASM64-DAG: li 3, 42
; ASM64-DAG: ld [[REG1:[0-9]+]], L..C{{[0-9]+}}(2)
; ASM64-DAG: lfs 1, 0([[REG1]])
; ASM64: stdu 1, -112(1)
; ASM64-NEXT: ld [[REGADDR:[0-9]+]], L..C{{[0-9]+}}(2)
+; ASM64-NEXT: std 0, 128(1)
; ASM64-NEXT: ld 3, 0([[REGADDR]])
; ASM64-NEXT: bl .test_byval_8Byte[PR]
; ASM64-NEXT: nop
; ASM-LABEL: .vec_caller:
; ASM32: # %bb.0: # %entry
; ASM32-DAG: mflr 0
-; ASM32-DAG: stw 0, 8(1)
; ASM32-DAG: stwu 1, -64(1)
; ASM32-DAG: lwz [[REG1:[0-9]+]], L..C0(2)
; ASM32-DAG: lxvw4x 34, 0, [[REG1]]
; ASM32-DAG: lxvw4x 44, 0, [[REG11]]
; ASM32-DAG: lwz [[REG12:[0-9]+]], L..C11(2)
; ASM32-DAG: lxvw4x 45, 0, [[REG12]]
+; ASM32-DAG: stw 0, 72(1)
; ASM32-DAG: bl .vec_callee
; ASM32-DAG: li 3, 0
; ASM32-DAG: addi 1, 1, 64
; ASM32: blr
; ASM64: # %entry
-; ASM64-DAG: std 0, 16(1)
; ASM64-DAG: stdu 1, -112(1)
; ASM64-DAG: ld [[REG1:[0-9]+]], L..C0(2)
; ASM64-DAG: lxvw4x 34, 0, [[REG1]]
; ASM64-DAG: lxvw4x 44, 0, [[REG11]]
; ASM64-DAG: ld [[REG12:[0-9]+]], L..C11(2)
; ASM64-DAG: lxvw4x 45, 0, [[REG12]]
+; ASM64-DAG: std 0, 128(1)
; ASM64-DAG: bl .vec_callee
; ASM64-DAG: li 3, 0
; ASM64-DAG: addi 1, 1, 112
; 64BIT-LABEL: .killOne:
-; 64BIT: mflr 0
-; 64BIT-NEXT: std 0, 16(1)
-; 64BIT-NEXT: mfcr 12
+; 64BIT: mfcr 12
; 64BIT-NEXT: stw 12, 8(1)
-; 64BIT: stdu 1, -112(1)
+; 64BIT-NEXT: mflr 0
+; 64BIT-NEXT: stdu 1, -112(1)
+; 64BIT: std 0, 128(1)
; 64BIT: # Clobber CR
; 64BIT: bl .do_something
; 32BIT-LABEL: .killOne:
-; 32BIT: mflr 0
-; 32BIT-NEXT: stw 0, 8(1)
-; 32BIT-NEXT: mfcr 12
+; 32BIT: mfcr 12
; 32BIT-NEXT: stw 12, 4(1)
-; 32BIT: stwu 1, -64(1)
+; 32BIT-NEXT: mflr 0
+; 32BIT-NEXT: stwu 1, -64(1)
+; 32BIT: stw 0, 72(1)
; 32BIT: # Clobber CR
; 32BIT: bl .do_something
; MIR64: liveins: $x3, $x14, $x25, $x31, $f14, $f19, $f21, $f31
; MIR64: $x0 = MFLR8 implicit $lr8
-; MIR64-NEXT: STD killed $x0, 16, $x1
; MIR64-NEXT: $x1 = STDU $x1, -400, $x1
+; MIR64-NEXT: STD killed $x0, 416, $x1
; MIR64-DAG: STD killed $x14, 112, $x1 :: (store (s64) into %fixed-stack.6, align 16)
; MIR64-DAG: STD killed $x25, 200, $x1 :: (store (s64) into %fixed-stack.5)
; MIR64-DAG: STD killed $x31, 248, $x1 :: (store (s64) into %fixed-stack.4)
; MIR32: liveins: $r3, $r13, $r14, $r25, $r31, $f14, $f19, $f21, $f31
; MIR32: $r0 = MFLR implicit $lr
-; MIR32-NEXT: STW killed $r0, 8, $r1
; MIR32-NEXT: $r1 = STWU $r1, -288, $r1
+; MIR32-NEXT: STW killed $r0, 296, $r1
; MIR32-DAG: STW killed $r13, 68, $r1 :: (store (s32) into %fixed-stack.7)
; MIR32-DAG: STW killed $r14, 72, $r1 :: (store (s32) into %fixed-stack.6, align 8)
; MIR32-DAG: STW killed $r25, 116, $r1 :: (store (s32) into %fixed-stack.5)
; ASM64-LABEL: .fprs_and_gprs:
; ASM64: mflr 0
-; ASM64-NEXT: std 0, 16(1)
; ASM64-NEXT: stdu 1, -400(1)
+; ASM64-NEXT: std 0, 416(1)
; ASM64-DAG: std 14, 112(1) # 8-byte Folded Spill
; ASM64-DAG: std 25, 200(1) # 8-byte Folded Spill
; ASM64-DAG: std 31, 248(1) # 8-byte Folded Spill
; ASM32-LABEL: .fprs_and_gprs:
; ASM32: mflr 0
-; ASM32-NEXT: stw 0, 8(1)
; ASM32-NEXT: stwu 1, -288(1)
+; ASM32-NEXT: stw 0, 296(1)
; ASM32-DAG: stw 13, 68(1) # 4-byte Folded Spill
; ASM32-DAG: stw 14, 72(1) # 4-byte Folded Spill
; ASM32-DAG: stw 25, 116(1) # 4-byte Folded Spill
; CHECK-ASM-LABEL: .main:{{[[:space:]] *}}# %bb.0:
; CHECK-FUNC-LABEL: .csect .main[PR],5{{[[:space:]] *}}# %bb.0
; COMMON-NEXT: mflr 0
-; COMMON-NEXT: stw 0, 8(1)
+; COMMON: stw 0, 168(1)
; COMMON: mtlr 0
; COMMON-NEXT: blr
; COMMON-NEXT: L..main0:
; AIX32: # %bb.0: # %entry
; AIX32-NEXT: mflr 0
; AIX32-NEXT: stw 31, -12(1)
-; AIX32-NEXT: stw 0, 8(1)
; AIX32-NEXT: stwu 1, -80(1)
; AIX32-NEXT: slwi 3, 3, 2
; AIX32-NEXT: mr 31, 1
-; AIX32-NEXT: stfd 31, 72(31) # 8-byte Folded Spill
-; AIX32-NEXT: fmr 31, 1
+; AIX32-NEXT: stw 0, 88(1)
; AIX32-NEXT: addi 3, 3, 15
; AIX32-NEXT: addi 4, 31, 80
+; AIX32-NEXT: stfd 31, 72(31) # 8-byte Folded Spill
+; AIX32-NEXT: fmr 31, 1
; AIX32-NEXT: rlwinm 3, 3, 0, 0, 27
; AIX32-NEXT: neg 3, 3
; AIX32-NEXT: stwux 4, 1, 3
; AIX64: # %bb.0: # %entry
; AIX64-NEXT: mflr 0
; AIX64-NEXT: std 31, -16(1)
-; AIX64-NEXT: std 0, 16(1)
; AIX64-NEXT: stdu 1, -144(1)
; AIX64-NEXT: rldic 3, 3, 2, 30
; AIX64-NEXT: mr 31, 1
-; AIX64-NEXT: stfd 31, 136(31) # 8-byte Folded Spill
-; AIX64-NEXT: fmr 31, 1
+; AIX64-NEXT: std 0, 160(1)
; AIX64-NEXT: addi 3, 3, 15
; AIX64-NEXT: addi 4, 31, 144
+; AIX64-NEXT: stfd 31, 136(31) # 8-byte Folded Spill
+; AIX64-NEXT: fmr 31, 1
; AIX64-NEXT: rldicl 3, 3, 60, 4
; AIX64-NEXT: rldicl 3, 3, 4, 29
; AIX64-NEXT: neg 3, 3
; CHECKRELOC32: 00000000 (idx: 7) .bar:
; CHECKRELOC64: 0000000000000000 (idx: 7) .bar:
; CHECKRELOC-NEXT: 0: 7c 08 02 a6 mflr 0
-; CHECKRELOC32-NEXT: 4: 90 01 00 08 stw 0, 8(1)
-; CHECKRELOC32-NEXT: 8: 94 21 ff c0 stwu 1, -64(1)
-; CHECKRELOC32-NEXT: c: 80 62 00 00 lwz 3, 0(2)
-; CHECKRELOC64-NEXT: 4: f8 01 00 10 std 0, 16(1)
-; CHECKRELOC64-NEXT: 8: f8 21 ff 91 stdu 1, -112(1)
-; CHECKRELOC64-NEXT: c: e8 62 00 00 ld 3, 0(2)
-; CHECKRELOC32-NEXT: 0000000e: R_TOC (idx: 13) s[TC]
-; CHECKRELOC64-NEXT: 000000000000000e: R_TOC (idx: 13) s[TC]
+; CHECKRELOC32-NEXT: 4: 94 21 ff c0 stwu 1, -64(1)
+; CHECKRELOC32-NEXT: 8: 80 62 00 00 lwz 3, 0(2)
+; CHECKRELOC32-NEXT: 0000000a: R_TOC (idx: 13) s[TC]
+; CHECKRELOC32-NEXT: c: 90 01 00 48 stw 0, 72(1)
+; CHECKRELOC64-NEXT: 4: f8 21 ff 91 stdu 1, -112(1)
+; CHECKRELOC64-NEXT: 8: e8 62 00 00 ld 3, 0(2)
+; CHECKRELOC64-NEXT: 000000000000000a: R_TOC (idx: 13) s[TC]
+; CHECKRELOC64-NEXT: c: f8 01 00 80 std 0, 128(1)
; CHECKRELOC-NEXT: 10: 80 83 00 04 lwz 4, 4(3)
; CHECKRELOC-NEXT: 14: 7c 85 23 78 mr 5, 4
; CHECKRELOC-NEXT: 18: 4b ff ff e9 bl 0x0
; 32BIT-LABEL: bar:
; 32BIT: # %bb.0: # %entry
; 32BIT-NEXT: mflr 0
-; 32BIT-NEXT: stw 0, 8(1)
; 32BIT-NEXT: stwu 1, -64(1)
+; 32BIT-NEXT: stw 0, 72(1)
; 32BIT-NEXT: bl .foo[PR]
; 32BIT-NEXT: nop
; 32BIT-NEXT: addi 1, 1, 64
; 64BIT-LABEL: bar:
; 64BIT: # %bb.0: # %entry
; 64BIT-NEXT: mflr 0
-; 64BIT-NEXT: std 0, 16(1)
; 64BIT-NEXT: stdu 1, -112(1)
+; 64BIT-NEXT: std 0, 128(1)
; 64BIT-NEXT: bl .foo[PR]
; 64BIT-NEXT: nop
; 64BIT-NEXT: addi 1, 1, 112
; ASM32: stwu 1, -64(1)
; ASM32-NEXT: addi 3, 1, 56
+; ASM32-NEXT: stw 0, 72(1)
; ASM32-NEXT: bl .foo[PR]
; ASM32-NEXT: nop
; ASM32-NEXT: addi 1, 1, 64
; ASM64: stdu 1, -128(1)
; ASM64-NEXT: addi 3, 1, 120
+; ASM64-NEXT: std 0, 144(1)
; ASM64-NEXT: bl .foo[PR]
; ASM64-NEXT: nop
; ASM64-NEXT: addi 1, 1, 128
; ASM32: stwu 1, -80(1)
; ASM32-NEXT: addi 3, 1, 56
+; ASM32-NEXT: stw 0, 88(1)
; ASM32-NEXT: bl .bar[PR]
; ASM32-NEXT: nop
; ASM32-NEXT: addi 1, 1, 80
; ASM64: stdu 1, -144(1)
; ASM64-NEXT: addi 3, 1, 120
+; ASM64-NEXT: std 0, 160(1)
; ASM64-NEXT: bl .bar[PR]
; ASM64-NEXT: nop
; ASM64-NEXT: addi 1, 1, 144
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -verify-machineinstrs -mcpu=pwr7 -mattr=-altivec \
; RUN: -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s \
; RUN: --check-prefix=SMALL32
; SMALL32-LABEL: storesTGUninit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
-; SMALL32-NEXT: lwz 3, L..C0(2)
-; SMALL32-NEXT: lwz 4, L..C1(2)
+; SMALL32-NEXT: lwz 3, L..C0(2) # target-flags(ppc-lo) @TGUninit
+; SMALL32-NEXT: lwz 4, L..C1(2) # target-flags(ppc-tlsgd) @TGUninit
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stfd 1, 0(3)
; SMALL32-NEXT: addi 1, 1, 32
; LARGE32-LABEL: storesTGUninit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C0@u(2)
; LARGE32-NEXT: addis 4, L..C1@u(2)
; LARGE32-NEXT: lwz 3, L..C0@l(3)
; SMALL64-LABEL: storesTGUninit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
-; SMALL64-NEXT: ld 3, L..C0(2)
-; SMALL64-NEXT: ld 4, L..C1(2)
+; SMALL64-NEXT: ld 3, L..C0(2) # target-flags(ppc-lo) @TGUninit
+; SMALL64-NEXT: ld 4, L..C1(2) # target-flags(ppc-tlsgd) @TGUninit
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: stfd 1, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTGUninit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C0@u(2)
; LARGE64-NEXT: addis 4, L..C1@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C0@l(3)
; LARGE64-NEXT: ld 4, L..C1@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTGInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
-; SMALL32-NEXT: lwz 3, L..C2(2)
-; SMALL32-NEXT: lwz 4, L..C3(2)
+; SMALL32-NEXT: lwz 3, L..C2(2) # target-flags(ppc-lo) @TGInit
+; SMALL32-NEXT: lwz 4, L..C3(2) # target-flags(ppc-tlsgd) @TGInit
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stfd 1, 0(3)
; SMALL32-NEXT: addi 1, 1, 32
; LARGE32-LABEL: storesTGInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C2@u(2)
; LARGE32-NEXT: addis 4, L..C3@u(2)
; LARGE32-NEXT: lwz 3, L..C2@l(3)
; SMALL64-LABEL: storesTGInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
-; SMALL64-NEXT: ld 3, L..C2(2)
-; SMALL64-NEXT: ld 4, L..C3(2)
+; SMALL64-NEXT: ld 3, L..C2(2) # target-flags(ppc-lo) @TGInit
+; SMALL64-NEXT: ld 4, L..C3(2) # target-flags(ppc-tlsgd) @TGInit
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: stfd 1, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTGInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C2@u(2)
; LARGE64-NEXT: addis 4, L..C3@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C2@l(3)
; LARGE64-NEXT: ld 4, L..C3@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTIInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
-; SMALL32-NEXT: lwz 3, L..C4(2)
-; SMALL32-NEXT: lwz 4, L..C5(2)
+; SMALL32-NEXT: lwz 3, L..C4(2) # target-flags(ppc-lo) @TIInit
+; SMALL32-NEXT: lwz 4, L..C5(2) # target-flags(ppc-tlsgd) @TIInit
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stfd 1, 0(3)
; SMALL32-NEXT: addi 1, 1, 32
; LARGE32-LABEL: storesTIInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C4@u(2)
; LARGE32-NEXT: addis 4, L..C5@u(2)
; LARGE32-NEXT: lwz 3, L..C4@l(3)
; SMALL64-LABEL: storesTIInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
-; SMALL64-NEXT: ld 3, L..C4(2)
-; SMALL64-NEXT: ld 4, L..C5(2)
+; SMALL64-NEXT: ld 3, L..C4(2) # target-flags(ppc-lo) @TIInit
+; SMALL64-NEXT: ld 4, L..C5(2) # target-flags(ppc-tlsgd) @TIInit
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: stfd 1, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTIInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C4@u(2)
; LARGE64-NEXT: addis 4, L..C5@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C4@l(3)
; LARGE64-NEXT: ld 4, L..C5@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTWInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
-; SMALL32-NEXT: lwz 3, L..C6(2)
-; SMALL32-NEXT: lwz 4, L..C7(2)
+; SMALL32-NEXT: lwz 3, L..C6(2) # target-flags(ppc-lo) @TWInit
+; SMALL32-NEXT: lwz 4, L..C7(2) # target-flags(ppc-tlsgd) @TWInit
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stfd 1, 0(3)
; SMALL32-NEXT: addi 1, 1, 32
; LARGE32-LABEL: storesTWInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C6@u(2)
; LARGE32-NEXT: addis 4, L..C7@u(2)
; LARGE32-NEXT: lwz 3, L..C6@l(3)
; SMALL64-LABEL: storesTWInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
-; SMALL64-NEXT: ld 3, L..C6(2)
-; SMALL64-NEXT: ld 4, L..C7(2)
+; SMALL64-NEXT: ld 3, L..C6(2) # target-flags(ppc-lo) @TWInit
+; SMALL64-NEXT: ld 4, L..C7(2) # target-flags(ppc-tlsgd) @TWInit
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: stfd 1, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTWInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C6@u(2)
; LARGE64-NEXT: addis 4, L..C7@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C6@l(3)
; LARGE64-NEXT: ld 4, L..C7@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTGUninit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
-; SMALL32-NEXT: lwz 3, L..C0(2)
-; SMALL32-NEXT: lwz 4, L..C1(2)
+; SMALL32-NEXT: lwz 3, L..C0(2) # target-flags(ppc-lo) @TGUninit
+; SMALL32-NEXT: lwz 4, L..C1(2) # target-flags(ppc-tlsgd) @TGUninit
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
-; SMALL32-NEXT: lwz 4, L..C8(2)
+; SMALL32-NEXT: lwz 4, L..C8(2) # @GInit
; SMALL32-NEXT: lfd 0, 0(3)
; SMALL32-NEXT: lfd 1, 0(4)
; SMALL32-NEXT: fadd 1, 0, 1
; LARGE32-LABEL: loadsTGUninit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C0@u(2)
; LARGE32-NEXT: addis 4, L..C1@u(2)
; LARGE32-NEXT: lwz 3, L..C0@l(3)
; SMALL64-LABEL: loadsTGUninit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
-; SMALL64-NEXT: ld 3, L..C0(2)
-; SMALL64-NEXT: ld 4, L..C1(2)
+; SMALL64-NEXT: ld 3, L..C0(2) # target-flags(ppc-lo) @TGUninit
+; SMALL64-NEXT: ld 4, L..C1(2) # target-flags(ppc-tlsgd) @TGUninit
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
-; SMALL64-NEXT: ld 4, L..C8(2)
+; SMALL64-NEXT: ld 4, L..C8(2) # @GInit
; SMALL64-NEXT: lfd 0, 0(3)
; SMALL64-NEXT: lfd 1, 0(4)
; SMALL64-NEXT: fadd 1, 0, 1
; LARGE64-LABEL: loadsTGUninit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C0@u(2)
; LARGE64-NEXT: addis 4, L..C1@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C0@l(3)
; LARGE64-NEXT: ld 4, L..C1@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTGInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
-; SMALL32-NEXT: lwz 3, L..C2(2)
-; SMALL32-NEXT: lwz 4, L..C3(2)
+; SMALL32-NEXT: lwz 3, L..C2(2) # target-flags(ppc-lo) @TGInit
+; SMALL32-NEXT: lwz 4, L..C3(2) # target-flags(ppc-tlsgd) @TGInit
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
-; SMALL32-NEXT: lwz 4, L..C8(2)
+; SMALL32-NEXT: lwz 4, L..C8(2) # @GInit
; SMALL32-NEXT: lfd 0, 0(3)
; SMALL32-NEXT: lfd 1, 0(4)
; SMALL32-NEXT: fadd 1, 0, 1
; LARGE32-LABEL: loadsTGInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C2@u(2)
; LARGE32-NEXT: addis 4, L..C3@u(2)
; LARGE32-NEXT: lwz 3, L..C2@l(3)
; SMALL64-LABEL: loadsTGInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
-; SMALL64-NEXT: ld 3, L..C2(2)
-; SMALL64-NEXT: ld 4, L..C3(2)
+; SMALL64-NEXT: ld 3, L..C2(2) # target-flags(ppc-lo) @TGInit
+; SMALL64-NEXT: ld 4, L..C3(2) # target-flags(ppc-tlsgd) @TGInit
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
-; SMALL64-NEXT: ld 4, L..C8(2)
+; SMALL64-NEXT: ld 4, L..C8(2) # @GInit
; SMALL64-NEXT: lfd 0, 0(3)
; SMALL64-NEXT: lfd 1, 0(4)
; SMALL64-NEXT: fadd 1, 0, 1
; LARGE64-LABEL: loadsTGInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C2@u(2)
; LARGE64-NEXT: addis 4, L..C3@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C2@l(3)
; LARGE64-NEXT: ld 4, L..C3@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTIInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
-; SMALL32-NEXT: lwz 3, L..C4(2)
-; SMALL32-NEXT: lwz 4, L..C5(2)
+; SMALL32-NEXT: lwz 3, L..C4(2) # target-flags(ppc-lo) @TIInit
+; SMALL32-NEXT: lwz 4, L..C5(2) # target-flags(ppc-tlsgd) @TIInit
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
-; SMALL32-NEXT: lwz 4, L..C8(2)
+; SMALL32-NEXT: lwz 4, L..C8(2) # @GInit
; SMALL32-NEXT: lfd 0, 0(3)
; SMALL32-NEXT: lfd 1, 0(4)
; SMALL32-NEXT: fadd 1, 0, 1
; LARGE32-LABEL: loadsTIInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C4@u(2)
; LARGE32-NEXT: addis 4, L..C5@u(2)
; LARGE32-NEXT: lwz 3, L..C4@l(3)
; SMALL64-LABEL: loadsTIInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
-; SMALL64-NEXT: ld 3, L..C4(2)
-; SMALL64-NEXT: ld 4, L..C5(2)
+; SMALL64-NEXT: ld 3, L..C4(2) # target-flags(ppc-lo) @TIInit
+; SMALL64-NEXT: ld 4, L..C5(2) # target-flags(ppc-tlsgd) @TIInit
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
-; SMALL64-NEXT: ld 4, L..C8(2)
+; SMALL64-NEXT: ld 4, L..C8(2) # @GInit
; SMALL64-NEXT: lfd 0, 0(3)
; SMALL64-NEXT: lfd 1, 0(4)
; SMALL64-NEXT: fadd 1, 0, 1
; LARGE64-LABEL: loadsTIInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C4@u(2)
; LARGE64-NEXT: addis 4, L..C5@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C4@l(3)
; LARGE64-NEXT: ld 4, L..C5@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTWInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
-; SMALL32-NEXT: lwz 3, L..C6(2)
-; SMALL32-NEXT: lwz 4, L..C7(2)
+; SMALL32-NEXT: lwz 3, L..C6(2) # target-flags(ppc-lo) @TWInit
+; SMALL32-NEXT: lwz 4, L..C7(2) # target-flags(ppc-tlsgd) @TWInit
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
-; SMALL32-NEXT: lwz 4, L..C8(2)
+; SMALL32-NEXT: lwz 4, L..C8(2) # @GInit
; SMALL32-NEXT: lfd 0, 0(3)
; SMALL32-NEXT: lfd 1, 0(4)
; SMALL32-NEXT: fadd 1, 0, 1
; LARGE32-LABEL: loadsTWInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C6@u(2)
; LARGE32-NEXT: addis 4, L..C7@u(2)
; LARGE32-NEXT: lwz 3, L..C6@l(3)
; SMALL64-LABEL: loadsTWInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
-; SMALL64-NEXT: ld 3, L..C6(2)
-; SMALL64-NEXT: ld 4, L..C7(2)
+; SMALL64-NEXT: ld 3, L..C6(2) # target-flags(ppc-lo) @TWInit
+; SMALL64-NEXT: ld 4, L..C7(2) # target-flags(ppc-tlsgd) @TWInit
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
-; SMALL64-NEXT: ld 4, L..C8(2)
+; SMALL64-NEXT: ld 4, L..C8(2) # @GInit
; SMALL64-NEXT: lfd 0, 0(3)
; SMALL64-NEXT: lfd 1, 0(4)
; SMALL64-NEXT: fadd 1, 0, 1
; LARGE64-LABEL: loadsTWInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C6@u(2)
; LARGE64-NEXT: addis 4, L..C7@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C6@l(3)
; LARGE64-NEXT: ld 4, L..C7@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTGUninit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: mr 6, 3
; SMALL32-NEXT: lwz 3, L..C0(2)
; SMALL32-NEXT: lwz 4, L..C1(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stw 6, 0(3)
; SMALL32-NEXT: addi 1, 1, 32
; LARGE32-LABEL: storesTGUninit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: mr 6, 3
; LARGE32-NEXT: addis 3, L..C0@u(2)
; LARGE32-NEXT: addis 4, L..C1@u(2)
; SMALL64-LABEL: storesTGUninit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: mr 6, 3
; SMALL64-NEXT: ld 3, L..C0(2)
; SMALL64-NEXT: ld 4, L..C1(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: stw 6, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTGUninit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: mr 6, 3
; LARGE64-NEXT: addis 3, L..C0@u(2)
; LARGE64-NEXT: addis 4, L..C1@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C0@l(3)
; LARGE64-NEXT: ld 4, L..C1@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTGInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: mr 6, 3
; SMALL32-NEXT: lwz 3, L..C2(2)
; SMALL32-NEXT: lwz 4, L..C3(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stw 6, 0(3)
; SMALL32-NEXT: addi 1, 1, 32
; LARGE32-LABEL: storesTGInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: mr 6, 3
; LARGE32-NEXT: addis 3, L..C2@u(2)
; LARGE32-NEXT: addis 4, L..C3@u(2)
; SMALL64-LABEL: storesTGInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: mr 6, 3
; SMALL64-NEXT: ld 3, L..C2(2)
; SMALL64-NEXT: ld 4, L..C3(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: stw 6, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTGInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: mr 6, 3
; LARGE64-NEXT: addis 3, L..C2@u(2)
; LARGE64-NEXT: addis 4, L..C3@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C2@l(3)
; LARGE64-NEXT: ld 4, L..C3@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTIUninit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: mr 6, 3
; SMALL32-NEXT: lwz 3, L..C4(2)
; SMALL32-NEXT: lwz 4, L..C5(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stw 6, 0(3)
; SMALL32-NEXT: addi 1, 1, 32
; LARGE32-LABEL: storesTIUninit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: mr 6, 3
; LARGE32-NEXT: addis 3, L..C4@u(2)
; LARGE32-NEXT: addis 4, L..C5@u(2)
; SMALL64-LABEL: storesTIUninit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: mr 6, 3
; SMALL64-NEXT: ld 3, L..C4(2)
; SMALL64-NEXT: ld 4, L..C5(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: stw 6, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTIUninit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: mr 6, 3
; LARGE64-NEXT: addis 3, L..C4@u(2)
; LARGE64-NEXT: addis 4, L..C5@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C4@l(3)
; LARGE64-NEXT: ld 4, L..C5@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTWUninit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: mr 6, 3
; SMALL32-NEXT: lwz 3, L..C6(2)
; SMALL32-NEXT: lwz 4, L..C7(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stw 6, 0(3)
; SMALL32-NEXT: addi 1, 1, 32
; LARGE32-LABEL: storesTWUninit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: mr 6, 3
; LARGE32-NEXT: addis 3, L..C6@u(2)
; LARGE32-NEXT: addis 4, L..C7@u(2)
; SMALL64-LABEL: storesTWUninit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: mr 6, 3
; SMALL64-NEXT: ld 3, L..C6(2)
; SMALL64-NEXT: ld 4, L..C7(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: stw 6, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTWUninit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: mr 6, 3
; LARGE64-NEXT: addis 3, L..C6@u(2)
; LARGE64-NEXT: addis 4, L..C7@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C6@l(3)
; LARGE64-NEXT: ld 4, L..C7@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTGUninit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: lwz 3, L..C0(2)
; SMALL32-NEXT: lwz 4, L..C1(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: lwz 4, L..C8(2)
; SMALL32-NEXT: lwz 3, 0(3)
; LARGE32-LABEL: loadsTGUninit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C0@u(2)
; LARGE32-NEXT: addis 4, L..C1@u(2)
; LARGE32-NEXT: lwz 3, L..C0@l(3)
; SMALL64-LABEL: loadsTGUninit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: ld 3, L..C0(2)
; SMALL64-NEXT: ld 4, L..C1(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: ld 4, L..C8(2)
; SMALL64-NEXT: lwz 3, 0(3)
; LARGE64-LABEL: loadsTGUninit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C0@u(2)
; LARGE64-NEXT: addis 4, L..C1@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C0@l(3)
; LARGE64-NEXT: ld 4, L..C1@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTGInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: lwz 3, L..C2(2)
; SMALL32-NEXT: lwz 4, L..C3(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: lwz 4, L..C8(2)
; SMALL32-NEXT: lwz 3, 0(3)
; LARGE32-LABEL: loadsTGInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C2@u(2)
; LARGE32-NEXT: addis 4, L..C3@u(2)
; LARGE32-NEXT: lwz 3, L..C2@l(3)
; SMALL64-LABEL: loadsTGInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: ld 3, L..C2(2)
; SMALL64-NEXT: ld 4, L..C3(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: ld 4, L..C8(2)
; SMALL64-NEXT: lwz 3, 0(3)
; LARGE64-LABEL: loadsTGInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C2@u(2)
; LARGE64-NEXT: addis 4, L..C3@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C2@l(3)
; LARGE64-NEXT: ld 4, L..C3@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTIUninit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: lwz 3, L..C4(2)
; SMALL32-NEXT: lwz 4, L..C5(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: lwz 4, L..C8(2)
; SMALL32-NEXT: lwz 3, 0(3)
; LARGE32-LABEL: loadsTIUninit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C4@u(2)
; LARGE32-NEXT: addis 4, L..C5@u(2)
; LARGE32-NEXT: lwz 3, L..C4@l(3)
; SMALL64-LABEL: loadsTIUninit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: ld 3, L..C4(2)
; SMALL64-NEXT: ld 4, L..C5(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: ld 4, L..C8(2)
; SMALL64-NEXT: lwz 3, 0(3)
; LARGE64-LABEL: loadsTIUninit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C4@u(2)
; LARGE64-NEXT: addis 4, L..C5@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C4@l(3)
; LARGE64-NEXT: ld 4, L..C5@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTWUninit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: lwz 3, L..C6(2)
; SMALL32-NEXT: lwz 4, L..C7(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: lwz 4, L..C8(2)
; SMALL32-NEXT: lwz 3, 0(3)
; LARGE32-LABEL: loadsTWUninit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C6@u(2)
; LARGE32-NEXT: addis 4, L..C7@u(2)
; LARGE32-NEXT: lwz 3, L..C6@l(3)
; SMALL64-LABEL: loadsTWUninit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: ld 3, L..C6(2)
; SMALL64-NEXT: ld 4, L..C7(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: ld 4, L..C8(2)
; SMALL64-NEXT: lwz 3, 0(3)
; LARGE64-LABEL: loadsTWUninit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C6@u(2)
; LARGE64-NEXT: addis 4, L..C7@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C6@l(3)
; LARGE64-NEXT: ld 4, L..C7@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTGInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: mr 6, 4
; SMALL32-NEXT: mr 7, 3
; SMALL32-NEXT: lwz 3, L..C0(2)
; SMALL32-NEXT: lwz 4, L..C1(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stw 6, 4(3)
; SMALL32-NEXT: stw 7, 0(3)
; LARGE32-LABEL: storesTGInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: mr 6, 4
; LARGE32-NEXT: mr 7, 3
; LARGE32-NEXT: addis 3, L..C0@u(2)
; SMALL64-LABEL: storesTGInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: mr 6, 3
; SMALL64-NEXT: ld 3, L..C0(2)
; SMALL64-NEXT: ld 4, L..C1(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: std 6, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTGInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: mr 6, 3
; LARGE64-NEXT: addis 3, L..C0@u(2)
; LARGE64-NEXT: addis 4, L..C1@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C0@l(3)
; LARGE64-NEXT: ld 4, L..C1@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTIUninit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: mr 6, 4
; SMALL32-NEXT: mr 7, 3
; SMALL32-NEXT: lwz 3, L..C2(2)
; SMALL32-NEXT: lwz 4, L..C3(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stw 6, 4(3)
; SMALL32-NEXT: stw 7, 0(3)
; LARGE32-LABEL: storesTIUninit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: mr 6, 4
; LARGE32-NEXT: mr 7, 3
; LARGE32-NEXT: addis 3, L..C2@u(2)
; SMALL64-LABEL: storesTIUninit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: mr 6, 3
; SMALL64-NEXT: ld 3, L..C2(2)
; SMALL64-NEXT: ld 4, L..C3(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: std 6, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTIUninit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: mr 6, 3
; LARGE64-NEXT: addis 3, L..C2@u(2)
; LARGE64-NEXT: addis 4, L..C3@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C2@l(3)
; LARGE64-NEXT: ld 4, L..C3@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTIInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: mr 6, 4
; SMALL32-NEXT: mr 7, 3
; SMALL32-NEXT: lwz 3, L..C4(2)
; SMALL32-NEXT: lwz 4, L..C5(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stw 6, 4(3)
; SMALL32-NEXT: stw 7, 0(3)
; LARGE32-LABEL: storesTIInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: mr 6, 4
; LARGE32-NEXT: mr 7, 3
; LARGE32-NEXT: addis 3, L..C4@u(2)
; SMALL64-LABEL: storesTIInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: mr 6, 3
; SMALL64-NEXT: ld 3, L..C4(2)
; SMALL64-NEXT: ld 4, L..C5(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: std 6, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTIInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: mr 6, 3
; LARGE64-NEXT: addis 3, L..C4@u(2)
; LARGE64-NEXT: addis 4, L..C5@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C4@l(3)
; LARGE64-NEXT: ld 4, L..C5@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: storesTWInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: mr 6, 4
; SMALL32-NEXT: mr 7, 3
; SMALL32-NEXT: lwz 3, L..C6(2)
; SMALL32-NEXT: lwz 4, L..C7(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: stw 6, 4(3)
; SMALL32-NEXT: stw 7, 0(3)
; LARGE32-LABEL: storesTWInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: mr 6, 4
; LARGE32-NEXT: mr 7, 3
; LARGE32-NEXT: addis 3, L..C6@u(2)
; SMALL64-LABEL: storesTWInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: mr 6, 3
; SMALL64-NEXT: ld 3, L..C6(2)
; SMALL64-NEXT: ld 4, L..C7(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: std 6, 0(3)
; SMALL64-NEXT: addi 1, 1, 48
; LARGE64-LABEL: storesTWInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: mr 6, 3
; LARGE64-NEXT: addis 3, L..C6@u(2)
; LARGE64-NEXT: addis 4, L..C7@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C6@l(3)
; LARGE64-NEXT: ld 4, L..C7@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTGInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: lwz 3, L..C0(2)
; SMALL32-NEXT: lwz 4, L..C1(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: lwz 4, L..C8(2)
; SMALL32-NEXT: lwz 5, 4(3)
; LARGE32-LABEL: loadsTGInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C0@u(2)
; LARGE32-NEXT: addis 4, L..C1@u(2)
; LARGE32-NEXT: lwz 3, L..C0@l(3)
; SMALL64-LABEL: loadsTGInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: ld 3, L..C0(2)
; SMALL64-NEXT: ld 4, L..C1(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: ld 4, L..C8(2)
; SMALL64-NEXT: ld 3, 0(3)
; LARGE64-LABEL: loadsTGInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C0@u(2)
; LARGE64-NEXT: addis 4, L..C1@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C0@l(3)
; LARGE64-NEXT: ld 4, L..C1@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTIUninit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: lwz 3, L..C2(2)
; SMALL32-NEXT: lwz 4, L..C3(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: lwz 4, L..C8(2)
; SMALL32-NEXT: lwz 5, 4(3)
; LARGE32-LABEL: loadsTIUninit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C2@u(2)
; LARGE32-NEXT: addis 4, L..C3@u(2)
; LARGE32-NEXT: lwz 3, L..C2@l(3)
; SMALL64-LABEL: loadsTIUninit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: ld 3, L..C2(2)
; SMALL64-NEXT: ld 4, L..C3(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: ld 4, L..C8(2)
; SMALL64-NEXT: ld 3, 0(3)
; LARGE64-LABEL: loadsTIUninit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C2@u(2)
; LARGE64-NEXT: addis 4, L..C3@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C2@l(3)
; LARGE64-NEXT: ld 4, L..C3@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTIInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: lwz 3, L..C4(2)
; SMALL32-NEXT: lwz 4, L..C5(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: lwz 4, L..C8(2)
; SMALL32-NEXT: lwz 5, 4(3)
; LARGE32-LABEL: loadsTIInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C4@u(2)
; LARGE32-NEXT: addis 4, L..C5@u(2)
; LARGE32-NEXT: lwz 3, L..C4@l(3)
; SMALL64-LABEL: loadsTIInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: ld 3, L..C4(2)
; SMALL64-NEXT: ld 4, L..C5(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: ld 4, L..C8(2)
; SMALL64-NEXT: ld 3, 0(3)
; LARGE64-LABEL: loadsTIInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C4@u(2)
; LARGE64-NEXT: addis 4, L..C5@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C4@l(3)
; LARGE64-NEXT: ld 4, L..C5@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; SMALL32-LABEL: loadsTWInit:
; SMALL32: # %bb.0: # %entry
; SMALL32-NEXT: mflr 0
-; SMALL32-NEXT: stw 0, 8(1)
; SMALL32-NEXT: stwu 1, -32(1)
; SMALL32-NEXT: lwz 3, L..C6(2)
; SMALL32-NEXT: lwz 4, L..C7(2)
+; SMALL32-NEXT: stw 0, 40(1)
; SMALL32-NEXT: bla .__tls_get_addr[PR]
; SMALL32-NEXT: lwz 4, L..C8(2)
; SMALL32-NEXT: lwz 5, 4(3)
; LARGE32-LABEL: loadsTWInit:
; LARGE32: # %bb.0: # %entry
; LARGE32-NEXT: mflr 0
-; LARGE32-NEXT: stw 0, 8(1)
; LARGE32-NEXT: stwu 1, -32(1)
+; LARGE32-NEXT: stw 0, 40(1)
; LARGE32-NEXT: addis 3, L..C6@u(2)
; LARGE32-NEXT: addis 4, L..C7@u(2)
; LARGE32-NEXT: lwz 3, L..C6@l(3)
; SMALL64-LABEL: loadsTWInit:
; SMALL64: # %bb.0: # %entry
; SMALL64-NEXT: mflr 0
-; SMALL64-NEXT: std 0, 16(1)
; SMALL64-NEXT: stdu 1, -48(1)
; SMALL64-NEXT: ld 3, L..C6(2)
; SMALL64-NEXT: ld 4, L..C7(2)
+; SMALL64-NEXT: std 0, 64(1)
; SMALL64-NEXT: bla .__tls_get_addr[PR]
; SMALL64-NEXT: ld 4, L..C8(2)
; SMALL64-NEXT: ld 3, 0(3)
; LARGE64-LABEL: loadsTWInit:
; LARGE64: # %bb.0: # %entry
; LARGE64-NEXT: mflr 0
-; LARGE64-NEXT: std 0, 16(1)
; LARGE64-NEXT: stdu 1, -48(1)
; LARGE64-NEXT: addis 3, L..C6@u(2)
; LARGE64-NEXT: addis 4, L..C7@u(2)
+; LARGE64-NEXT: std 0, 64(1)
; LARGE64-NEXT: ld 3, L..C6@l(3)
; LARGE64-NEXT: ld 4, L..C7@l(4)
; LARGE64-NEXT: bla .__tls_get_addr[PR]
; DIS: Disassembly of section .text:
; DIS: 00000000 (idx: 5) .storesTIInit:
; DIS-NEXT: mflr 0
-; DIS-NEXT: stw 0, 8(1)
; DIS-NEXT: stwu 1, -32(1)
+; DIS-NEXT: stw 0, 40(1)
; DIS-NEXT: mr 6, 4
; DIS-NEXT: mr 7, 3
; DIS-NEXT: [[#%x, ADDR:]]: {{.*}} addis 3, 2, 0
; DIS-NEXT: blr
; DIS: 00000040 (idx: 7) .loadsTWInit:
; DIS-NEXT: mflr 0
-; DIS-NEXT: stw 0, 8(1)
; DIS-NEXT: stwu 1, -32(1)
+; DIS-NEXT: stw 0, 40(1)
; DIS-NEXT: [[#%x, ADDR:]]: {{.*}} addis 3, 2, 0
; DIS-NEXT: {{0*}}[[#ADDR + 2]]: R_TOCU (idx: 21) .TWInit[TE]
; DIS-NEXT: [[#%x, ADDR:]]: {{.*}} addis 4, 2, 0
; RELOC-NEXT: Relocations [
; RELOC-NEXT: Section (index: 1) .text {
; RELOC-NEXT: Relocation {
-; RELOC-NEXT: Virtual Address: 0x12
+; RELOC-NEXT: Virtual Address: 0xE
; RELOC-NEXT: Symbol: .TIUninit (23)
; RELOC-NEXT: IsSigned: No
; RELOC-NEXT: FixupBitValue: 0
; RELOC-NEXT: Type: R_TOC (0x3)
; RELOC-NEXT: }
; RELOC-NEXT: Relocation {
-; RELOC-NEXT: Virtual Address: 0x16
+; RELOC-NEXT: Virtual Address: 0x12
; RELOC-NEXT: Symbol: TIUninit (25)
; RELOC-NEXT: IsSigned: No
; RELOC-NEXT: FixupBitValue: 0
; RELOC-NEXT: Type: R_RBA (0x18)
; RELOC-NEXT: }
; RELOC-NEXT: Relocation {
-; RELOC-NEXT: Virtual Address: 0x3E
+; RELOC-NEXT: Virtual Address: 0x3A
; RELOC-NEXT: Symbol: .TGInit (27)
; RELOC-NEXT: IsSigned: No
; RELOC-NEXT: FixupBitValue: 0
; RELOC-NEXT: Type: R_TOC (0x3)
; RELOC-NEXT: }
; RELOC-NEXT: Relocation {
-; RELOC-NEXT: Virtual Address: 0x42
+; RELOC-NEXT: Virtual Address: 0x3E
; RELOC-NEXT: Symbol: TGInit (29)
; RELOC-NEXT: IsSigned: No
; RELOC-NEXT: FixupBitValue: 0
; DIS: Disassembly of section .text:
; DIS: 00000000 (idx: 5) .storesTIUninit:
; DIS-NEXT: mflr 0
-; DIS-NEXT: stw 0, 8(1)
; DIS-NEXT: stwu 1, -32(1)
; DIS-NEXT: mr 6, 3
; DIS-NEXT: [[#%x, ADDR:]]: {{.*}} lwz 3, 0(2)
; DIS-NEXT: {{0*}}[[#ADDR + 2]]: R_TOC (idx: 23) .TIUninit[TC]
; DIS-NEXT: [[#%x, ADDR:]]: {{.*}} lwz 4, 4(2)
; DIS-NEXT: {{0*}}[[#ADDR + 2]]: R_TOC (idx: 25) TIUninit[TC]
+; DIS-NEXT: stw 0, 40(1)
; DIS-NEXT: [[#%x, ADDR:]]: {{.*}} bla 0
; DIS-NEXT: {{0*}}[[#ADDR]]: R_RBA (idx: 1) .__tls_get_addr[PR]
; DIS-NEXT: stw 6, 0(3)
; DIS-NEXT: blr
; DIS: 00000030 (idx: 7) .loadsTGInit:
; DIS-NEXT: mflr 0
-; DIS-NEXT: stw 0, 8(1)
; DIS-NEXT: stwu 1, -32(1)
; DIS-NEXT: [[#%x, ADDR:]]: {{.*}} lwz 3, 8(2)
; DIS-NEXT: {{0*}}[[#ADDR + 2]]: R_TOC (idx: 27) .TGInit[TC]
; DIS-NEXT: [[#%x, ADDR:]]: {{.*}} lwz 4, 12(2)
; DIS-NEXT: {{0*}}[[#ADDR + 2]]: R_TOC (idx: 29) TGInit[TC]
+; DIS-NEXT: stw 0, 40(1)
; DIS-NEXT: [[#%x, ADDR:]]: {{.*}} bla 0
; DIS-NEXT: {{0*}}[[#ADDR]]: R_RBA (idx: 1) .__tls_get_addr[PR]
; DIS-NEXT: [[#%x, ADDR:]]: {{.*}} lwz 4, 16(2)
; 32-DIS-NEXT: c: 60 00 00 00 nop
; 32-DIS: 00000010 <.call_memcpy>:
; 32-DIS-NEXT: 10: 7c 08 02 a6 mflr 0
-; 32-DIS-NEXT: 14: 90 01 00 08 stw 0, 8(1)
-; 32-DIS-NEXT: 18: 94 21 ff c0 stwu 1, -64(1)
+; 32-DIS-NEXT: 14: 94 21 ff c0 stwu 1, -64(1)
+; 32-DIS-NEXT: 18: 90 01 00 48 stw 0, 72(1)
; 32-DIS-NEXT: 1c: 4b ff ff e5 bl 0x0
; 32-DIS-NEXT: 20: 60 00 00 00 nop
; 32-DIS-NEXT: 24: 38 21 00 40 addi 1, 1, 64
; 32BIT-LABEL: caller:
; 32BIT: # %bb.0: # %entry
; 32BIT-NEXT: mflr 0
-; 32BIT-NEXT: stw 0, 8(1)
; 32BIT-NEXT: stwu 1, -192(1)
; 32BIT-NEXT: lis 3, 16392
+; 32BIT-NEXT: stw 0, 200(1)
; 32BIT-NEXT: lis 4, 16384
; 32BIT-NEXT: xxlxor 0, 0, 0
; 32BIT-NEXT: lwz 5, L..C0(2) # %const.0
-; 32BIT-NEXT: li 6, 512
; 32BIT-NEXT: stw 3, 180(1)
; 32BIT-NEXT: li 3, 0
; 32BIT-NEXT: xxlxor 1, 1, 1
+; 32BIT-NEXT: li 6, 512
; 32BIT-NEXT: stw 4, 172(1)
; 32BIT-NEXT: lis 4, 16368
; 32BIT-NEXT: xxlxor 2, 2, 2
; 64BIT-LABEL: caller:
; 64BIT: # %bb.0: # %entry
; 64BIT-NEXT: mflr 0
-; 64BIT-NEXT: std 0, 16(1)
; 64BIT-NEXT: stdu 1, -224(1)
; 64BIT-NEXT: li 3, 2049
+; 64BIT-NEXT: std 0, 240(1)
; 64BIT-NEXT: li 4, 1
; 64BIT-NEXT: xxlxor 0, 0, 0
-; 64BIT-NEXT: li 5, 0
; 64BIT-NEXT: rldic 3, 3, 51, 1
; 64BIT-NEXT: rldic 4, 4, 62, 1
+; 64BIT-NEXT: li 5, 0
; 64BIT-NEXT: xxlxor 1, 1, 1
-; 64BIT-NEXT: li 6, 144
; 64BIT-NEXT: std 3, 216(1)
; 64BIT-NEXT: li 3, 1023
; 64BIT-NEXT: xxlxor 2, 2, 2
+; 64BIT-NEXT: li 6, 144
; 64BIT-NEXT: rldic 3, 3, 52, 2
; 64BIT-NEXT: std 4, 208(1)
; 64BIT-NEXT: li 4, 160
; 32BIT-LABEL: vec_caller:
; 32BIT: # %bb.0: # %entry
; 32BIT-NEXT: mflr 0
-; 32BIT-NEXT: stw 0, 8(1)
; 32BIT-NEXT: stwu 1, -64(1)
; 32BIT-NEXT: lwz 3, L..C0(2)
; 32BIT-NEXT: lwz 4, L..C1(2)
; 32BIT-NEXT: xxlxor 34, 34, 34
+; 32BIT-NEXT: stw 0, 72(1)
; 32BIT-NEXT: xxlxor 35, 35, 35
; 32BIT-NEXT: xxlxor 36, 36, 36
; 32BIT-NEXT: lxvw4x 0, 0, 3
; 64BIT-LABEL: vec_caller:
; 64BIT: # %bb.0: # %entry
; 64BIT-NEXT: mflr 0
-; 64BIT-NEXT: std 0, 16(1)
; 64BIT-NEXT: stdu 1, -112(1)
; 64BIT-NEXT: ld 3, L..C0(2)
; 64BIT-NEXT: ld 4, L..C1(2)
; 64BIT-NEXT: xxlxor 34, 34, 34
+; 64BIT-NEXT: std 0, 128(1)
; 64BIT-NEXT: xxlxor 35, 35, 35
; 64BIT-NEXT: xxlxor 36, 36, 36
; 64BIT-NEXT: lxvw4x 0, 0, 3
; DIS: Disassembly of section .text:
; DIS: 00000000 <.foo>:
; DIS-NEXT: 0: 7c 08 02 a6 mflr 0
-; DIS-NEXT: 4: 90 01 00 08 stw 0, 8(1)
-; DIS-NEXT: 8: 94 21 ff c0 stwu 1, -64(1)
-; DIS-NEXT: c: 38 60 00 01 li 3, 1
+; DIS-NEXT: 4: 94 21 ff c0 stwu 1, -64(1)
+; DIS-NEXT: 8: 38 60 00 01 li 3, 1
+; DIS-NEXT: c: 90 01 00 48 stw 0, 72(1)
; DIS-NEXT: 10: 4b ff ff f1 bl 0x0
; DIS-NEXT: 14: 60 00 00 00 nop
; DIS-NEXT: 18: 80 82 00 00 lwz 4, 0(2)
; DIS64: Disassembly of section .text:
; DIS64: 0000000000000000 <.foo>:
; DIS64-NEXT: 0: 7c 08 02 a6 mflr 0
-; DIS64-NEXT: 4: f8 01 00 10 std 0, 16(1)
-; DIS64-NEXT: 8: f8 21 ff 91 stdu 1, -112(1)
-; DIS64-NEXT: c: 38 60 00 01 li 3, 1
+; DIS64-NEXT: 4: f8 21 ff 91 stdu 1, -112(1)
+; DIS64-NEXT: 8: 38 60 00 01 li 3, 1
+; DIS64-NEXT: c: f8 01 00 80 std 0, 128(1)
; DIS64-NEXT: 10: 4b ff ff f1 bl 0x0 <.foo>
; DIS64-NEXT: 14: 60 00 00 00 nop
; DIS64-NEXT: 18: e8 82 00 00 ld 4, 0(2)
; OBJ-EMPTY:
; OBJ-NEXT: 00000000 (idx: 7) .f$o:
; OBJ-NEXT: 0: 7c 08 02 a6 mflr 0
-; OBJ-NEXT: 4: 90 01 00 08 stw 0, 8(1)
-; OBJ-NEXT: 8: 94 21 ff c0 stwu 1, -64(1)
+; OBJ-NEXT: 4: 94 21 ff c0 stwu 1, -64(1)
+; OBJ-NEXT: 8: 90 01 00 48 stw 0, 72(1)
; OBJ-NEXT: c: 4b ff ff f5 bl 0x0
; OBJ-NEXT: 0000000c: R_RBR (idx: 1) .f@o[PR]
; OBJ-NEXT: 10: 60 00 00 00 nop
; OBJ-EMPTY:
; OBJ-NEXT: 00000030 (idx: 9) .f&o:
; OBJ-NEXT: 30: 7c 08 02 a6 mflr 0
-; OBJ-NEXT: 34: 90 01 00 08 stw 0, 8(1)
-; OBJ-NEXT: 38: 94 21 ff c0 stwu 1, -64(1)
+; OBJ-NEXT: 34: 94 21 ff c0 stwu 1, -64(1)
+; OBJ-NEXT: 38: 90 01 00 48 stw 0, 72(1)
; OBJ-NEXT: 3c: 4b ff ff c5 bl 0x0
; OBJ-NEXT: 40: 80 82 00 00 lwz 4, 0(2)
; OBJ-NEXT: 00000042: R_TOC (idx: 25) f=o[TC]
; AIX32-LABEL: test_op_ignore:
; AIX32: # %bb.0: # %entry
; AIX32-NEXT: mflr 0
-; AIX32-NEXT: stw 0, 8(1)
; AIX32-NEXT: stwu 1, -160(1)
; AIX32-NEXT: lwz 3, L..C0(2) # @sc
+; AIX32-NEXT: stw 0, 168(1)
; AIX32-NEXT: stw 15, 92(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 26, 136(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 28, 144(1) # 4-byte Folded Spill
; AIX32-NEXT: li 15, 1
; AIX32-NEXT: stw 16, 96(1) # 4-byte Folded Spill
-; AIX32-NEXT: stw 17, 100(1) # 4-byte Folded Spill
; AIX32-NEXT: rlwinm 4, 3, 3, 27, 28
; AIX32-NEXT: rlwinm 28, 3, 0, 0, 29
; AIX32-NEXT: li 3, 255
; AIX32-NEXT: xori 26, 4, 24
+; AIX32-NEXT: stw 17, 100(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 18, 104(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 19, 108(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 20, 112(1) # 4-byte Folded Spill
; AIX32-LABEL: test_fetch_and_op:
; AIX32: # %bb.0: # %entry
; AIX32-NEXT: mflr 0
-; AIX32-NEXT: stw 0, 8(1)
; AIX32-NEXT: stwu 1, -144(1)
; AIX32-NEXT: lwz 4, L..C0(2) # @sc
+; AIX32-NEXT: stw 0, 152(1)
; AIX32-NEXT: stw 26, 120(1) # 4-byte Folded Spill
; AIX32-NEXT: li 7, 11
; AIX32-NEXT: stw 13, 68(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 14, 72(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 15, 76(1) # 4-byte Folded Spill
-; AIX32-NEXT: stw 16, 80(1) # 4-byte Folded Spill
; AIX32-NEXT: rlwinm 3, 4, 3, 27, 28
-; AIX32-NEXT: stw 17, 84(1) # 4-byte Folded Spill
+; AIX32-NEXT: stw 16, 80(1) # 4-byte Folded Spill
; AIX32-NEXT: xori 26, 3, 24
; AIX32-NEXT: li 3, 255
+; AIX32-NEXT: stw 17, 84(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 18, 88(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 19, 92(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 20, 96(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 4, 64(1) # 4-byte Folded Spill
; AIX32-NEXT: rlwinm 24, 4, 0, 0, 29
; AIX32-NEXT: slw 23, 7, 26
-; AIX32-NEXT: sync
; AIX32-NEXT: slw 4, 3, 26
+; AIX32-NEXT: sync
; AIX32-NEXT: L..BB1_1: # %entry
; AIX32-NEXT: #
; AIX32-NEXT: lwarx 3, 0, 24
; AIX32-LABEL: test_op_and_fetch:
; AIX32: # %bb.0: # %entry
; AIX32-NEXT: mflr 0
-; AIX32-NEXT: stw 0, 8(1)
; AIX32-NEXT: stwu 1, -176(1)
+; AIX32-NEXT: stw 0, 184(1)
; AIX32-NEXT: stw 24, 144(1) # 4-byte Folded Spill
+; AIX32-NEXT: lwz 24, L..C0(2) # @sc
; AIX32-NEXT: stw 26, 152(1) # 4-byte Folded Spill
; AIX32-NEXT: lwz 26, L..C1(2) # @uc
-; AIX32-NEXT: lwz 24, L..C0(2) # @sc
; AIX32-NEXT: stw 23, 140(1) # 4-byte Folded Spill
; AIX32-NEXT: li 5, 255
; AIX32-NEXT: stw 13, 100(1) # 4-byte Folded Spill
+; AIX32-NEXT: rlwinm 4, 24, 3, 27, 28
; AIX32-NEXT: stw 14, 104(1) # 4-byte Folded Spill
; AIX32-NEXT: lbz 3, 0(26)
-; AIX32-NEXT: rlwinm 4, 24, 3, 27, 28
-; AIX32-NEXT: stw 15, 108(1) # 4-byte Folded Spill
; AIX32-NEXT: xori 23, 4, 24
+; AIX32-NEXT: stw 15, 108(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 16, 112(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 17, 116(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 18, 120(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 31, 172(1) # 4-byte Folded Spill
; AIX32-NEXT: rlwinm 22, 24, 0, 0, 29
; AIX32-NEXT: li 25, -1
-; AIX32-NEXT: sync
; AIX32-NEXT: slw 4, 3, 23
; AIX32-NEXT: slw 6, 5, 23
+; AIX32-NEXT: sync
; AIX32-NEXT: L..BB2_1: # %entry
; AIX32-NEXT: #
; AIX32-NEXT: lwarx 5, 0, 22
; AIX32-LABEL: test_compare_and_swap:
; AIX32: # %bb.0: # %entry
; AIX32-NEXT: mflr 0
-; AIX32-NEXT: stw 0, 8(1)
; AIX32-NEXT: stwu 1, -128(1)
+; AIX32-NEXT: stw 0, 136(1)
; AIX32-NEXT: stw 28, 112(1) # 4-byte Folded Spill
-; AIX32-NEXT: stw 29, 116(1) # 4-byte Folded Spill
; AIX32-NEXT: lwz 28, L..C0(2) # @sc
+; AIX32-NEXT: stw 29, 116(1) # 4-byte Folded Spill
; AIX32-NEXT: lwz 29, L..C1(2) # @uc
; AIX32-NEXT: stw 23, 92(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 17, 68(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 18, 72(1) # 4-byte Folded Spill
-; AIX32-NEXT: stw 19, 76(1) # 4-byte Folded Spill
; AIX32-NEXT: lbz 3, 0(28)
; AIX32-NEXT: rlwinm 4, 28, 3, 27, 28
+; AIX32-NEXT: stw 19, 76(1) # 4-byte Folded Spill
; AIX32-NEXT: lbz 5, 0(29)
-; AIX32-NEXT: rlwinm 19, 28, 0, 0, 29
; AIX32-NEXT: xori 23, 4, 24
; AIX32-NEXT: li 4, 255
; AIX32-NEXT: slw 6, 3, 23
-; AIX32-NEXT: slw 5, 5, 23
; AIX32-NEXT: slw 3, 4, 23
+; AIX32-NEXT: slw 5, 5, 23
; AIX32-NEXT: stw 20, 80(1) # 4-byte Folded Spill
+; AIX32-NEXT: and 4, 6, 3
; AIX32-NEXT: stw 21, 84(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 22, 88(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 24, 96(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 27, 108(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 30, 120(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 31, 124(1) # 4-byte Folded Spill
-; AIX32-NEXT: and 4, 6, 3
+; AIX32-NEXT: rlwinm 19, 28, 0, 0, 29
; AIX32-NEXT: and 5, 5, 3
; AIX32-NEXT: sync
; AIX32-NEXT: L..BB3_1: # %entry
; AIX32-LABEL: test_lock:
; AIX32: # %bb.0: # %entry
; AIX32-NEXT: mflr 0
-; AIX32-NEXT: stw 0, 8(1)
; AIX32-NEXT: stwu 1, -96(1)
+; AIX32-NEXT: stw 0, 104(1)
; AIX32-NEXT: stw 29, 84(1) # 4-byte Folded Spill
; AIX32-NEXT: lwz 29, L..C0(2) # @sc
; AIX32-NEXT: li 3, 1
; AIX32-NEXT: li 5, 255
; AIX32-NEXT: stw 23, 60(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 24, 64(1) # 4-byte Folded Spill
-; AIX32-NEXT: stw 25, 68(1) # 4-byte Folded Spill
-; AIX32-NEXT: stw 26, 72(1) # 4-byte Folded Spill
; AIX32-NEXT: rlwinm 4, 29, 3, 27, 28
-; AIX32-NEXT: stw 27, 76(1) # 4-byte Folded Spill
+; AIX32-NEXT: stw 25, 68(1) # 4-byte Folded Spill
; AIX32-NEXT: xori 4, 4, 24
-; AIX32-NEXT: stw 28, 80(1) # 4-byte Folded Spill
+; AIX32-NEXT: stw 26, 72(1) # 4-byte Folded Spill
; AIX32-NEXT: slw 8, 3, 4
; AIX32-NEXT: slw 6, 5, 4
+; AIX32-NEXT: stw 27, 76(1) # 4-byte Folded Spill
+; AIX32-NEXT: stw 28, 80(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 30, 88(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 31, 92(1) # 4-byte Folded Spill
; AIX32-NEXT: rlwinm 7, 29, 0, 0, 29
; AIX32-LABEL: cmpswplp:
; AIX32: # %bb.0: # %entry
; AIX32-NEXT: mflr 0
-; AIX32-NEXT: stw 0, 8(1)
; AIX32-NEXT: stwu 1, -64(1)
; AIX32-NEXT: addic 7, 6, 1
-; AIX32-NEXT: stw 6, 60(1)
+; AIX32-NEXT: stw 0, 72(1)
; AIX32-NEXT: addi 4, 1, 56
; AIX32-NEXT: addze 8, 5
-; AIX32-NEXT: stw 5, 56(1)
+; AIX32-NEXT: stw 6, 60(1)
; AIX32-NEXT: mr 6, 7
+; AIX32-NEXT: stw 5, 56(1)
; AIX32-NEXT: mr 5, 8
; AIX32-NEXT: li 7, 0
; AIX32-NEXT: li 8, 0
; AIX32-LABEL: atommax8:
; AIX32: # %bb.0: # %entry
; AIX32-NEXT: mflr 0
-; AIX32-NEXT: stw 0, 8(1)
; AIX32-NEXT: stwu 1, -80(1)
+; AIX32-NEXT: stw 0, 88(1)
+; AIX32-NEXT: stw 28, 64(1) # 4-byte Folded Spill
; AIX32-NEXT: lwz 9, 4(3)
; AIX32-NEXT: lwz 10, 0(3)
-; AIX32-NEXT: stw 28, 64(1) # 4-byte Folded Spill
+; AIX32-NEXT: addi 28, 1, 56
; AIX32-NEXT: stw 29, 68(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 30, 72(1) # 4-byte Folded Spill
; AIX32-NEXT: stw 31, 76(1) # 4-byte Folded Spill
; AIX32-NEXT: mr 31, 5
; AIX32-NEXT: mr 29, 3
; AIX32-NEXT: mr 30, 4
-; AIX32-NEXT: addi 28, 1, 56
; AIX32-NEXT: .align 4
; AIX32-NEXT: L..BB7_1: # %atomicrmw.start
; AIX32-NEXT: #
; ELFV2-NEXT: $x12 = MFOCRF8 killed $cr2
; V1ANDAIX-NEXT: $x12 = MFCR8 implicit killed $cr2
; CHECK64-DAG: STD $x31, -8, $x1
-; CHECK64-DAG: STD killed $x0, 16, $x1
; CHECK64-DAG: STW8 killed $x12, 8, $x1
; ELFV2-NEXT: $x1 = STDU $x1, -48, $x1
+; ELFV2-NEXT: STD killed $x0, 64, $x1
; V1ANDAIX-NEXT: x1 = STDU $x1, -128, $x1
+; V1ANDAIX-NEXT: STD killed $x0, 144, $x1
; CHECK64: $x31 = OR8 $x1, $x1
; CHECK32: $r0 = MFLR implicit $lr
; CHECK32-NEXT: $r12 = MFCR implicit killed $cr2
; CHECK32-DAG: STW $r31, -4, $r1
-; CHECK32-DAG: STW killed $r0, 8, $r1
; CHECK32-DAG: STW killed $r12, 4, $r1
; CHECK32: $r1 = STWU $r1, -80, $r1
+; CHECK32-NEXT: STW killed $r0, 88, $r1
; CHECK32: $r31 = OR $r1, $r1
; CHECK32: $[[ORIGSP:r[0-9]+]] = ADDI $r31, 80
; PWR7-LABEL: lq_unordered:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r4, 0
; AIX64-PWR8-LABEL: lq_unordered:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r4, 0
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_load_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: lq_unordered:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: mr r4, r3
; PWR7-LABEL: lqx_unordered:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: sldi r4, r4, 4
; AIX64-PWR8-LABEL: lqx_unordered:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: sldi r4, r4, 4
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: add r3, r3, r4
; AIX64-PWR8-NEXT: li r4, 0
; AIX64-PWR8-NEXT: bl .__atomic_load_16[PR]
; PPC-PWR8-LABEL: lqx_unordered:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: slwi r4, r6, 4
; PWR7-LABEL: lq_big_offset_unordered:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: addis r3, r3, 32
; AIX64-PWR8-LABEL: lq_big_offset_unordered:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: addis r3, r3, 32
; AIX64-PWR8-NEXT: li r4, 0
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_load_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: lq_big_offset_unordered:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: addis r4, r3, 32
; PWR7-LABEL: lq_monotonic:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r4, 0
; AIX64-PWR8-LABEL: lq_monotonic:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r4, 0
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_load_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: lq_monotonic:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: mr r4, r3
; PWR7-LABEL: lq_acquire:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r4, 2
; AIX64-PWR8-LABEL: lq_acquire:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r4, 2
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_load_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: lq_acquire:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: mr r4, r3
; PWR7-LABEL: lq_seqcst:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r4, 5
; AIX64-PWR8-LABEL: lq_seqcst:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r4, 5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_load_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: lq_seqcst:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: mr r4, r3
; PWR7-LABEL: stq_unordered:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: mr r6, r4
; AIX64-PWR8-LABEL: stq_unordered:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: mr r6, r4
; AIX64-PWR8-NEXT: mr r4, r3
; AIX64-PWR8-NEXT: mr r3, r5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: mr r5, r6
; AIX64-PWR8-NEXT: li r6, 0
; AIX64-PWR8-NEXT: bl .__atomic_store_16[PR]
; PPC-PWR8-LABEL: stq_unordered:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: stw r6, 28(r1)
; PWR7-LABEL: stqx_unordered:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: mr r7, r4
; AIX64-PWR8-LABEL: stqx_unordered:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: mr r7, r4
; AIX64-PWR8-NEXT: mr r4, r3
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: sldi r3, r6, 4
; AIX64-PWR8-NEXT: li r6, 0
; AIX64-PWR8-NEXT: add r3, r5, r3
; PPC-PWR8-LABEL: stqx_unordered:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: slwi r8, r10, 4
; PWR7-LABEL: stq_big_offset_unordered:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: mr r6, r4
; AIX64-PWR8-LABEL: stq_big_offset_unordered:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: mr r6, r4
; AIX64-PWR8-NEXT: mr r4, r3
; AIX64-PWR8-NEXT: addis r3, r5, 32
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: mr r5, r6
; AIX64-PWR8-NEXT: li r6, 0
; AIX64-PWR8-NEXT: bl .__atomic_store_16[PR]
; PPC-PWR8-LABEL: stq_big_offset_unordered:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: stw r6, 28(r1)
; PWR7-LABEL: stq_monotonic:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: mr r6, r4
; AIX64-PWR8-LABEL: stq_monotonic:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: mr r6, r4
; AIX64-PWR8-NEXT: mr r4, r3
; AIX64-PWR8-NEXT: mr r3, r5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: mr r5, r6
; AIX64-PWR8-NEXT: li r6, 0
; AIX64-PWR8-NEXT: bl .__atomic_store_16[PR]
; PPC-PWR8-LABEL: stq_monotonic:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: stw r6, 28(r1)
; PWR7-LABEL: stq_release:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: mr r6, r4
; AIX64-PWR8-LABEL: stq_release:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: mr r6, r4
; AIX64-PWR8-NEXT: mr r4, r3
; AIX64-PWR8-NEXT: mr r3, r5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: mr r5, r6
; AIX64-PWR8-NEXT: li r6, 3
; AIX64-PWR8-NEXT: bl .__atomic_store_16[PR]
; PPC-PWR8-LABEL: stq_release:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: stw r6, 28(r1)
; PWR7-LABEL: stq_seqcst:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: mr r6, r4
; AIX64-PWR8-LABEL: stq_seqcst:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: mr r6, r4
; AIX64-PWR8-NEXT: mr r4, r3
; AIX64-PWR8-NEXT: mr r3, r5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: mr r5, r6
; AIX64-PWR8-NEXT: li r6, 5
; AIX64-PWR8-NEXT: bl .__atomic_store_16[PR]
; PPC-PWR8-LABEL: stq_seqcst:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -32(r1)
+; PPC-PWR8-NEXT: stw r0, 36(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 32
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: stw r6, 28(r1)
; PWR7-LABEL: swap:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r6, 5
; AIX64-PWR8-LABEL: swap:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r6, 5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_exchange_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: swap:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -48(r1)
+; PPC-PWR8-NEXT: stw r0, 52(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 48
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: mr r4, r3
; PWR7-LABEL: add:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r6, 5
; AIX64-PWR8-LABEL: add:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r6, 5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_fetch_add_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: add:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -80(r1)
+; PPC-PWR8-NEXT: stw r0, 84(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 80
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: .cfi_offset r24, -32
; PWR7-LABEL: sub:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r6, 5
; AIX64-PWR8-LABEL: sub:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r6, 5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_fetch_sub_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: sub:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -80(r1)
+; PPC-PWR8-NEXT: stw r0, 84(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 80
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: .cfi_offset r24, -32
; PWR7-LABEL: and:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r6, 5
; AIX64-PWR8-LABEL: and:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r6, 5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_fetch_and_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: and:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -80(r1)
+; PPC-PWR8-NEXT: stw r0, 84(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 80
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: .cfi_offset r24, -32
; PWR7-LABEL: or:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r6, 5
; AIX64-PWR8-LABEL: or:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r6, 5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_fetch_or_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: or:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -80(r1)
+; PPC-PWR8-NEXT: stw r0, 84(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 80
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: .cfi_offset r24, -32
; PWR7-LABEL: xor:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r6, 5
; AIX64-PWR8-LABEL: xor:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r6, 5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_fetch_xor_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: xor:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -80(r1)
+; PPC-PWR8-NEXT: stw r0, 84(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 80
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: .cfi_offset r24, -32
; PWR7-LABEL: nand:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -112(r1)
+; PWR7-NEXT: std r0, 128(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 112
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: li r6, 5
; AIX64-PWR8-LABEL: nand:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -112(r1)
; AIX64-PWR8-NEXT: li r6, 5
+; AIX64-PWR8-NEXT: std r0, 128(r1)
; AIX64-PWR8-NEXT: bl .__atomic_fetch_nand_16[PR]
; AIX64-PWR8-NEXT: nop
; AIX64-PWR8-NEXT: addi r1, r1, 112
; PPC-PWR8-LABEL: nand:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -80(r1)
+; PPC-PWR8-NEXT: stw r0, 84(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 80
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: .cfi_offset r24, -32
; PWR7-LABEL: cas_weak_acquire_acquire:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -128(r1)
+; PWR7-NEXT: std r0, 144(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 128
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: std r5, 120(r1)
; AIX64-PWR8-LABEL: cas_weak_acquire_acquire:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -128(r1)
+; AIX64-PWR8-NEXT: std r0, 144(r1)
; AIX64-PWR8-NEXT: std r5, 120(r1)
; AIX64-PWR8-NEXT: std r4, 112(r1)
; AIX64-PWR8-NEXT: addi r4, r1, 112
; PPC-PWR8-LABEL: cas_weak_acquire_acquire:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -48(r1)
+; PPC-PWR8-NEXT: stw r0, 52(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 48
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: mr r4, r3
; PWR7-LABEL: cas_weak_release_monotonic:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -128(r1)
+; PWR7-NEXT: std r0, 144(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 128
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: std r5, 120(r1)
; AIX64-PWR8-LABEL: cas_weak_release_monotonic:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -128(r1)
+; AIX64-PWR8-NEXT: std r0, 144(r1)
; AIX64-PWR8-NEXT: std r5, 120(r1)
; AIX64-PWR8-NEXT: std r4, 112(r1)
; AIX64-PWR8-NEXT: addi r4, r1, 112
; PPC-PWR8-LABEL: cas_weak_release_monotonic:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -48(r1)
+; PPC-PWR8-NEXT: stw r0, 52(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 48
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: mr r4, r3
; PWR7-LABEL: cas_sc_sc:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -128(r1)
+; PWR7-NEXT: std r0, 144(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 128
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: std r5, 120(r1)
; AIX64-PWR8-LABEL: cas_sc_sc:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -128(r1)
+; AIX64-PWR8-NEXT: std r0, 144(r1)
; AIX64-PWR8-NEXT: std r5, 120(r1)
; AIX64-PWR8-NEXT: std r4, 112(r1)
; AIX64-PWR8-NEXT: addi r4, r1, 112
; PPC-PWR8-LABEL: cas_sc_sc:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -48(r1)
+; PPC-PWR8-NEXT: stw r0, 52(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 48
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: mr r4, r3
; PWR7-LABEL: cas_acqrel_acquire:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -128(r1)
+; PWR7-NEXT: std r0, 144(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 128
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: std r5, 120(r1)
; AIX64-PWR8-LABEL: cas_acqrel_acquire:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -128(r1)
+; AIX64-PWR8-NEXT: std r0, 144(r1)
; AIX64-PWR8-NEXT: std r5, 120(r1)
; AIX64-PWR8-NEXT: std r4, 112(r1)
; AIX64-PWR8-NEXT: addi r4, r1, 112
; PPC-PWR8-LABEL: cas_acqrel_acquire:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -48(r1)
+; PPC-PWR8-NEXT: stw r0, 52(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 48
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: mr r4, r3
; PWR7-LABEL: cas_acqrel_acquire_check_succ:
; PWR7: # %bb.0: # %entry
; PWR7-NEXT: mflr r0
-; PWR7-NEXT: std r0, 16(r1)
; PWR7-NEXT: stdu r1, -128(r1)
+; PWR7-NEXT: std r0, 144(r1)
; PWR7-NEXT: .cfi_def_cfa_offset 128
; PWR7-NEXT: .cfi_offset lr, 16
; PWR7-NEXT: std r5, 120(r1)
; AIX64-PWR8-LABEL: cas_acqrel_acquire_check_succ:
; AIX64-PWR8: # %bb.0: # %entry
; AIX64-PWR8-NEXT: mflr r0
-; AIX64-PWR8-NEXT: std r0, 16(r1)
; AIX64-PWR8-NEXT: stdu r1, -128(r1)
+; AIX64-PWR8-NEXT: std r0, 144(r1)
; AIX64-PWR8-NEXT: std r5, 120(r1)
; AIX64-PWR8-NEXT: std r4, 112(r1)
; AIX64-PWR8-NEXT: addi r4, r1, 112
; PPC-PWR8-LABEL: cas_acqrel_acquire_check_succ:
; PPC-PWR8: # %bb.0: # %entry
; PPC-PWR8-NEXT: mflr r0
-; PPC-PWR8-NEXT: stw r0, 4(r1)
; PPC-PWR8-NEXT: stwu r1, -48(r1)
+; PPC-PWR8-NEXT: stw r0, 52(r1)
; PPC-PWR8-NEXT: .cfi_def_cfa_offset 48
; PPC-PWR8-NEXT: .cfi_offset lr, 4
; PPC-PWR8-NEXT: mr r4, r3
; PPC32-LABEL: load_x_i64_unordered:
; PPC32: # %bb.0:
; PPC32-NEXT: mflr r0
-; PPC32-NEXT: stw r0, 4(r1)
; PPC32-NEXT: stwu r1, -16(r1)
+; PPC32-NEXT: stw r0, 20(r1)
; PPC32-NEXT: .cfi_def_cfa_offset 16
; PPC32-NEXT: .cfi_offset lr, 4
; PPC32-NEXT: addi r3, r3, -896
; PPC32-LABEL: store_x_i64_unordered:
; PPC32: # %bb.0:
; PPC32-NEXT: mflr r0
-; PPC32-NEXT: stw r0, 4(r1)
; PPC32-NEXT: stwu r1, -16(r1)
+; PPC32-NEXT: stw r0, 20(r1)
; PPC32-NEXT: .cfi_def_cfa_offset 16
; PPC32-NEXT: .cfi_offset lr, 4
; PPC32-NEXT: addi r3, r3, -896
; PPC32-LABEL: load_i64_seq_cst:
; PPC32: # %bb.0:
; PPC32-NEXT: mflr r0
-; PPC32-NEXT: stw r0, 4(r1)
; PPC32-NEXT: stwu r1, -16(r1)
+; PPC32-NEXT: stw r0, 20(r1)
; PPC32-NEXT: .cfi_def_cfa_offset 16
; PPC32-NEXT: .cfi_offset lr, 4
; PPC32-NEXT: li r4, 5
; PPC32-LABEL: store_i64_seq_cst:
; PPC32: # %bb.0:
; PPC32-NEXT: mflr r0
-; PPC32-NEXT: stw r0, 4(r1)
; PPC32-NEXT: stwu r1, -16(r1)
+; PPC32-NEXT: stw r0, 20(r1)
; PPC32-NEXT: .cfi_def_cfa_offset 16
; PPC32-NEXT: .cfi_offset lr, 4
; PPC32-NEXT: li r5, 0
; PPC32-LABEL: cas_weak_i64_release_monotonic:
; PPC32: # %bb.0:
; PPC32-NEXT: mflr r0
-; PPC32-NEXT: stw r0, 4(r1)
; PPC32-NEXT: stwu r1, -16(r1)
+; PPC32-NEXT: stw r0, 20(r1)
; PPC32-NEXT: .cfi_def_cfa_offset 16
; PPC32-NEXT: .cfi_offset lr, 4
; PPC32-NEXT: li r4, 0
; PPC32-LABEL: and_i64_release:
; PPC32: # %bb.0:
; PPC32-NEXT: mflr r0
-; PPC32-NEXT: stw r0, 4(r1)
; PPC32-NEXT: stwu r1, -16(r1)
+; PPC32-NEXT: stw r0, 20(r1)
; PPC32-NEXT: .cfi_def_cfa_offset 16
; PPC32-NEXT: .cfi_offset lr, 4
; PPC32-NEXT: li r7, 3
; CHECK-LABEL: test1:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: stbcx. 4, 0, 3
; CHECK-AIX-LABEL: test1:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: std 0, 16(1)
; CHECK-AIX-NEXT: stdu 1, -112(1)
+; CHECK-AIX-NEXT: std 0, 128(1)
; CHECK-AIX-NEXT: stbcx. 4, 0, 3
; CHECK-AIX-NEXT: bne 0, L..BB0_2
; CHECK-AIX-NEXT: # %bb.1: # %if.then
; CHECK-LABEL: test2:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: sthcx. 4, 0, 3
; CHECK-AIX-LABEL: test2:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: std 0, 16(1)
; CHECK-AIX-NEXT: stdu 1, -112(1)
+; CHECK-AIX-NEXT: std 0, 128(1)
; CHECK-AIX-NEXT: sthcx. 4, 0, 3
; CHECK-AIX-NEXT: bne 0, L..BB1_2
; CHECK-AIX-NEXT: # %bb.1: # %if.then
; CHECK-LABEL: test3:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: stwcx. 4, 0, 3
; CHECK-AIX-LABEL: test3:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: std 0, 16(1)
; CHECK-AIX-NEXT: stdu 1, -112(1)
+; CHECK-AIX-NEXT: std 0, 128(1)
; CHECK-AIX-NEXT: stwcx. 4, 0, 3
; CHECK-AIX-NEXT: bne 0, L..BB2_2
; CHECK-AIX-NEXT: # %bb.1: # %if.then
; CHECK-LABEL: test4:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: stdcx. 4, 0, 3
; CHECK-AIX-LABEL: test4:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: std 0, 16(1)
; CHECK-AIX-NEXT: stdu 1, -112(1)
+; CHECK-AIX-NEXT: std 0, 128(1)
; CHECK-AIX-NEXT: stdcx. 4, 0, 3
; CHECK-AIX-NEXT: bne 0, L..BB3_2
; CHECK-AIX-NEXT: # %bb.1: # %if.then
; CHECK-LABEL: bar:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -80(1)
+; CHECK-NEXT: std 0, 96(1)
; CHECK-NEXT: .cfi_def_cfa_offset 80
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addi 3, 1, 40
; CHECK-P8: # %bb.0: # %test_entry
; CHECK-P8-NEXT: mflr r0
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: bl dummy
; CHECK-P8-NEXT: nop
; CHECK-P9: # %bb.0: # %test_entry
; CHECK-P9-NEXT: mflr r0
; CHECK-P9-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P9-NEXT: std r0, 16(r1)
; CHECK-P9-NEXT: stdu r1, -48(r1)
+; CHECK-P9-NEXT: std r0, 64(r1)
; CHECK-P9-NEXT: mr r30, r3
; CHECK-P9-NEXT: bl dummy
; CHECK-P9-NEXT: nop
; CHECK-P9-BE-LABEL: no_crash_elt0_from_RHS:
; CHECK-P9-BE: # %bb.0: # %test_entry
; CHECK-P9-BE-NEXT: mflr r0
-; CHECK-P9-BE-NEXT: std r0, 16(r1)
; CHECK-P9-BE-NEXT: stdu r1, -128(r1)
+; CHECK-P9-BE-NEXT: std r0, 144(r1)
; CHECK-P9-BE-NEXT: std r30, 112(r1) # 8-byte Folded Spill
; CHECK-P9-BE-NEXT: mr r30, r3
; CHECK-P9-BE-NEXT: bl dummy
; CHECK-NOVSX: # %bb.0: # %test_entry
; CHECK-NOVSX-NEXT: mflr r0
; CHECK-NOVSX-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NOVSX-NEXT: std r0, 16(r1)
; CHECK-NOVSX-NEXT: stdu r1, -48(r1)
+; CHECK-NOVSX-NEXT: std r0, 64(r1)
; CHECK-NOVSX-NEXT: mr r30, r3
; CHECK-NOVSX-NEXT: bl dummy
; CHECK-NOVSX-NEXT: nop
; CHECK-P7: # %bb.0: # %test_entry
; CHECK-P7-NEXT: mflr r0
; CHECK-P7-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P7-NEXT: std r0, 16(r1)
; CHECK-P7-NEXT: stdu r1, -48(r1)
+; CHECK-P7-NEXT: std r0, 64(r1)
; CHECK-P7-NEXT: mr r30, r3
; CHECK-P7-NEXT: bl dummy
; CHECK-P7-NEXT: nop
; P8-AIX-64-LABEL: no_crash_elt0_from_RHS:
; P8-AIX-64: # %bb.0: # %test_entry
; P8-AIX-64-NEXT: mflr r0
-; P8-AIX-64-NEXT: std r0, 16(r1)
; P8-AIX-64-NEXT: stdu r1, -128(r1)
+; P8-AIX-64-NEXT: std r0, 144(r1)
; P8-AIX-64-NEXT: std r31, 120(r1) # 8-byte Folded Spill
; P8-AIX-64-NEXT: mr r31, r3
; P8-AIX-64-NEXT: bl .dummy[PR]
; P8-AIX-32-LABEL: no_crash_elt0_from_RHS:
; P8-AIX-32: # %bb.0: # %test_entry
; P8-AIX-32-NEXT: mflr r0
-; P8-AIX-32-NEXT: stw r0, 8(r1)
; P8-AIX-32-NEXT: stwu r1, -64(r1)
+; P8-AIX-32-NEXT: stw r0, 72(r1)
; P8-AIX-32-NEXT: stw r31, 60(r1) # 4-byte Folded Spill
; P8-AIX-32-NEXT: mr r31, r3
; P8-AIX-32-NEXT: bl .dummy[PR]
; CHECK-P9-LABEL: three_constants_ppcf128:
; CHECK-P9: # %bb.0: # %entry
; CHECK-P9-NEXT: mflr r0
-; CHECK-P9-NEXT: std r0, 16(r1)
; CHECK-P9-NEXT: stdu r1, -32(r1)
+; CHECK-P9-NEXT: std r0, 48(r1)
; CHECK-P9-NEXT: .cfi_def_cfa_offset 32
; CHECK-P9-NEXT: .cfi_offset lr, 16
; CHECK-P9-NEXT: addis r3, r2, .LCPI16_0@toc@ha
; CHECK-PWR9-NEXT: .cfi_offset lr, 16
; CHECK-PWR9-NEXT: .cfi_offset r30, -16
; CHECK-PWR9-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-PWR9-NEXT: std r0, 16(r1)
; CHECK-PWR9-NEXT: stdu r1, -48(r1)
; CHECK-PWR9-NEXT: mr r30, r3
; CHECK-PWR9-NEXT: addis r3, r2, a@toc@ha
+; CHECK-PWR9-NEXT: std r0, 64(r1)
; CHECK-PWR9-NEXT: lwa r3, a@toc@l(r3)
; CHECK-PWR9-NEXT: cmpld r3, r30
; CHECK-PWR9-NEXT: # implicit-def: $r3
; CHECK-LABEL: test1:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -128(r1)
+; CHECK-NEXT: std r0, 144(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 128
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-PWR9-NEXT: .cfi_offset lr, 16
; CHECK-PWR9-NEXT: .cfi_offset r30, -16
; CHECK-PWR9-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-PWR9-NEXT: std r0, 16(r1)
; CHECK-PWR9-NEXT: stdu r1, -48(r1)
; CHECK-PWR9-NEXT: mr r30, r3
; CHECK-PWR9-NEXT: li r3, 0
+; CHECK-PWR9-NEXT: std r0, 64(r1)
; CHECK-PWR9-NEXT: cmpldi r30, 0
; CHECK-PWR9-NEXT: beq cr0, .LBB1_3
; CHECK-PWR9-NEXT: # %bb.1: # %if.end
; CHECK-LABEL: test2:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -128(r1)
+; CHECK-NEXT: std r0, 144(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 128
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-PWR9-NEXT: .cfi_offset r30, -16
; CHECK-PWR9-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-PWR9-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-PWR9-NEXT: std r0, 16(r1)
; CHECK-PWR9-NEXT: stdu r1, -64(r1)
+; CHECK-PWR9-NEXT: std r0, 80(r1)
; CHECK-PWR9-NEXT: ld r30, 0(r3)
; CHECK-PWR9-NEXT: cmpldi r30, 0
; CHECK-PWR9-NEXT: beq cr0, .LBB2_2
; CHECK-LABEL: test3:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -144(r1)
+; CHECK-NEXT: std r0, 160(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 144
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r29, -24
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std 29, -24(1) # 8-byte Folded Spill
; CHECK-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -64(1)
; CHECK-NEXT: li 30, 0
; CHECK-NEXT: addi 29, 3, -8
+; CHECK-NEXT: std 0, 80(1)
; CHECK-NEXT: .p2align 5
; CHECK-NEXT: .LBB0_1: # %for.body
; CHECK-NEXT: #
; PWR8-LABEL: fmul_ctrloop_fp128:
; PWR8: # %bb.0: # %entry
; PWR8-NEXT: mflr 0
-; PWR8-NEXT: std 0, 16(1)
; PWR8-NEXT: stdu 1, -112(1)
; PWR8-NEXT: li 3, 48
+; PWR8-NEXT: std 0, 128(1)
; PWR8-NEXT: addis 4, 2, x@toc@ha
; PWR8-NEXT: std 28, 80(1) # 8-byte Folded Spill
; PWR8-NEXT: std 29, 88(1) # 8-byte Folded Spill
; PWR8-NEXT: std 30, 96(1) # 8-byte Folded Spill
; PWR8-NEXT: li 30, 0
-; PWR8-NEXT: li 29, 16
; PWR8-NEXT: addi 4, 4, x@toc@l
-; PWR8-NEXT: std 26, 64(1) # 8-byte Folded Spill
+; PWR8-NEXT: li 29, 16
; PWR8-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PWR8-NEXT: addis 3, 2, a@toc@ha
+; PWR8-NEXT: std 26, 64(1) # 8-byte Folded Spill
; PWR8-NEXT: std 27, 72(1) # 8-byte Folded Spill
; PWR8-NEXT: addi 3, 3, a@toc@l
; PWR8-NEXT: lxvd2x 0, 0, 3
; PWR8-NEXT: std 28, -32(1) # 8-byte Folded Spill
; PWR8-NEXT: std 29, -24(1) # 8-byte Folded Spill
; PWR8-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; PWR8-NEXT: std 0, 16(1)
; PWR8-NEXT: stdu 1, -64(1)
; PWR8-NEXT: addis 4, 2, y@toc@ha
; PWR8-NEXT: addi 30, 3, -8
; PWR8-NEXT: li 28, 0
+; PWR8-NEXT: std 0, 80(1)
; PWR8-NEXT: addi 4, 4, y@toc@l
; PWR8-NEXT: addi 29, 4, -16
; PWR8-NEXT: .p2align 4
; PWR8-NEXT: std 28, -32(1) # 8-byte Folded Spill
; PWR8-NEXT: std 29, -24(1) # 8-byte Folded Spill
; PWR8-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; PWR8-NEXT: std 0, 16(1)
; PWR8-NEXT: stdu 1, -64(1)
; PWR8-NEXT: addis 4, 2, x@toc@ha
; PWR8-NEXT: addi 30, 3, -8
; PWR8-NEXT: li 28, 0
+; PWR8-NEXT: std 0, 80(1)
; PWR8-NEXT: addi 4, 4, x@toc@l
; PWR8-NEXT: addi 29, 4, -16
; PWR8-NEXT: .p2align 4
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
; CHECK-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -48(1)
+; CHECK-NEXT: std 0, 64(1)
; CHECK-NEXT: addis 3, 13, __tls_guard@tprel@ha
; CHECK-NEXT: lbz 4, __tls_guard@tprel@l(3)
; CHECK-NEXT: andi. 4, 4, 1
declare ppc_fp128 @llvm.fmuladd.ppcf128(ppc_fp128, ppc_fp128, ppc_fp128) #2
define ppc_fp128 @test_ctr0() {
-; LE-LABEL: test_ctr0:
-; LE: # %bb.0: # %bb
-; LE-NEXT: mflr r0
-; LE-NEXT: .cfi_def_cfa_offset 48
-; LE-NEXT: .cfi_offset lr, 16
-; LE-NEXT: .cfi_offset r30, -16
-; LE-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; LE-NEXT: std r0, 16(r1)
-; LE-NEXT: stdu r1, -48(r1)
-; LE-NEXT: xxlxor f1, f1, f1
-; LE-NEXT: li r30, 0
-; LE-NEXT: xxlxor f2, f2, f2
-; LE-NEXT: .p2align 5
-; LE-NEXT: .LBB0_1: # %bb6
-; LE-NEXT: #
-; LE-NEXT: xxlxor f3, f3, f3
-; LE-NEXT: xxlxor f4, f4, f4
-; LE-NEXT: bl __gcc_qadd
-; LE-NEXT: nop
-; LE-NEXT: addi r30, r30, 4
-; LE-NEXT: cmpldi r30, 0
-; LE-NEXT: bne cr0, .LBB0_1
-; LE-NEXT: # %bb.2: # %bb14
-; LE-NEXT: addi r1, r1, 48
-; LE-NEXT: ld r0, 16(r1)
-; LE-NEXT: ld r30, -16(r1) # 8-byte Folded Reload
-; LE-NEXT: mtlr r0
-; LE-NEXT: blr
-;
; P9BE-LABEL: test_ctr0:
; P9BE: # %bb.0: # %bb
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -128(r1)
+; P9BE-NEXT: std r0, 144(r1)
; P9BE-NEXT: .cfi_def_cfa_offset 128
; P9BE-NEXT: .cfi_offset lr, 16
; P9BE-NEXT: .cfi_offset r30, -16
; P8BE-LABEL: test_ctr0:
; P8BE: # %bb.0: # %bb
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -128(r1)
+; P8BE-NEXT: std r0, 144(r1)
; P8BE-NEXT: .cfi_def_cfa_offset 128
; P8BE-NEXT: .cfi_offset lr, 16
; P8BE-NEXT: .cfi_offset r30, -16
bb14: ; preds = %bb6
ret ppc_fp128 %i8
}
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; LE: {{.*}}
; CHECK-LABEL: call_test_byval_mem1:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC0@toc@ha
; CHECK-LABEL: call_test_byval_mem1_2:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -112(1)
+; CHECK-NEXT: std 0, 128(1)
; CHECK-NEXT: .cfi_def_cfa_offset 112
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC0@toc@ha
; CHECK-LABEL: call_test_byval_mem1_3:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC0@toc@ha
; CHECK-LABEL: call_test_byval_mem1_4:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -112(1)
+; CHECK-NEXT: std 0, 128(1)
; CHECK-NEXT: .cfi_def_cfa_offset 112
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC0@toc@ha
; CHECK-LABEL: call_test_byval_mem1_5:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC0@toc@ha
; CHECK-LABEL: call_test_byval_mem2:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC1@toc@ha
; CHECK-LABEL: call_test_byval_mem3:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC2@toc@ha
; CHECK-LABEL: call_test_byval_mem4:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC3@toc@ha
; CHECK-LABEL: call_test_byval_mem8:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC4@toc@ha
; CHECK-LABEL: call_test_byval_mem32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC5@toc@ha
; CHECK-LABEL: call_test_byval_mem32_2:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC5@toc@ha
; CHECK-LABEL: call_test_byval_mem32_3:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -112(1)
+; CHECK-NEXT: std 0, 128(1)
; CHECK-NEXT: .cfi_def_cfa_offset 112
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC5@toc@ha
; CHECK-LABEL: call_test_byval_mem64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC6@toc@ha
; CHECK-LABEL: call_test_byval_mem65:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -112(1)
+; CHECK-NEXT: std 0, 128(1)
; CHECK-NEXT: .cfi_def_cfa_offset 112
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC7@toc@ha
; CHECK-GEN-ISEL-TRUE-NEXT: .cfi_offset r30, -16
; CHECK-GEN-ISEL-TRUE-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-GEN-ISEL-TRUE-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-GEN-ISEL-TRUE-NEXT: std r0, 16(r1)
; CHECK-GEN-ISEL-TRUE-NEXT: stdu r1, -64(r1)
; CHECK-GEN-ISEL-TRUE-NEXT: mr r30, r3
; CHECK-GEN-ISEL-TRUE-NEXT: # implicit-def: $x3
; CHECK-GEN-ISEL-TRUE-NEXT: # implicit-def: $r29
+; CHECK-GEN-ISEL-TRUE-NEXT: std r0, 80(r1)
; CHECK-GEN-ISEL-TRUE-NEXT: .p2align 4
; CHECK-GEN-ISEL-TRUE-NEXT: .LBB0_1: # %while.cond11
; CHECK-GEN-ISEL-TRUE-NEXT: #
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -64(r1)
; CHECK-NEXT: mr r30, r3
; CHECK-NEXT: # implicit-def: $x3
; CHECK-NEXT: # implicit-def: $r29
+; CHECK-NEXT: std r0, 80(r1)
; CHECK-NEXT: .p2align 4
; CHECK-NEXT: .LBB0_1: # %while.cond11
; CHECK-NEXT: #
; CHECK-P8-LABEL: testMixedAggregate_03:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -96(r1)
+; CHECK-P8-NEXT: std r0, 112(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 96
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -64(r1)
; CHECK-P8-NEXT: addis r11, r2, .LCPI17_0@toc@ha
; CHECK-P8-NEXT: cmpwi r3, 0
+; CHECK-P8-NEXT: std r0, 80(r1)
; CHECK-P8-NEXT: std r4, 104(r1)
; CHECK-P8-NEXT: std r5, 112(r1)
; CHECK-P8-NEXT: std r6, 120(r1)
-; CHECK-P8-NEXT: std r7, 128(r1)
; CHECK-P8-NEXT: addi r11, r11, .LCPI17_0@toc@l
; CHECK-P8-NEXT: lxvd2x vs0, 0, r11
+; CHECK-P8-NEXT: std r7, 128(r1)
; CHECK-P8-NEXT: std r8, 136(r1)
; CHECK-P8-NEXT: std r9, 144(r1)
; CHECK-P8-NEXT: std r10, 152(r1)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: vmr v3, v2
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: vmr v3, v2
; CHECK-P8-NEXT: bl __subkf3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: vmr v3, v2
; CHECK-P8-NEXT: bl __mulkf3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: vmr v3, v2
; CHECK-P8-NEXT: bl __divkf3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl sqrtf128
; CHECK-P8-NEXT: nop
; CHECK-LABEL: qp_sin:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qp_sin:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-LABEL: qp_cos:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qp_cos:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-LABEL: qp_log:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qp_log:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-LABEL: qp_log10:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qp_log10:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-LABEL: qp_log2:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qp_log2:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-LABEL: qp_minnum:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qp_minnum:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-LABEL: qp_maxnum:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qp_maxnum:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-LABEL: qp_pow:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qp_pow:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-LABEL: qp_exp:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qp_exp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-LABEL: qp_exp2:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qp_exp2:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
-; CHECK-NEXT: lxv v2, 0(r3)
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: mr r30, r5
+; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-NEXT: lwz r5, 0(r4)
; CHECK-NEXT: bl __powikf2
; CHECK-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lwz r3, 0(r4)
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: mr r5, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl __powikf2
; CHECK-LABEL: qp_frem:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis r3, r2, a@toc@ha
; CHECK-P8-LABEL: qp_frem:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a@toc@ha
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl ceilf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl floorf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl truncf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl roundf128
; CHECK-P8-NEXT: nop
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
-; CHECK-NEXT: lxv v2, 0(r3)
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: mr r30, r4
+; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-NEXT: bl lroundf128
; CHECK-NEXT: nop
; CHECK-NEXT: stw r3, 0(r30)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl lroundf128
; CHECK-P8-NEXT: nop
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
-; CHECK-NEXT: lxv v2, 0(r3)
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: mr r30, r4
+; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-NEXT: bl llroundf128
; CHECK-NEXT: nop
; CHECK-NEXT: std r3, 0(r30)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl llroundf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl rintf128
; CHECK-P8-NEXT: nop
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
-; CHECK-NEXT: lxv v2, 0(r3)
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: mr r30, r4
+; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-NEXT: bl lrintf128
; CHECK-NEXT: nop
; CHECK-NEXT: stw r3, 0(r30)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl lrintf128
; CHECK-P8-NEXT: nop
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
-; CHECK-NEXT: lxv v2, 0(r3)
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: mr r30, r4
+; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-NEXT: bl llrintf128
; CHECK-NEXT: nop
; CHECK-NEXT: std r3, 0(r30)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl llrintf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl nearbyintf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r6
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r6
; CHECK-P8-NEXT: lxvd2x vs2, 0, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; P8-LABEL: test_choice1:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr 0
-; P8-NEXT: std 0, 16(1)
; P8-NEXT: stdu 1, -112(1)
+; P8-NEXT: std 0, 128(1)
; P8-NEXT: bl __nekf2
; P8-NEXT: nop
; P8-NEXT: # kill: def $r3 killed $r3 killed $x3
; P9-LABEL: test_choice1:
; P9: # %bb.0: # %entry
; P9-NEXT: mflr 0
-; P9-NEXT: std 0, 16(1)
; P9-NEXT: stdu 1, -112(1)
+; P9-NEXT: std 0, 128(1)
; P9-NEXT: xscmpuqp 0, 2, 3
; P9-NEXT: bne 0, .LBB0_2
; P9-NEXT: b .LBB0_1
; P8-LABEL: test_choice2:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr 0
-; P8-NEXT: std 0, 16(1)
; P8-NEXT: stdu 1, -112(1)
+; P8-NEXT: std 0, 128(1)
; P8-NEXT: bl __lekf2
; P8-NEXT: nop
; P8-NEXT: # kill: def $r3 killed $r3 killed $x3
; P9-LABEL: test_choice2:
; P9: # %bb.0: # %entry
; P9-NEXT: mflr 0
-; P9-NEXT: std 0, 16(1)
; P9-NEXT: stdu 1, -112(1)
+; P9-NEXT: std 0, 128(1)
; P9-NEXT: xscmpuqp 0, 2, 3
; P9-NEXT: crmove 20, 3
; P9-NEXT: crnot 21, 20
; P8-LABEL: test_choice3:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr 0
-; P8-NEXT: std 0, 16(1)
; P8-NEXT: stdu 1, -112(1)
+; P8-NEXT: std 0, 128(1)
; P8-NEXT: bl __ltkf2
; P8-NEXT: nop
; P8-NEXT: # kill: def $r3 killed $r3 killed $x3
; P9-LABEL: test_choice3:
; P9: # %bb.0: # %entry
; P9-NEXT: mflr 0
-; P9-NEXT: std 0, 16(1)
; P9-NEXT: stdu 1, -112(1)
+; P9-NEXT: std 0, 128(1)
; P9-NEXT: xscmpuqp 0, 2, 3
; P9-NEXT: bge 0, .LBB2_2
; P9-NEXT: b .LBB2_1
; P8-LABEL: test_choice4:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr 0
-; P8-NEXT: std 0, 16(1)
; P8-NEXT: stdu 1, -112(1)
+; P8-NEXT: std 0, 128(1)
; P8-NEXT: bl __eqkf2
; P8-NEXT: nop
; P8-NEXT: # kill: def $r3 killed $r3 killed $x3
; P9-LABEL: test_choice4:
; P9: # %bb.0: # %entry
; P9-NEXT: mflr 0
-; P9-NEXT: std 0, 16(1)
; P9-NEXT: stdu 1, -112(1)
+; P9-NEXT: std 0, 128(1)
; P9-NEXT: xscmpuqp 0, 2, 3
; P9-NEXT: beq 0, .LBB3_2
; P9-NEXT: b .LBB3_1
; CHECK-P8-LABEL: greater_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a_qp@toc@ha
; CHECK-P8-LABEL: less_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a_qp@toc@ha
; CHECK-P8-LABEL: greater_eq_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a_qp@toc@ha
; CHECK-P8-LABEL: less_eq_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a_qp@toc@ha
; CHECK-P8-LABEL: equal_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a_qp@toc@ha
; CHECK-P8-LABEL: not_greater_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a_qp@toc@ha
; CHECK-P8-LABEL: not_less_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a_qp@toc@ha
; CHECK-P8-LABEL: not_greater_eq_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a_qp@toc@ha
; CHECK-P8-LABEL: not_less_eq_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a_qp@toc@ha
; CHECK-P8-LABEL: not_equal_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r3, r2, a_qp@toc@ha
; CHECK-P8-LABEL: greater_sel_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset v30, -32
; CHECK-P8-LABEL: less_sel_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset v30, -32
; CHECK-P8-LABEL: greater_eq_sel_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset v30, -32
; CHECK-P8-LABEL: less_eq_sel_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset v30, -32
; CHECK-P8-LABEL: equal_sel_qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset v30, -32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: mr r3, r4
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: bl __floatdikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: xxswapd vs0, v2
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
; CHECK-NEXT: mr r30, r3
; CHECK-NEXT: mr r3, r4
; CHECK-NEXT: mr r4, r5
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: bl __floattikf
; CHECK-NEXT: nop
; CHECK-NEXT: stxv v2, 0(r30)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: mr r3, r4
; CHECK-P8-NEXT: mr r4, r5
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: bl __floattikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: xxswapd vs0, v2
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: ld r4, 16(r4)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: ld r4, 0(r4)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
+; CHECK-P8-NEXT: ld r4, 0(r4)
; CHECK-P8-NEXT: mr r3, r4
; CHECK-P8-NEXT: bl __floatdikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: andi. r3, r4, 1
; CHECK-P8-NEXT: li r4, -1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: li r3, 0
; CHECK-P8-NEXT: iselgt r3, r4, r3
; CHECK-P8-NEXT: bl __floatsikf
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: mr r3, r4
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: bl __floatundikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: xxswapd vs0, v2
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
; CHECK-NEXT: mr r30, r3
; CHECK-NEXT: mr r3, r4
; CHECK-NEXT: mr r4, r5
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: bl __floatuntikf
; CHECK-NEXT: nop
; CHECK-NEXT: stxv v2, 0(r30)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: mr r3, r4
; CHECK-P8-NEXT: mr r4, r5
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: bl __floatuntikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: xxswapd vs0, v2
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC1@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC1@toc@l(r4)
; CHECK-P8-NEXT: ld r4, 32(r4)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: ld r4, 0(r4)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
+; CHECK-P8-NEXT: ld r4, 0(r4)
; CHECK-P8-NEXT: mr r3, r4
; CHECK-P8-NEXT: bl __floatundikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: clrldi r3, r4, 63
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: bl __floatsikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: xxswapd vs0, v2
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: lis r5, 1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ori r5, r5, 7797
; CHECK-P8-NEXT: ldx r4, r4, r5
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: lis r5, 1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ori r5, r5, 7797
; CHECK-P8-NEXT: ldx r4, r4, r5
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: mr r3, r4
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: bl __floatsikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: xxswapd vs0, v2
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lwa r4, 0(r4)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
+; CHECK-P8-NEXT: lwa r4, 0(r4)
; CHECK-P8-NEXT: mr r3, r4
; CHECK-P8-NEXT: bl __floatsikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC2@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC2@toc@l(r4)
; CHECK-P8-NEXT: lwa r4, 12(r4)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: mr r3, r4
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: bl __floatunsikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: xxswapd vs0, v2
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lwz r4, 0(r4)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
+; CHECK-P8-NEXT: lwz r4, 0(r4)
; CHECK-P8-NEXT: mr r3, r4
; CHECK-P8-NEXT: bl __floatunsikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC3@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC3@toc@l(r4)
; CHECK-P8-NEXT: lwz r4, 12(r4)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: lwz r3, 0(r5)
; CHECK-P8-NEXT: add r3, r3, r4
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: mr r3, r4
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: bl __floatunsikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: xxswapd vs0, v2
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lhz r4, 0(r4)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
+; CHECK-P8-NEXT: lhz r4, 0(r4)
; CHECK-P8-NEXT: mr r3, r4
; CHECK-P8-NEXT: bl __floatunsikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC4@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC4@toc@l(r4)
; CHECK-P8-NEXT: lhz r4, 6(r4)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: lhz r3, 0(r5)
; CHECK-P8-NEXT: add r3, r3, r4
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: mr r3, r4
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: bl __floatunsikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: xxswapd vs0, v2
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lbz r4, 0(r4)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
+; CHECK-P8-NEXT: lbz r4, 0(r4)
; CHECK-P8-NEXT: mr r3, r4
; CHECK-P8-NEXT: bl __floatunsikf
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC5@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC5@toc@l(r4)
; CHECK-P8-NEXT: lbz r4, 2(r4)
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: lbz r3, 0(r5)
; CHECK-P8-NEXT: add r3, r3, r4
; CHECK-P8-LABEL: qpConv2dp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC6@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC6@toc@l(r4)
; CHECK-P8-NEXT: lxvd2x vs0, 0, r4
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: addis r4, r2, .LC7@toc@ha
+; CHECK-P8-NEXT: std r0, 80(r1)
; CHECK-P8-NEXT: mr r29, r3
; CHECK-P8-NEXT: ld r4, .LC7@toc@l(r4)
; CHECK-P8-NEXT: lxvd2x vs0, 0, r4
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-LABEL: qpConv2sp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC6@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC6@toc@l(r4)
; CHECK-P8-NEXT: lxvd2x vs0, 0, r4
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: addis r4, r2, .LC7@toc@ha
+; CHECK-P8-NEXT: std r0, 80(r1)
; CHECK-P8-NEXT: mr r29, r3
; CHECK-P8-NEXT: ld r4, .LC7@toc@l(r4)
; CHECK-P8-NEXT: addi r4, r4, 48
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-LABEL: dpConv2qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl __extenddfkf2
; CHECK-P8-LABEL: dpConv2qp_02:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lfd f1, 0(r3)
; CHECK-P8-LABEL: dpConv2qp_02b:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: sldi r4, r4, 3
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -64(r1)
+; CHECK-P8-NEXT: std r0, 80(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: mr r29, r3
; CHECK-P8-NEXT: bl __extenddfkf2
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: bl __extenddfkf2
; CHECK-P8-NEXT: nop
; CHECK-P8-LABEL: spConv2qp:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl __extendsfkf2
; CHECK-P8-LABEL: spConv2qp_02:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lfs f1, 0(r3)
; CHECK-P8-LABEL: spConv2qp_02b:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: sldi r4, r4, 2
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -64(r1)
+; CHECK-P8-NEXT: std r0, 80(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: mr r29, r3
; CHECK-P8-NEXT: bl __extendsfkf2
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: bl __extendsfkf2
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: xscvdpsxws f0, f1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: mffprwz r3, f0
; CHECK-P8-NEXT: extsw r3, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: xscvdpsxds f0, f1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: mffprd r3, f0
; CHECK-P8-NEXT: bl __floatdikf
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: xscvdpsxws f0, f1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: mffprwz r3, f0
; CHECK-P8-NEXT: extsw r3, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: xscvdpsxds f0, f1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: mffprd r3, f0
; CHECK-P8-NEXT: bl __floatdikf
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: xscvdpuxws f0, f1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: mffprwz r3, f0
; CHECK-P8-NEXT: bl __floatunsikf
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: xscvdpuxds f0, f1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: mffprd r3, f0
; CHECK-P8-NEXT: bl __floatundikf
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: xscvdpuxws f0, f1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: mffprwz r3, f0
; CHECK-P8-NEXT: bl __floatunsikf
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: xscvdpuxds f0, f1
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: mffprd r3, f0
; CHECK-P8-NEXT: bl __floatundikf
; CHECK-LABEL: qpConv2i128:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qpConv2i128:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-LABEL: qpConv2ui128:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: lxv v2, 0(r3)
; CHECK-P8-LABEL: qpConv2ui128:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-LABEL: qpConv2ui1:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-LABEL: qpConv2si1:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-LABEL: qpFmadd:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-LABEL: qpFmadd_02:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -64(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
-; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
+; CHECK-P8-NEXT: std r0, 80(r1)
; CHECK-P8-NEXT: mr r30, r6
; CHECK-P8-NEXT: mr r29, r5
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __mulkf3
; CHECK-P8-LABEL: qpFnmadd:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -96(r1)
+; CHECK-P8-NEXT: std r0, 112(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 96
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
-; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: mr r30, r6
; CHECK-P8-NEXT: mr r29, r5
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __mulkf3
; CHECK-P8-LABEL: qpFmsub:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -64(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
-; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
+; CHECK-P8-NEXT: std r0, 80(r1)
; CHECK-P8-NEXT: mr r30, r6
; CHECK-P8-NEXT: mr r29, r5
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __mulkf3
; CHECK-P8-LABEL: qpFnmsub:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -96(r1)
+; CHECK-P8-NEXT: std r0, 112(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 96
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
-; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: mr r30, r6
; CHECK-P8-NEXT: mr r29, r5
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __mulkf3
; CHECK-P8-LABEL: loadConstant2:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-LABEL: fp128Param:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl __fixkfsi
; CHECK-P8-LABEL: fp128Return:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-LABEL: fp128Array:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: sldi r4, r4, 4
; CHECK-P8-LABEL: maxVecParam:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -224(r1)
+; CHECK-P8-NEXT: std r0, 240(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 224
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset v21, -176
; CHECK-P8-LABEL: mixParam_01:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-LABEL: mixParam_01f:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-LABEL: mixParam_02:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset f31, -8
; CHECK-P8-LABEL: mixParam_02f:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset f31, -8
; CHECK-P8-LABEL: mixParam_03:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-LABEL: mixParam_03f:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 80
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-LABEL: noopt_call_crash:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -96(r1)
+; CHECK-NEXT: std r0, 112(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 96
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl in
; CHECK-P8-LABEL: noopt_call_crash:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -96(r1)
+; CHECK-P8-NEXT: std r0, 112(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 96
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl in
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl truncf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl rintf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl nearbyintf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl roundf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl floorf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r4
+; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: bl ceilf128
; CHECK-P8-NEXT: nop
; CHECK-P8-LABEL: qpConv2sdw:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: addi r4, r4, 32
; CHECK-P8-LABEL: qpConv2sdw_03:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 80(r1)
; CHECK-P8-NEXT: mr r29, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: addi r4, r4, 32
; CHECK-P8-LABEL: qpConv2udw:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: addi r4, r4, 32
; CHECK-P8-LABEL: qpConv2udw_03:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -64(r1)
; CHECK-P8-NEXT: mr r30, r4
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 80(r1)
; CHECK-P8-NEXT: mr r29, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: lxvd2x vs0, 0, r4
; CHECK-P8-LABEL: qpConv2sw:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: addi r4, r4, 32
; CHECK-P8-LABEL: qpConv2sw_03:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-LABEL: qpConv2uw:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: addi r4, r4, 32
; CHECK-P8-LABEL: qpConv2uw_03:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-LABEL: qpConv2shw:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: addi r4, r4, 32
; CHECK-P8-LABEL: qpConv2shw_03:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-LABEL: qpConv2uhw:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: addi r4, r4, 32
; CHECK-P8-LABEL: qpConv2uhw_03:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-LABEL: qpConv2sb:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: addi r4, r4, 32
; CHECK-P8-LABEL: qpConv2sb_03:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-LABEL: qpConv2ub:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r3
; CHECK-P8-NEXT: ld r4, .LC0@toc@l(r4)
; CHECK-P8-NEXT: addi r4, r4, 32
; CHECK-P8-LABEL: qpConv2ub_03:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: addis r4, r2, .LC0@toc@ha
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
+; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
; CHECK-P8-NEXT: lxvd2x vs1, 0, r4
-; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: xxswapd v2, vs0
; CHECK-P8-NEXT: xxswapd v3, vs1
; CHECK-P8-NEXT: bl __addkf3
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: mr r30, r5
; CHECK-NEXT: bl __extendkftf2
; CHECK-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: bl __extendkftf2
; CHECK-P8-NEXT: nop
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: mr r30, r5
; CHECK-NEXT: bl __trunctfkf2
; CHECK-NEXT: nop
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: .cfi_offset r30, -16
; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: mr r30, r5
; CHECK-P8-NEXT: bl __trunctfkf2
; CHECK-P8-NEXT: nop
; ELF64-LABEL: bar:
; ELF64: # %bb.0: # %entry
; ELF64-NEXT: mflr 0
-; ELF64-NEXT: std 0, 16(1)
; ELF64-NEXT: stdu 1, -48(1)
+; ELF64-NEXT: std 0, 64(1)
; ELF64-NEXT: .cfi_def_cfa_offset 48
; ELF64-NEXT: .cfi_offset lr, 16
; ELF64-NEXT: li 3, 0
; AIX64-LABEL: bar:
; AIX64: # %bb.0: # %entry
; AIX64-NEXT: mflr 0
-; AIX64-NEXT: std 0, 16(1)
; AIX64-NEXT: stdu 1, -128(1)
+; AIX64-NEXT: std 0, 144(1)
; AIX64-NEXT: li 3, 0
; AIX64-NEXT: stw 3, 124(1)
; AIX64-NEXT: li 3, 0
; AIX64-NEXT: L..BB0_1: # %for.cond
; AIX64-NEXT: #
; AIX64-NEXT: lwz 3, 120(1)
-; AIX64-NEXT: ld 4, L..C0(2)
+; AIX64-NEXT: ld 4, L..C0(2) # @x
; AIX64-NEXT: lwz 4, 0(4)
; AIX64-NEXT: cmpw 3, 4
; AIX64-NEXT: bge 0, L..BB0_4
; CHECK-LABEL: test:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -192(1)
; CHECK-NEXT: addis 3, 2, a1@toc@ha
+; CHECK-NEXT: std 0, 208(1)
; CHECK-NEXT: addis 5, 2, a16@toc@ha
; CHECK-NEXT: addis 6, 2, a17@toc@ha
; CHECK-NEXT: addis 4, 2, a15@toc@ha
; FMF-LABEL: log2_approx:
; FMF: # %bb.0:
; FMF-NEXT: mflr 0
-; FMF-NEXT: std 0, 16(1)
; FMF-NEXT: stdu 1, -32(1)
+; FMF-NEXT: std 0, 48(1)
; FMF-NEXT: bl log2
; FMF-NEXT: nop
; FMF-NEXT: addi 1, 1, 32
; GLOBAL-LABEL: log2_approx:
; GLOBAL: # %bb.0:
; GLOBAL-NEXT: mflr 0
-; GLOBAL-NEXT: std 0, 16(1)
; GLOBAL-NEXT: stdu 1, -32(1)
+; GLOBAL-NEXT: std 0, 48(1)
; GLOBAL-NEXT: bl log2
; GLOBAL-NEXT: nop
; GLOBAL-NEXT: addi 1, 1, 32
attributes #0 = { "denormal-fp-math"="ieee,ieee" }
attributes #1 = { "denormal-fp-math"="preserve-sign,preserve-sign" }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; FMFDEBUG: {{.*}}
+; GLOBALDEBUG: {{.*}}
; CHECK-LABEL: test_fminf:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -16(1)
+; CHECK-NEXT: stw 0, 20(1)
; CHECK-NEXT: .cfi_def_cfa_offset 16
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: bl fminf
; CHECK-LABEL: test_fmin:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -16(1)
+; CHECK-NEXT: stw 0, 20(1)
; CHECK-NEXT: .cfi_def_cfa_offset 16
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: bl fmin
; CHECK-LABEL: test_fminl:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -112(1)
+; CHECK-NEXT: stw 0, 116(1)
; CHECK-NEXT: .cfi_def_cfa_offset 112
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: stfd 1, 40(1)
; CHECK-LABEL: test_intrinsic_fmin_f32:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -16(1)
+; CHECK-NEXT: stw 0, 20(1)
; CHECK-NEXT: .cfi_def_cfa_offset 16
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: bl fminf
; CHECK-LABEL: test_intrinsic_fmin_f64:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -16(1)
+; CHECK-NEXT: stw 0, 20(1)
; CHECK-NEXT: .cfi_def_cfa_offset 16
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: bl fmin
; CHECK-LABEL: test_intrinsic_fmin_f128:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -112(1)
+; CHECK-NEXT: stw 0, 116(1)
; CHECK-NEXT: .cfi_def_cfa_offset 112
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: stfd 1, 40(1)
; CHECK-LABEL: test_intrinsic_fminf_v2f32:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -32(1)
+; CHECK-NEXT: stw 0, 36(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: .cfi_offset f29, -24
; CHECK-LABEL: test_intrinsic_fmin_v4f32:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -64(1)
+; CHECK-NEXT: stw 0, 68(1)
; CHECK-NEXT: .cfi_def_cfa_offset 64
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: .cfi_offset f25, -56
; CHECK-LABEL: test_intrinsic_fmin_v8f32:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -128(1)
+; CHECK-NEXT: stw 0, 132(1)
; CHECK-NEXT: .cfi_def_cfa_offset 128
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: .cfi_offset f17, -120
; CHECK-LABEL: fminnum_const:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -96(1)
+; CHECK-NEXT: stw 0, 100(1)
; CHECK-NEXT: .cfi_def_cfa_offset 96
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: stfd 1, 40(1)
; CHECK-LABEL: f_i128_f:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: bl __fixsfti
; CHECK-NEXT: nop
; CHECK-NEXT: bl __floattisf
; P8-LABEL: q_to_i128:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixkfti
; P9-LABEL: q_to_i128:
; P9: # %bb.0: # %entry
; P9-NEXT: mflr r0
-; P9-NEXT: std r0, 16(r1)
; P9-NEXT: stdu r1, -32(r1)
+; P9-NEXT: std r0, 48(r1)
; P9-NEXT: .cfi_def_cfa_offset 32
; P9-NEXT: .cfi_offset lr, 16
; P9-NEXT: bl __fixkfti
; NOVSX-LABEL: q_to_i128:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixkfti
; P8-LABEL: q_to_u128:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixunskfti
; P9-LABEL: q_to_u128:
; P9: # %bb.0: # %entry
; P9-NEXT: mflr r0
-; P9-NEXT: std r0, 16(r1)
; P9-NEXT: stdu r1, -32(r1)
+; P9-NEXT: std r0, 48(r1)
; P9-NEXT: .cfi_def_cfa_offset 32
; P9-NEXT: .cfi_offset lr, 16
; P9-NEXT: bl __fixunskfti
; NOVSX-LABEL: q_to_u128:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixunskfti
; P8-LABEL: q_to_s1:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixkfsi
; NOVSX-LABEL: q_to_s1:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixkfsi
; P8-LABEL: q_to_u1:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixkfsi
; NOVSX-LABEL: q_to_u1:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixunskfsi
; P8-LABEL: ppcq_to_i128:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixtfti
; P9-LABEL: ppcq_to_i128:
; P9: # %bb.0: # %entry
; P9-NEXT: mflr r0
-; P9-NEXT: std r0, 16(r1)
; P9-NEXT: stdu r1, -32(r1)
+; P9-NEXT: std r0, 48(r1)
; P9-NEXT: .cfi_def_cfa_offset 32
; P9-NEXT: .cfi_offset lr, 16
; P9-NEXT: bl __fixtfti
; NOVSX-LABEL: ppcq_to_i128:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixtfti
; P8-LABEL: ppcq_to_u128:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixtfti
; P9-LABEL: ppcq_to_u128:
; P9: # %bb.0: # %entry
; P9-NEXT: mflr r0
-; P9-NEXT: std r0, 16(r1)
; P9-NEXT: stdu r1, -32(r1)
+; P9-NEXT: std r0, 48(r1)
; P9-NEXT: .cfi_def_cfa_offset 32
; P9-NEXT: .cfi_offset lr, 16
; P9-NEXT: bl __fixtfti
; NOVSX-LABEL: ppcq_to_u128:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixtfti
; P8-LABEL: q_to_i32:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixkfsi
; NOVSX-LABEL: q_to_i32:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixkfsi
; P8-LABEL: q_to_i64:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixkfdi
; NOVSX-LABEL: q_to_i64:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixkfdi
; P8-LABEL: q_to_u64:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixunskfdi
; NOVSX-LABEL: q_to_u64:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixunskfdi
; P8-LABEL: q_to_u32:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixunskfsi
; NOVSX-LABEL: q_to_u32:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixunskfsi
; P8-LABEL: ppcq_to_i64:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixtfdi
; P9-LABEL: ppcq_to_i64:
; P9: # %bb.0: # %entry
; P9-NEXT: mflr r0
-; P9-NEXT: std r0, 16(r1)
; P9-NEXT: stdu r1, -32(r1)
+; P9-NEXT: std r0, 48(r1)
; P9-NEXT: .cfi_def_cfa_offset 32
; P9-NEXT: .cfi_offset lr, 16
; P9-NEXT: bl __fixtfdi
; NOVSX-LABEL: ppcq_to_i64:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixtfdi
; P8-LABEL: ppcq_to_u64:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __fixunstfdi
; P9-LABEL: ppcq_to_u64:
; P9: # %bb.0: # %entry
; P9-NEXT: mflr r0
-; P9-NEXT: std r0, 16(r1)
; P9-NEXT: stdu r1, -32(r1)
+; P9-NEXT: std r0, 48(r1)
; P9-NEXT: .cfi_def_cfa_offset 32
; P9-NEXT: .cfi_offset lr, 16
; P9-NEXT: bl __fixunstfdi
; NOVSX-LABEL: ppcq_to_u64:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __fixunstfdi
; P8-LABEL: ppcq_to_u32:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -128(r1)
+; P8-NEXT: std r0, 144(r1)
; P8-NEXT: .cfi_def_cfa_offset 128
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: .cfi_offset r30, -16
; P9-NEXT: .cfi_offset lr, 16
; P9-NEXT: .cfi_offset r30, -16
; P9-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; P9-NEXT: std r0, 16(r1)
; P9-NEXT: stdu r1, -48(r1)
; P9-NEXT: addis r3, r2, .LCPI13_0@toc@ha
; P9-NEXT: xxlxor f3, f3, f3
+; P9-NEXT: std r0, 64(r1)
; P9-NEXT: lfs f0, .LCPI13_0@toc@l(r3)
; P9-NEXT: fcmpo cr1, f2, f3
; P9-NEXT: lis r3, -32768
-; P9-NEXT: fcmpo cr0, f1, f0
; P9-NEXT: xxlxor f3, f3, f3
+; P9-NEXT: fcmpo cr0, f1, f0
; P9-NEXT: crand 4*cr5+lt, eq, 4*cr1+lt
; P9-NEXT: crandc 4*cr5+gt, lt, eq
; P9-NEXT: cror 4*cr5+lt, 4*cr5+gt, 4*cr5+lt
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mfocrf r12, 32
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stw r12, 8(r1)
; NOVSX-NEXT: stdu r1, -48(r1)
+; NOVSX-NEXT: std r0, 64(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 48
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: .cfi_offset cr2, 8
; P8-LABEL: i1_to_q:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __floatsikf
; NOVSX-LABEL: i1_to_q:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __floatsikf
; P8-LABEL: u1_to_q:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __floatsikf
; NOVSX-LABEL: u1_to_q:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __floatunsikf
; P8-LABEL: i32_to_q:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __floatsikf
; NOVSX-LABEL: i32_to_q:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __floatsikf
; P8-LABEL: i64_to_q:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __floatdikf
; NOVSX-LABEL: i64_to_q:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __floatdikf
; P8-LABEL: u32_to_q:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __floatunsikf
; NOVSX-LABEL: u32_to_q:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __floatunsikf
; P8-LABEL: u64_to_q:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl __floatundikf
; NOVSX-LABEL: u64_to_q:
; NOVSX: # %bb.0: # %entry
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: .cfi_def_cfa_offset 32
; NOVSX-NEXT: .cfi_offset lr, 16
; NOVSX-NEXT: bl __floatundikf
; SPE-LABEL: d_to_i64:
; SPE: # %bb.0: # %entry
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: evmergelo r4, r3, r4
; SPE-LABEL: d_to_u64:
; SPE: # %bb.0: # %entry
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: evmergelo r4, r3, r4
; SPE-LABEL: f_to_i64:
; SPE: # %bb.0: # %entry
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: bl __fixsfdi
; SPE-LABEL: f_to_u64:
; SPE: # %bb.0: # %entry
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: bl __fixunssfdi
; SPE-LABEL: i64_to_d:
; SPE: # %bb.0: # %entry
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: bl __floatdidf
; SPE-LABEL: u64_to_d:
; SPE: # %bb.0: # %entry
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: bl __floatundidf
; SPE-LABEL: i64_to_f:
; SPE: # %bb.0: # %entry
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: bl __floatdisf
; SPE-LABEL: u64_to_f:
; SPE: # %bb.0: # %entry
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: bl __floatundisf
; CHECK-P8-LABEL: fadd_f128:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl __addkf3
; CHECK-P8-LABEL: fsub_f128:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl __subkf3
; CHECK-P8-LABEL: fmul_f128:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl __mulkf3
; CHECK-P8-LABEL: fdiv_f128:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl __divkf3
; CHECK-P8-LABEL: fmadd_f128:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl fmaf128
; CHECK-P8-LABEL: fmsub_f128:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 48
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: xxswapd vs0, v4
; CHECK-P8-LABEL: fnmadd_f128:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -48(r1)
+; CHECK-P8-NEXT: std r0, 64(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 48
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl fmaf128
; CHECK-P8-LABEL: fnmsub_f128:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -64(r1)
+; CHECK-P8-NEXT: std r0, 80(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 64
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: xxswapd vs0, v4
; CHECK-P8-LABEL: fsqrt_f128:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r0, 16(r1)
; CHECK-P8-NEXT: stdu r1, -32(r1)
+; CHECK-P8-NEXT: std r0, 48(r1)
; CHECK-P8-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-NEXT: .cfi_offset lr, 16
; CHECK-P8-NEXT: bl sqrtf128
; P8-LABEL: fcmp_olt_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __ltkf2
; P8-NEXT: nop
; P8-NEXT: rlwinm r3, r3, 1, 31, 31
; NOVSX-LABEL: fcmp_olt_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __ltkf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: rlwinm r3, r3, 1, 31, 31
; P8-LABEL: fcmp_ole_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __lekf2
; P8-NEXT: nop
; P8-NEXT: extsw r3, r3
; NOVSX-LABEL: fcmp_ole_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __lekf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: extsw r3, r3
; P8-LABEL: fcmp_ogt_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __gtkf2
; P8-NEXT: nop
; P8-NEXT: extsw r3, r3
; NOVSX-LABEL: fcmp_ogt_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __gtkf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: extsw r3, r3
; P8-LABEL: fcmp_oge_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __gekf2
; P8-NEXT: nop
; P8-NEXT: rlwinm r3, r3, 1, 31, 31
; NOVSX-LABEL: fcmp_oge_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __gekf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: rlwinm r3, r3, 1, 31, 31
; P8-LABEL: fcmp_oeq_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __eqkf2
; P8-NEXT: nop
; P8-NEXT: cntlzw r3, r3
; NOVSX-LABEL: fcmp_oeq_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __eqkf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: cntlzw r3, r3
; P8-LABEL: fcmp_one_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -176(r1)
; P8-NEXT: li r3, 128
+; P8-NEXT: std r0, 192(r1)
; P8-NEXT: std r30, 160(r1) # 8-byte Folded Spill
; P8-NEXT: stxvd2x v30, r1, r3 # 16-byte Folded Spill
; P8-NEXT: li r3, 144
; NOVSX-NEXT: std r28, -32(r1) # 8-byte Folded Spill
; NOVSX-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; NOVSX-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -80(r1)
+; NOVSX-NEXT: std r0, 96(r1)
; NOVSX-NEXT: mr r30, r6
; NOVSX-NEXT: mr r29, r5
; NOVSX-NEXT: mr r28, r4
; P8-LABEL: fcmp_ult_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __gekf2
; P8-NEXT: nop
; P8-NEXT: rlwinm r3, r3, 1, 31, 31
; NOVSX-LABEL: fcmp_ult_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __gekf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: rlwinm r3, r3, 1, 31, 31
; P8-LABEL: fcmp_ule_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __gtkf2
; P8-NEXT: nop
; P8-NEXT: extsw r3, r3
; NOVSX-LABEL: fcmp_ule_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __gtkf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: extsw r3, r3
; P8-LABEL: fcmp_ugt_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __lekf2
; P8-NEXT: nop
; P8-NEXT: extsw r3, r3
; NOVSX-LABEL: fcmp_ugt_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __lekf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: extsw r3, r3
; P8-LABEL: fcmp_uge_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __ltkf2
; P8-NEXT: nop
; P8-NEXT: rlwinm r3, r3, 1, 31, 31
; NOVSX-LABEL: fcmp_uge_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __ltkf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: rlwinm r3, r3, 1, 31, 31
; P8-LABEL: fcmp_ueq_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -176(r1)
; P8-NEXT: li r3, 128
+; P8-NEXT: std r0, 192(r1)
; P8-NEXT: std r30, 160(r1) # 8-byte Folded Spill
; P8-NEXT: stxvd2x v30, r1, r3 # 16-byte Folded Spill
; P8-NEXT: li r3, 144
; NOVSX-NEXT: std r28, -32(r1) # 8-byte Folded Spill
; NOVSX-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; NOVSX-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -80(r1)
+; NOVSX-NEXT: std r0, 96(r1)
; NOVSX-NEXT: mr r30, r6
; NOVSX-NEXT: mr r29, r5
; NOVSX-NEXT: mr r28, r4
; P8-LABEL: fcmp_une_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __nekf2
; P8-NEXT: nop
; P8-NEXT: cntlzw r3, r3
; NOVSX-LABEL: fcmp_une_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __nekf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: cntlzw r3, r3
; P8-LABEL: fcmps_olt_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __ltkf2
; P8-NEXT: nop
; P8-NEXT: rlwinm r3, r3, 1, 31, 31
; NOVSX-LABEL: fcmps_olt_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __ltkf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: rlwinm r3, r3, 1, 31, 31
; P8-LABEL: fcmps_ole_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __lekf2
; P8-NEXT: nop
; P8-NEXT: extsw r3, r3
; NOVSX-LABEL: fcmps_ole_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __lekf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: extsw r3, r3
; P8-LABEL: fcmps_ogt_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __gtkf2
; P8-NEXT: nop
; P8-NEXT: extsw r3, r3
; NOVSX-LABEL: fcmps_ogt_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __gtkf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: extsw r3, r3
; P8-LABEL: fcmps_oge_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __gekf2
; P8-NEXT: nop
; P8-NEXT: rlwinm r3, r3, 1, 31, 31
; NOVSX-LABEL: fcmps_oge_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __gekf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: rlwinm r3, r3, 1, 31, 31
; P8-LABEL: fcmps_oeq_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __eqkf2
; P8-NEXT: nop
; P8-NEXT: cntlzw r3, r3
; NOVSX-LABEL: fcmps_oeq_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __eqkf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: cntlzw r3, r3
; P8-LABEL: fcmps_one_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -176(r1)
; P8-NEXT: li r3, 128
+; P8-NEXT: std r0, 192(r1)
; P8-NEXT: std r30, 160(r1) # 8-byte Folded Spill
; P8-NEXT: stxvd2x v30, r1, r3 # 16-byte Folded Spill
; P8-NEXT: li r3, 144
; NOVSX-NEXT: std r28, -32(r1) # 8-byte Folded Spill
; NOVSX-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; NOVSX-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -80(r1)
+; NOVSX-NEXT: std r0, 96(r1)
; NOVSX-NEXT: mr r30, r6
; NOVSX-NEXT: mr r29, r5
; NOVSX-NEXT: mr r28, r4
; P8-LABEL: fcmps_ult_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __gekf2
; P8-NEXT: nop
; P8-NEXT: rlwinm r3, r3, 1, 31, 31
; NOVSX-LABEL: fcmps_ult_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __gekf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: rlwinm r3, r3, 1, 31, 31
; P8-LABEL: fcmps_ule_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __gtkf2
; P8-NEXT: nop
; P8-NEXT: extsw r3, r3
; NOVSX-LABEL: fcmps_ule_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __gtkf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: extsw r3, r3
; P8-LABEL: fcmps_ugt_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __lekf2
; P8-NEXT: nop
; P8-NEXT: extsw r3, r3
; NOVSX-LABEL: fcmps_ugt_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __lekf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: extsw r3, r3
; P8-LABEL: fcmps_uge_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __ltkf2
; P8-NEXT: nop
; P8-NEXT: rlwinm r3, r3, 1, 31, 31
; NOVSX-LABEL: fcmps_uge_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __ltkf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: rlwinm r3, r3, 1, 31, 31
; P8-LABEL: fcmps_ueq_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -176(r1)
; P8-NEXT: li r3, 128
+; P8-NEXT: std r0, 192(r1)
; P8-NEXT: std r30, 160(r1) # 8-byte Folded Spill
; P8-NEXT: stxvd2x v30, r1, r3 # 16-byte Folded Spill
; P8-NEXT: li r3, 144
; NOVSX-NEXT: std r28, -32(r1) # 8-byte Folded Spill
; NOVSX-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; NOVSX-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -80(r1)
+; NOVSX-NEXT: std r0, 96(r1)
; NOVSX-NEXT: mr r30, r6
; NOVSX-NEXT: mr r29, r5
; NOVSX-NEXT: mr r28, r4
; P8-LABEL: fcmps_une_f128:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: bl __nekf2
; P8-NEXT: nop
; P8-NEXT: cntlzw r3, r3
; NOVSX-LABEL: fcmps_une_f128:
; NOVSX: # %bb.0:
; NOVSX-NEXT: mflr r0
-; NOVSX-NEXT: std r0, 16(r1)
; NOVSX-NEXT: stdu r1, -32(r1)
+; NOVSX-NEXT: std r0, 48(r1)
; NOVSX-NEXT: bl __nekf2
; NOVSX-NEXT: nop
; NOVSX-NEXT: cntlzw r3, r3
; P8-LABEL: nearbyint_f64:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: .cfi_def_cfa_offset 112
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: bl nearbyint
; P9-LABEL: nearbyint_f64:
; P9: # %bb.0:
; P9-NEXT: mflr r0
-; P9-NEXT: std r0, 16(r1)
; P9-NEXT: stdu r1, -32(r1)
+; P9-NEXT: std r0, 48(r1)
; P9-NEXT: .cfi_def_cfa_offset 32
; P9-NEXT: .cfi_offset lr, 16
; P9-NEXT: bl nearbyint
; P8-LABEL: nearbyint_v4f32:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -176(r1)
+; P8-NEXT: std r0, 192(r1)
; P8-NEXT: .cfi_def_cfa_offset 176
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: .cfi_offset v29, -48
; P9-LABEL: nearbyint_v4f32:
; P9: # %bb.0:
; P9-NEXT: mflr r0
-; P9-NEXT: std r0, 16(r1)
; P9-NEXT: stdu r1, -80(r1)
+; P9-NEXT: std r0, 96(r1)
; P9-NEXT: .cfi_def_cfa_offset 80
; P9-NEXT: .cfi_offset lr, 16
; P9-NEXT: .cfi_offset v29, -48
; P8-LABEL: nearbyint_v2f64:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -160(r1)
+; P8-NEXT: std r0, 176(r1)
; P8-NEXT: .cfi_def_cfa_offset 160
; P8-NEXT: .cfi_offset lr, 16
; P8-NEXT: .cfi_offset v30, -32
; P9-LABEL: nearbyint_v2f64:
; P9: # %bb.0:
; P9-NEXT: mflr r0
-; P9-NEXT: std r0, 16(r1)
; P9-NEXT: stdu r1, -64(r1)
+; P9-NEXT: std r0, 80(r1)
; P9-NEXT: .cfi_def_cfa_offset 64
; P9-NEXT: .cfi_offset lr, 16
; P9-NEXT: .cfi_offset v30, -32
; SPE-LABEL: fmadd_f32:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: bl fmaf
; SPE-LABEL: fmadd_f64:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: evmergelo r8, r7, r8
; SPE-LABEL: fmadd_v4f32:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -96(r1)
+; SPE-NEXT: stw r0, 100(r1)
; SPE-NEXT: .cfi_def_cfa_offset 96
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: .cfi_offset r21, -88
; SPE-LABEL: fmadd_v2f64:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -64(r1)
+; SPE-NEXT: stw r0, 68(r1)
; SPE-NEXT: .cfi_def_cfa_offset 64
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: .cfi_offset r26, -48
; SPE-LABEL: fmsub_f32:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: efsneg r5, r5
; SPE-LABEL: fmsub_f64:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: evmergelo r6, r5, r6
; SPE-LABEL: fmsub_v4f32:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -96(r1)
+; SPE-NEXT: stw r0, 100(r1)
; SPE-NEXT: .cfi_def_cfa_offset 96
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: .cfi_offset r21, -88
; SPE-LABEL: fmsub_v2f64:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -64(r1)
+; SPE-NEXT: stw r0, 68(r1)
; SPE-NEXT: .cfi_def_cfa_offset 64
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: .cfi_offset r26, -48
; SPE-LABEL: fnmadd_f32:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: bl fmaf
; SPE-LABEL: fnmadd_f64:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: evmergelo r8, r7, r8
; SPE-LABEL: fnmadd_v4f32:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -96(r1)
+; SPE-NEXT: stw r0, 100(r1)
; SPE-NEXT: .cfi_def_cfa_offset 96
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: .cfi_offset r21, -88
; SPE-LABEL: fnmadd_v2f64:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -64(r1)
+; SPE-NEXT: stw r0, 68(r1)
; SPE-NEXT: .cfi_def_cfa_offset 64
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: .cfi_offset r26, -48
; SPE-LABEL: fnmsub_f32:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: efsneg r5, r5
; SPE-LABEL: fnmsub_f64:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: evmergelo r6, r5, r6
; SPE-LABEL: fnmsub_v4f32:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -96(r1)
+; SPE-NEXT: stw r0, 100(r1)
; SPE-NEXT: .cfi_def_cfa_offset 96
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: .cfi_offset r21, -88
; SPE-LABEL: fnmsub_v2f64:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -64(r1)
+; SPE-NEXT: stw r0, 68(r1)
; SPE-NEXT: .cfi_def_cfa_offset 64
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: .cfi_offset r26, -48
; SPE-LABEL: fsqrt_f32:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: bl sqrtf
; SPE-LABEL: fsqrt_f64:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -16(r1)
+; SPE-NEXT: stw r0, 20(r1)
; SPE-NEXT: .cfi_def_cfa_offset 16
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: evmergelo r4, r3, r4
; SPE-LABEL: fsqrt_v4f32:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -48(r1)
+; SPE-NEXT: stw r0, 52(r1)
; SPE-NEXT: .cfi_def_cfa_offset 48
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: .cfi_offset r27, -40
; SPE-LABEL: fsqrt_v2f64:
; SPE: # %bb.0:
; SPE-NEXT: mflr r0
-; SPE-NEXT: stw r0, 4(r1)
; SPE-NEXT: stwu r1, -48(r1)
+; SPE-NEXT: stw r0, 52(r1)
; SPE-NEXT: .cfi_def_cfa_offset 48
; SPE-NEXT: .cfi_offset lr, 4
; SPE-NEXT: .cfi_offset r28, -32
; PPC64-P8-LE-LABEL: test_copysign:
; PPC64-P8-LE: # %bb.0: # %entry
; PPC64-P8-LE-NEXT: mflr 0
-; PPC64-P8-LE-NEXT: std 0, 16(1)
; PPC64-P8-LE-NEXT: stdu 1, -32(1)
+; PPC64-P8-LE-NEXT: std 0, 48(1)
; PPC64-P8-LE-NEXT: bl copysignl
; PPC64-P8-LE-NEXT: nop
; PPC64-P8-LE-NEXT: mffprd 3, 1
; PPC64-LE-LABEL: test_copysign:
; PPC64-LE: # %bb.0: # %entry
; PPC64-LE-NEXT: mflr 0
-; PPC64-LE-NEXT: std 0, 16(1)
; PPC64-LE-NEXT: stdu 1, -48(1)
+; PPC64-LE-NEXT: std 0, 64(1)
; PPC64-LE-NEXT: bl copysignl
; PPC64-LE-NEXT: nop
; PPC64-LE-NEXT: stfd 1, 32(1)
; PPC64-P8-BE-LABEL: test_copysign:
; PPC64-P8-BE: # %bb.0: # %entry
; PPC64-P8-BE-NEXT: mflr 0
-; PPC64-P8-BE-NEXT: std 0, 16(1)
; PPC64-P8-BE-NEXT: stdu 1, -112(1)
+; PPC64-P8-BE-NEXT: std 0, 128(1)
; PPC64-P8-BE-NEXT: bl copysignl
; PPC64-P8-BE-NEXT: nop
; PPC64-P8-BE-NEXT: mffprd 3, 1
; PPC64-BE-LABEL: test_copysign:
; PPC64-BE: # %bb.0: # %entry
; PPC64-BE-NEXT: mflr 0
-; PPC64-BE-NEXT: std 0, 16(1)
; PPC64-BE-NEXT: stdu 1, -128(1)
+; PPC64-BE-NEXT: std 0, 144(1)
; PPC64-BE-NEXT: bl copysignl
; PPC64-BE-NEXT: nop
; PPC64-BE-NEXT: stfd 1, 112(1)
; PPC32-LABEL: test_copysign:
; PPC32: # %bb.0: # %entry
; PPC32-NEXT: mflr 0
-; PPC32-NEXT: stw 0, 4(1)
; PPC32-NEXT: stwu 1, -96(1)
+; PPC32-NEXT: stw 0, 100(1)
; PPC32-NEXT: stfd 1, 40(1)
; PPC32-NEXT: lwz 3, 44(1)
; PPC32-NEXT: stfd 2, 32(1)
; CHECK-LABEL: frem32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl fmodf
; CHECK-LABEL: frem64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl fmod
; CHECK-LABEL: frem4x32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -96(1)
+; CHECK-NEXT: std 0, 112(1)
; CHECK-NEXT: .cfi_def_cfa_offset 96
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset v28, -64
; CHECK-LABEL: frem2x64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -80(1)
+; CHECK-NEXT: std 0, 96(1)
; CHECK-NEXT: .cfi_def_cfa_offset 80
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset v29, -48
; CHECK32_32-LABEL: fshl_i37:
; CHECK32_32: # %bb.0:
; CHECK32_32-NEXT: mflr 0
-; CHECK32_32-NEXT: stw 0, 4(1)
; CHECK32_32-NEXT: stwu 1, -32(1)
+; CHECK32_32-NEXT: stw 0, 36(1)
; CHECK32_32-NEXT: .cfi_def_cfa_offset 32
; CHECK32_32-NEXT: .cfi_offset lr, 4
; CHECK32_32-NEXT: .cfi_offset r27, -20
; CHECK32_64-LABEL: fshl_i37:
; CHECK32_64: # %bb.0:
; CHECK32_64-NEXT: mflr 0
-; CHECK32_64-NEXT: stw 0, 4(1)
; CHECK32_64-NEXT: stwu 1, -32(1)
+; CHECK32_64-NEXT: stw 0, 36(1)
; CHECK32_64-NEXT: .cfi_def_cfa_offset 32
; CHECK32_64-NEXT: .cfi_offset lr, 4
; CHECK32_64-NEXT: .cfi_offset r27, -20
; CHECK32_32-LABEL: fshr_i37:
; CHECK32_32: # %bb.0:
; CHECK32_32-NEXT: mflr 0
-; CHECK32_32-NEXT: stw 0, 4(1)
; CHECK32_32-NEXT: stwu 1, -32(1)
+; CHECK32_32-NEXT: stw 0, 36(1)
; CHECK32_32-NEXT: .cfi_def_cfa_offset 32
; CHECK32_32-NEXT: .cfi_offset lr, 4
; CHECK32_32-NEXT: .cfi_offset r27, -20
; CHECK32_64-LABEL: fshr_i37:
; CHECK32_64: # %bb.0:
; CHECK32_64-NEXT: mflr 0
-; CHECK32_64-NEXT: stw 0, 4(1)
; CHECK32_64-NEXT: stwu 1, -32(1)
+; CHECK32_64-NEXT: stw 0, 36(1)
; CHECK32_64-NEXT: .cfi_def_cfa_offset 32
; CHECK32_64-NEXT: .cfi_offset lr, 4
; CHECK32_64-NEXT: .cfi_offset r27, -20
; P8-LABEL: loadd:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -32(r1)
+; P8-NEXT: std r0, 48(r1)
; P8-NEXT: lhz r3, 2(r3)
; P8-NEXT: bl __gnu_h2f_ieee
; P8-NEXT: nop
; SOFT-LABEL: loadd:
; SOFT: # %bb.0: # %entry
; SOFT-NEXT: mflr r0
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -32(r1)
+; SOFT-NEXT: std r0, 48(r1)
; SOFT-NEXT: lhz r3, 2(r3)
; SOFT-NEXT: bl __gnu_h2f_ieee
; SOFT-NEXT: nop
; P8-LABEL: loadf:
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -32(r1)
+; P8-NEXT: std r0, 48(r1)
; P8-NEXT: lhz r3, 2(r3)
; P8-NEXT: bl __gnu_h2f_ieee
; P8-NEXT: nop
; SOFT-LABEL: loadf:
; SOFT: # %bb.0: # %entry
; SOFT-NEXT: mflr r0
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -32(r1)
+; SOFT-NEXT: std r0, 48(r1)
; SOFT-NEXT: lhz r3, 2(r3)
; SOFT-NEXT: bl __gnu_h2f_ieee
; SOFT-NEXT: nop
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
; P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -48(r1)
+; P8-NEXT: std r0, 64(r1)
; P8-NEXT: mr r30, r3
; P8-NEXT: bl __truncdfhf2
; P8-NEXT: nop
; SOFT: # %bb.0: # %entry
; SOFT-NEXT: mflr r0
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -48(r1)
; SOFT-NEXT: mr r30, r3
; SOFT-NEXT: mr r3, r4
+; SOFT-NEXT: std r0, 64(r1)
; SOFT-NEXT: bl __truncdfhf2
; SOFT-NEXT: nop
; SOFT-NEXT: clrldi r3, r3, 48
; P8: # %bb.0: # %entry
; P8-NEXT: mflr r0
; P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -48(r1)
+; P8-NEXT: std r0, 64(r1)
; P8-NEXT: mr r30, r3
; P8-NEXT: bl __gnu_f2h_ieee
; P8-NEXT: nop
; SOFT: # %bb.0: # %entry
; SOFT-NEXT: mflr r0
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -48(r1)
; SOFT-NEXT: mr r30, r3
; SOFT-NEXT: clrldi r3, r4, 32
+; SOFT-NEXT: std r0, 64(r1)
; SOFT-NEXT: bl __gnu_f2h_ieee
; SOFT-NEXT: nop
; SOFT-NEXT: clrldi r3, r3, 48
; SOFT: # %bb.0:
; SOFT-NEXT: mflr r0
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -48(r1)
-; SOFT-NEXT: lhz r3, 0(r3)
+; SOFT-NEXT: std r0, 64(r1)
; SOFT-NEXT: mr r30, r4
+; SOFT-NEXT: lhz r3, 0(r3)
; SOFT-NEXT: bl __gnu_h2f_ieee
; SOFT-NEXT: nop
; SOFT-NEXT: bl __gnu_f2h_ieee
; P8-LABEL: test_extend32:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -32(r1)
+; P8-NEXT: std r0, 48(r1)
; P8-NEXT: lhz r3, 0(r3)
; P8-NEXT: bl __gnu_h2f_ieee
; P8-NEXT: nop
; SOFT-LABEL: test_extend32:
; SOFT: # %bb.0:
; SOFT-NEXT: mflr r0
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -32(r1)
+; SOFT-NEXT: std r0, 48(r1)
; SOFT-NEXT: lhz r3, 0(r3)
; SOFT-NEXT: bl __gnu_h2f_ieee
; SOFT-NEXT: nop
; P8-LABEL: test_extend64:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -32(r1)
+; P8-NEXT: std r0, 48(r1)
; P8-NEXT: lhz r3, 0(r3)
; P8-NEXT: bl __gnu_h2f_ieee
; P8-NEXT: nop
; SOFT-LABEL: test_extend64:
; SOFT: # %bb.0:
; SOFT-NEXT: mflr r0
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -32(r1)
+; SOFT-NEXT: std r0, 48(r1)
; SOFT-NEXT: lhz r3, 0(r3)
; SOFT-NEXT: bl __gnu_h2f_ieee
; SOFT-NEXT: nop
; P8: # %bb.0:
; P8-NEXT: mflr r0
; P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -48(r1)
+; P8-NEXT: std r0, 64(r1)
; P8-NEXT: mr r30, r4
; P8-NEXT: bl __gnu_f2h_ieee
; P8-NEXT: nop
; SOFT: # %bb.0:
; SOFT-NEXT: mflr r0
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -48(r1)
; SOFT-NEXT: clrldi r3, r3, 32
+; SOFT-NEXT: std r0, 64(r1)
; SOFT-NEXT: mr r30, r4
; SOFT-NEXT: bl __gnu_f2h_ieee
; SOFT-NEXT: nop
; P8: # %bb.0:
; P8-NEXT: mflr r0
; P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -48(r1)
+; P8-NEXT: std r0, 64(r1)
; P8-NEXT: mr r30, r4
; P8-NEXT: bl __truncdfhf2
; P8-NEXT: nop
; SOFT: # %bb.0:
; SOFT-NEXT: mflr r0
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -48(r1)
+; SOFT-NEXT: std r0, 64(r1)
; SOFT-NEXT: mr r30, r4
; SOFT-NEXT: bl __truncdfhf2
; SOFT-NEXT: nop
; P8-LABEL: test_fptosi_i64:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -32(r1)
+; P8-NEXT: std r0, 48(r1)
; P8-NEXT: lhz r3, 0(r3)
; P8-NEXT: bl __gnu_h2f_ieee
; P8-NEXT: nop
; SOFT-LABEL: test_fptosi_i64:
; SOFT: # %bb.0:
; SOFT-NEXT: mflr r0
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -32(r1)
+; SOFT-NEXT: std r0, 48(r1)
; SOFT-NEXT: lhz r3, 0(r3)
; SOFT-NEXT: bl __gnu_h2f_ieee
; SOFT-NEXT: nop
; P8: # %bb.0:
; P8-NEXT: mflr r0
; P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -48(r1)
; P8-NEXT: mtfprd f0, r3
+; P8-NEXT: std r0, 64(r1)
; P8-NEXT: mr r30, r4
; P8-NEXT: xscvsxdsp f1, f0
; P8-NEXT: bl __gnu_f2h_ieee
; SOFT: # %bb.0:
; SOFT-NEXT: mflr r0
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -48(r1)
+; SOFT-NEXT: std r0, 64(r1)
; SOFT-NEXT: mr r30, r4
; SOFT-NEXT: bl __floatdisf
; SOFT-NEXT: nop
; P8-LABEL: test_fptoui_i64:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -32(r1)
+; P8-NEXT: std r0, 48(r1)
; P8-NEXT: lhz r3, 0(r3)
; P8-NEXT: bl __gnu_h2f_ieee
; P8-NEXT: nop
; SOFT-LABEL: test_fptoui_i64:
; SOFT: # %bb.0:
; SOFT-NEXT: mflr r0
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -32(r1)
+; SOFT-NEXT: std r0, 48(r1)
; SOFT-NEXT: lhz r3, 0(r3)
; SOFT-NEXT: bl __gnu_h2f_ieee
; SOFT-NEXT: nop
; P8: # %bb.0:
; P8-NEXT: mflr r0
; P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -48(r1)
; P8-NEXT: mtfprd f0, r3
+; P8-NEXT: std r0, 64(r1)
; P8-NEXT: mr r30, r4
; P8-NEXT: xscvuxdsp f1, f0
; P8-NEXT: bl __gnu_f2h_ieee
; SOFT: # %bb.0:
; SOFT-NEXT: mflr r0
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -48(r1)
+; SOFT-NEXT: std r0, 64(r1)
; SOFT-NEXT: mr r30, r4
; SOFT-NEXT: bl __floatundisf
; SOFT-NEXT: nop
; P8-LABEL: test_extend32_vec4:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: li r4, 48
; P8-NEXT: std r30, 96(r1) # 8-byte Folded Spill
; P8-NEXT: mr r30, r3
; SOFT-NEXT: std r28, -32(r1) # 8-byte Folded Spill
; SOFT-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -80(r1)
+; SOFT-NEXT: std r0, 96(r1)
; SOFT-NEXT: mr r30, r3
; SOFT-NEXT: lhz r3, 0(r3)
; SOFT-NEXT: bl __gnu_h2f_ieee
; P8-LABEL: test_extend64_vec4:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: li r4, 48
; P8-NEXT: std r30, 96(r1) # 8-byte Folded Spill
; P8-NEXT: mr r30, r3
; SOFT-NEXT: std r28, -32(r1) # 8-byte Folded Spill
; SOFT-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -80(r1)
+; SOFT-NEXT: std r0, 96(r1)
; SOFT-NEXT: mr r30, r3
; SOFT-NEXT: lhz r3, 0(r3)
; SOFT-NEXT: bl __gnu_h2f_ieee
; P8-LABEL: test_trunc32_vec4:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -112(r1)
; P8-NEXT: xxsldwi vs0, vs34, vs34, 3
; P8-NEXT: li r3, 48
+; P8-NEXT: std r0, 128(r1)
; P8-NEXT: std r27, 72(r1) # 8-byte Folded Spill
; P8-NEXT: std r28, 80(r1) # 8-byte Folded Spill
; P8-NEXT: std r29, 88(r1) # 8-byte Folded Spill
-; P8-NEXT: std r30, 96(r1) # 8-byte Folded Spill
-; P8-NEXT: mr r30, r5
; P8-NEXT: xscvspdpn f1, vs0
+; P8-NEXT: std r30, 96(r1) # 8-byte Folded Spill
; P8-NEXT: stxvd2x vs63, r1, r3 # 16-byte Folded Spill
+; P8-NEXT: mr r30, r5
; P8-NEXT: vmr v31, v2
; P8-NEXT: bl __gnu_f2h_ieee
; P8-NEXT: nop
; SOFT-NEXT: std r28, -32(r1) # 8-byte Folded Spill
; SOFT-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -80(r1)
; SOFT-NEXT: mr r27, r3
; SOFT-NEXT: clrldi r3, r6, 32
+; SOFT-NEXT: std r0, 96(r1)
; SOFT-NEXT: mr r30, r7
; SOFT-NEXT: mr r29, r5
; SOFT-NEXT: mr r28, r4
; P8-LABEL: test_trunc64_vec4:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -128(r1)
; P8-NEXT: li r3, 48
+; P8-NEXT: std r0, 144(r1)
; P8-NEXT: xxswapd vs1, vs34
; P8-NEXT: std r27, 88(r1) # 8-byte Folded Spill
; P8-NEXT: std r28, 96(r1) # 8-byte Folded Spill
; P8-NEXT: std r29, 104(r1) # 8-byte Folded Spill
-; P8-NEXT: std r30, 112(r1) # 8-byte Folded Spill
-; P8-NEXT: mr r30, r7
; P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; P8-NEXT: stxvd2x vs62, r1, r3 # 16-byte Folded Spill
; P8-NEXT: li r3, 64
+; P8-NEXT: std r30, 112(r1) # 8-byte Folded Spill
+; P8-NEXT: mr r30, r7
; P8-NEXT: vmr v30, v2
; P8-NEXT: stxvd2x vs63, r1, r3 # 16-byte Folded Spill
; P8-NEXT: vmr v31, v3
; SOFT-NEXT: std r28, -32(r1) # 8-byte Folded Spill
; SOFT-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -80(r1)
; SOFT-NEXT: mr r27, r3
; SOFT-NEXT: mr r3, r6
+; SOFT-NEXT: std r0, 96(r1)
; SOFT-NEXT: mr r30, r7
; SOFT-NEXT: mr r29, r5
; SOFT-NEXT: mr r28, r4
; P8-NEXT: mflr r0
; P8-NEXT: std r30, -24(r1) # 8-byte Folded Spill
; P8-NEXT: stfd f31, -8(r1) # 8-byte Folded Spill
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -64(r1)
+; P8-NEXT: std r0, 80(r1)
; P8-NEXT: mr r30, r3
; P8-NEXT: lhz r3, 0(r4)
; P8-NEXT: bl __gnu_h2f_ieee
; SOFT-NEXT: mflr r0
; SOFT-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; SOFT-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -64(r1)
+; SOFT-NEXT: std r0, 80(r1)
; SOFT-NEXT: mr r30, r3
; SOFT-NEXT: lhz r3, 0(r4)
; SOFT-NEXT: bl __gnu_h2f_ieee
; P8-LABEL: PR40273:
; P8: # %bb.0:
; P8-NEXT: mflr r0
-; P8-NEXT: std r0, 16(r1)
; P8-NEXT: stdu r1, -32(r1)
+; P8-NEXT: std r0, 48(r1)
; P8-NEXT: bl __gnu_f2h_ieee
; P8-NEXT: nop
; P8-NEXT: clrldi r3, r3, 48
; SOFT-LABEL: PR40273:
; SOFT: # %bb.0:
; SOFT-NEXT: mflr r0
-; SOFT-NEXT: std r0, 16(r1)
; SOFT-NEXT: stdu r1, -32(r1)
; SOFT-NEXT: clrldi r3, r3, 48
+; SOFT-NEXT: std r0, 48(r1)
; SOFT-NEXT: bl __gnu_h2f_ieee
; SOFT-NEXT: nop
; SOFT-NEXT: li r4, 0
; CHECK-LABEL: @main
-; CHECK-DAG: mr [[REG:[0-9]+]], 3
-; CHECK-DAG: li 0, 1076
-; CHECK: stw [[REG]],
+; CHECK: mr [[REG:[0-9]+]], 3
+; CHECK: std 0,
+; CHECK: stw [[REG]],
; CHECK: #APP
; CHECK: sc
; CHECK-LABEL: test:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
; CHECK-NEXT: addi r3, r3, -1
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: cmplwi r3, 5
; CHECK-NEXT: bgt cr0, .LBB0_3
; CHECK-NEXT: # %bb.1: # %entry
; CHECK-LABEL: caller:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -320(r1)
+; CHECK-NEXT: std r0, 336(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 320
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset r14, -288
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: .cfi_offset f31, -8
; CHECK-LNX-NEXT: stfd 31, -8(1) # 8-byte Folded Spill
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -48(1)
; CHECK-LNX-NEXT: addis 3, 2, .LCPI0_0@toc@ha
+; CHECK-LNX-NEXT: std 0, 64(1)
; CHECK-LNX-NEXT: xssqrtdp 31, 0
; CHECK-LNX-NEXT: lfs 1, .LCPI0_0@toc@l(3)
; CHECK-LNX-NEXT: bl __xl_cos
; CHECK-AIX-LABEL: cos_f64:
; CHECK-AIX: # %bb.0: # %bb
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; CHECK-AIX-NEXT: bl .sqrt[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: .cfi_offset f31, -8
; CHECK-LNX-NEXT: stfd 31, -8(1) # 8-byte Folded Spill
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -48(1)
; CHECK-LNX-NEXT: addis 3, 2, .LCPI1_0@toc@ha
+; CHECK-LNX-NEXT: std 0, 64(1)
; CHECK-LNX-NEXT: xssqrtdp 31, 0
; CHECK-LNX-NEXT: lfs 1, .LCPI1_0@toc@l(3)
; CHECK-LNX-NEXT: bl __xl_log
; CHECK-AIX-LABEL: log_f64:
; CHECK-AIX: # %bb.0: # %bb
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; CHECK-AIX-NEXT: bl .sqrt[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: cos_f64:
; CHECK-LNX: # %bb.0: # %bb
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI0_0@toc@ha
; CHECK-AIX-LABEL: cos_f64:
; CHECK-AIX: # %bb.0: # %bb
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; CHECK-AIX-NEXT: bl .sqrt[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: log_f64:
; CHECK-LNX: # %bb.0: # %bb
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI1_0@toc@ha
; CHECK-AIX-LABEL: log_f64:
; CHECK-AIX: # %bb.0: # %bb
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; CHECK-AIX-NEXT: bl .sqrt[PR]
; CHECK-AIX-NEXT: nop
; CHECK-P9-NEXT: std r28, -32(r1) # 8-byte Folded Spill
; CHECK-P9-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-P9-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P9-NEXT: std r0, 16(r1)
; CHECK-P9-NEXT: stdu r1, -80(r1)
; CHECK-P9-NEXT: mr r30, r4
; CHECK-P9-NEXT: mr r29, r3
; CHECK-P9-NEXT: lis r3, 21845
+; CHECK-P9-NEXT: std r0, 96(r1)
; CHECK-P9-NEXT: add r28, r30, r29
; CHECK-P9-NEXT: ori r27, r3, 21846
; CHECK-P9-NEXT: b .LBB1_4
; CHECK-LABEL: length2_eq_nobuiltin_attr:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
; CHECK-NEXT: li 5, 2
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: bl memcmp
; CHECK-NEXT: nop
; CHECK-NEXT: cntlzw 3, 3
define void @no_duplicate1(i64 %a) {
; CHECK-LABEL: no_duplicate1
; CHECK: mr 30, 3
+; CHECK-NEXT: std 0, 64(1)
; CHECK-NEXT: b .LBB0_2
; CHECK: .LBB0_2:
define void @no_duplicate2(i64 %a) {
; CHECK-LABEL: no_duplicate2
; CHECK: mr 30, 3
+; CHECK-NEXT: std 0, 64(1)
; CHECK-NEXT: b .LBB1_2
; CHECK: .LBB1_2:
; CHECK-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
; CHECK-NEXT: std r31, -8(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -192(r1)
+; CHECK-NEXT: std r0, 208(r1)
; CHECK-NEXT: std r5, 32(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r3, 40(r1) # 8-byte Folded Spill
; CHECK-NEXT: mr r0, r4
+; CHECK-NEXT: std r3, 40(r1) # 8-byte Folded Spill
; CHECK-NEXT: ld r3, 40(r1) # 8-byte Folded Reload
; CHECK-NEXT: #APP
; CHECK-NEXT: add r3, r3, r0
; CHECK-P9-LABEL: main:
; CHECK-P9: # %bb.0: # %bb
; CHECK-P9-NEXT: mflr r0
-; CHECK-P9-NEXT: std r0, 16(r1)
; CHECK-P9-NEXT: stdu r1, -32(r1)
+; CHECK-P9-NEXT: std r0, 48(r1)
; CHECK-P9-NEXT: .cfi_def_cfa_offset 32
; CHECK-P9-NEXT: .cfi_offset lr, 16
; CHECK-P9-NEXT: bl malloc
; CHECK-P8-LE-LABEL: store_f128_to_uint:
; CHECK-P8-LE: # %bb.0: # %entry
; CHECK-P8-LE-NEXT: mflr r0
-; CHECK-P8-LE-NEXT: std r0, 16(r1)
; CHECK-P8-LE-NEXT: stdu r1, -32(r1)
+; CHECK-P8-LE-NEXT: std r0, 48(r1)
; CHECK-P8-LE-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-LE-NEXT: .cfi_offset lr, 16
; CHECK-P8-LE-NEXT: bl __fixunskfdi
; CHECK-P8-BE-LABEL: store_f128_to_uint:
; CHECK-P8-BE: # %bb.0: # %entry
; CHECK-P8-BE-NEXT: mflr r0
-; CHECK-P8-BE-NEXT: std r0, 16(r1)
; CHECK-P8-BE-NEXT: stdu r1, -112(r1)
+; CHECK-P8-BE-NEXT: std r0, 128(r1)
; CHECK-P8-BE-NEXT: .cfi_def_cfa_offset 112
; CHECK-P8-BE-NEXT: .cfi_offset lr, 16
; CHECK-P8-BE-NEXT: bl __fixunskfdi
; CHECK-P8-LE-LABEL: store_f128_to_sint:
; CHECK-P8-LE: # %bb.0: # %entry
; CHECK-P8-LE-NEXT: mflr r0
-; CHECK-P8-LE-NEXT: std r0, 16(r1)
; CHECK-P8-LE-NEXT: stdu r1, -32(r1)
+; CHECK-P8-LE-NEXT: std r0, 48(r1)
; CHECK-P8-LE-NEXT: .cfi_def_cfa_offset 32
; CHECK-P8-LE-NEXT: .cfi_offset lr, 16
; CHECK-P8-LE-NEXT: bl __fixkfdi
; CHECK-P8-BE-LABEL: store_f128_to_sint:
; CHECK-P8-BE: # %bb.0: # %entry
; CHECK-P8-BE-NEXT: mflr r0
-; CHECK-P8-BE-NEXT: std r0, 16(r1)
; CHECK-P8-BE-NEXT: stdu r1, -112(r1)
+; CHECK-P8-BE-NEXT: std r0, 128(r1)
; CHECK-P8-BE-NEXT: .cfi_def_cfa_offset 112
; CHECK-P8-BE-NEXT: .cfi_offset lr, 16
; CHECK-P8-BE-NEXT: bl __fixkfdi
; CHECK-AIX-LABEL: llvmintr_powf_f32_fast025:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C0(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_powf_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-AIX-LABEL: llvmintr_pow_f64_fast025:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C1(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_pow_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-AIX-LABEL: llvmintr_powf_f32_fast075:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C2(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_powf_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-AIX-LABEL: llvmintr_pow_f64_fast075:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C3(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_pow_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: llvmintr_powf_f32_fast050:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI4_0@toc@ha
; CHECK-AIX-LABEL: llvmintr_powf_f32_fast050:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C4(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_powf_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: llvmintr_pow_f64_fast050:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI5_0@toc@ha
; CHECK-AIX-LABEL: llvmintr_pow_f64_fast050:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C5(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_pow_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: powf_f32_fast025:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI0_0@toc@ha
; CHECK-AIX-LABEL: powf_f32_fast025:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C0(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_powf_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: pow_f64_fast025:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI1_0@toc@ha
; CHECK-AIX-LABEL: pow_f64_fast025:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C1(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_pow_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: powf_f32_fast075:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI2_0@toc@ha
; CHECK-AIX-LABEL: powf_f32_fast075:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C2(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_powf_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: pow_f64_fast075:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI3_0@toc@ha
; CHECK-AIX-LABEL: pow_f64_fast075:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C3(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_pow_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: powf_f32_fast050:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI4_0@toc@ha
; CHECK-AIX-LABEL: powf_f32_fast050:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C4(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_powf_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: pow_f64_fast050:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI5_0@toc@ha
; CHECK-AIX-LABEL: pow_f64_fast050:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C5(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_pow_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: __powf_finite_f32_fast025:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI6_0@toc@ha
; CHECK-AIX-LABEL: __powf_finite_f32_fast025:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C6(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_powf_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: __pow_finite_f64_fast025:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI7_0@toc@ha
; CHECK-AIX-LABEL: __pow_finite_f64_fast025:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C7(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_pow_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: __powf_finite_f32_fast075:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI8_0@toc@ha
; CHECK-AIX-LABEL: __powf_finite_f32_fast075:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C8(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_powf_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: __pow_finite_f64_fast075:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI9_0@toc@ha
; CHECK-AIX-LABEL: __pow_finite_f64_fast075:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C9(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_pow_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: __powf_finite_f32_fast050:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI10_0@toc@ha
; CHECK-AIX-LABEL: __powf_finite_f32_fast050:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C10(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_powf_finite[PR]
; CHECK-AIX-NEXT: nop
; CHECK-LNX-LABEL: __pow_finite_f64_fast050:
; CHECK-LNX: # %bb.0: # %entry
; CHECK-LNX-NEXT: mflr 0
-; CHECK-LNX-NEXT: std 0, 16(1)
; CHECK-LNX-NEXT: stdu 1, -32(1)
+; CHECK-LNX-NEXT: std 0, 48(1)
; CHECK-LNX-NEXT: .cfi_def_cfa_offset 32
; CHECK-LNX-NEXT: .cfi_offset lr, 16
; CHECK-LNX-NEXT: addis 3, 2, .LCPI11_0@toc@ha
; CHECK-AIX-LABEL: __pow_finite_f64_fast050:
; CHECK-AIX: # %bb.0: # %entry
; CHECK-AIX-NEXT: mflr 0
-; CHECK-AIX-NEXT: stw 0, 8(1)
; CHECK-AIX-NEXT: stwu 1, -64(1)
; CHECK-AIX-NEXT: lwz 3, L..C11(2) # %const.0
+; CHECK-AIX-NEXT: stw 0, 72(1)
; CHECK-AIX-NEXT: lfs 2, 0(3)
; CHECK-AIX-NEXT: bl .__xl_pow_finite[PR]
; CHECK-AIX-NEXT: nop
define i32 @_Z4funci(i32 %a) ssp {
; CHECK: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -32(1)
; CHECK-NEXT: stw 31, 28(1)
+; CHECK-NEXT: stw 0, 36(1)
; CHECK: mr 31, 1
entry:
%a_addr = alloca i32 ; <ptr> [#uses=2]
; RUN: llc -mtriple=powerpc-ibm-aix-xcoff -mattr=-altivec -mcpu=pwr8 %s -o - -verify-machineinstrs | FileCheck %s --check-prefixes=CHECK,ENABLE,CHECK-32,ENABLE-32
; RUN: llc -mtriple=powerpc-ibm-aix-xcoff %s -o - -enable-shrink-wrap=false -verify-machineinstrs | FileCheck %s --check-prefixes=CHECK,DISABLE,CHECK-32,DISABLE-32
; RUN: llc -mtriple=powerpc64-ibm-aix-xcoff -mattr=-altivec -mcpu=pwr8 %s -o - -verify-machineinstrs | FileCheck %s --check-prefixes=CHECK,ENABLE,CHECK-64,ENABLE-64
-; RUN: llc -mtriple=powerpc64-ibm-aix-xcoff %s -o - -enable-shrink-wrap=false -verify-machineinstrs | FileCheck %s --check-prefixes=CHECK,DISABLE,CHECK-64,DISABLE-64
+; RUN: llc -mtriple=powerpc64-ibm-aix-xcoff %s -o - -enable-shrink-wrap=false -verify-machineinstrs | FileCheck %s --check-prefixes=CHECK,DISABLE,CHECK-64,DISABLE-64,DISABLE-64-AIX
;
;
; Note: Lots of tests use inline asm instead of regular calls.
; Compare the arguments and jump to exit.
; After the prologue is set.
; DISABLE: cmpw 3, 4
+; DISABLE-32: stw 0,
+; DISABLE-64-AIX: std 0,
; DISABLE-NEXT: bge 0, {{.*}}[[EXIT_LABEL:BB[0-9_]+]]
;
; Store %a on the stack
; CHECK: mflr {{[0-9]+}}
;
; DISABLE: cmplwi 3, 0
+; DISABLE-32: stw 0, 72(1)
+; DISABLE-64-AIX: std 0,
; DISABLE-NEXT: beq 0, {{.*}}[[ELSE_LABEL:BB[0-9_]+]]
;
; Setup of the varags.
; CHECK-32-NEXT: mr 7, 4
; CHECK-32-NEXT: mr 8, 4
; CHECK-32-NEXT: mr 9, 4
+; ENABLE-32-NEXT: stw 0, 72(1)
;
; CHECK-NEXT: bl {{.*}}someVariadicFunc
; CHECK: slwi 3, 3, 3
; DISABLE: mflr {{[0-9]+}}
;
; CHECK: cmplwi 3, 0
+; DISABLE-32: stw 0, 72(1)
+; DISABLE-64-AIX: std 0,
; CHECK-NEXT: bne{{[-]?}} 0, {{.*}}[[ABORT:BB[0-9_]+]]
;
; CHECK: li 3, 42
define ptr @nest_caller(ptr %arg) nounwind {
; CHECK-LABEL: nest_caller:
; CHECK: mr 11, 3
+; CHECK: stw 0, 20(1)
; CHECK-NEXT: bl nest_receiver
; CHECK: blr
; CHECK-PWR8-LABEL: setbf128:
; CHECK-PWR8: # %bb.0:
; CHECK-PWR8-NEXT: mflr r0
-; CHECK-PWR8-NEXT: std r0, 16(r1)
; CHECK-PWR8-NEXT: stdu r1, -96(r1)
+; CHECK-PWR8-NEXT: std r0, 112(r1)
; CHECK-PWR8-NEXT: .cfi_def_cfa_offset 96
; CHECK-PWR8-NEXT: .cfi_offset lr, 16
; CHECK-PWR8-NEXT: .cfi_offset r30, -16
; P8LE-LABEL: caller_9:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -80(r1)
+; P8LE-NEXT: std r0, 96(r1)
; P8LE-NEXT: stb r4, 56(r1)
; P8LE-NEXT: addi r5, r1, 71
; P8LE-NEXT: std r3, 48(r1)
; P9LE-LABEL: caller_9:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -80(r1)
+; P9LE-NEXT: std r0, 96(r1)
; P9LE-NEXT: stb r4, 56(r1)
; P9LE-NEXT: addi r4, r1, 71
-; P9LE-NEXT: std r3, 48(r1)
; P9LE-NEXT: lbz r5, 56(r1)
+; P9LE-NEXT: std r3, 48(r1)
; P9LE-NEXT: stdx r3, 0, r4
; P9LE-NEXT: mr r3, r4
; P9LE-NEXT: stb r5, 79(r1)
; P8BE-LABEL: caller_9:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -144(r1)
+; P8BE-NEXT: std r0, 160(r1)
; P8BE-NEXT: stb r4, 200(r1)
; P8BE-NEXT: addi r5, r1, 135
; P8BE-NEXT: std r3, 192(r1)
; P9BE-LABEL: caller_9:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -144(r1)
+; P9BE-NEXT: std r0, 160(r1)
; P9BE-NEXT: stb r4, 200(r1)
; P9BE-NEXT: addi r4, r1, 135
-; P9BE-NEXT: std r3, 192(r1)
; P9BE-NEXT: lbz r5, 200(r1)
+; P9BE-NEXT: std r3, 192(r1)
; P9BE-NEXT: stdx r3, 0, r4
; P9BE-NEXT: mr r3, r4
; P9BE-NEXT: stb r5, 143(r1)
; P8LE-LABEL: caller_9_callee_9:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -80(r1)
+; P8LE-NEXT: std r0, 96(r1)
; P8LE-NEXT: stb r4, 56(r1)
; P8LE-NEXT: addi r5, r1, 71
; P8LE-NEXT: std r3, 48(r1)
; P8LE-NEXT: lbz r4, 56(r1)
; P8LE-NEXT: stdx r3, 0, r5
-; P8LE-NEXT: ld r3, 48(r1)
; P8LE-NEXT: stb r4, 79(r1)
; P8LE-NEXT: lbz r4, 56(r1)
+; P8LE-NEXT: ld r3, 48(r1)
; P8LE-NEXT: bl callee_9
; P8LE-NEXT: nop
; P8LE-NEXT: li r3, 0
; P9LE-LABEL: caller_9_callee_9:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -80(r1)
+; P9LE-NEXT: std r0, 96(r1)
; P9LE-NEXT: stb r4, 56(r1)
; P9LE-NEXT: addi r4, r1, 71
-; P9LE-NEXT: std r3, 48(r1)
; P9LE-NEXT: lbz r5, 56(r1)
+; P9LE-NEXT: std r3, 48(r1)
; P9LE-NEXT: stdx r3, 0, r4
; P9LE-NEXT: lbz r4, 56(r1)
; P9LE-NEXT: ld r3, 48(r1)
; P8BE-LABEL: caller_9_callee_9:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -144(r1)
+; P8BE-NEXT: std r0, 160(r1)
; P8BE-NEXT: stb r4, 200(r1)
; P8BE-NEXT: addi r5, r1, 135
; P8BE-NEXT: std r3, 192(r1)
; P8BE-NEXT: lbz r4, 200(r1)
; P8BE-NEXT: stdx r3, 0, r5
-; P8BE-NEXT: ld r3, 192(r1)
; P8BE-NEXT: stb r4, 143(r1)
; P8BE-NEXT: lbz r4, 200(r1)
+; P8BE-NEXT: ld r3, 192(r1)
; P8BE-NEXT: bl callee_9
; P8BE-NEXT: nop
; P8BE-NEXT: li r3, 0
; P9BE-LABEL: caller_9_callee_9:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -144(r1)
+; P9BE-NEXT: std r0, 160(r1)
; P9BE-NEXT: stb r4, 200(r1)
; P9BE-NEXT: addi r4, r1, 135
-; P9BE-NEXT: std r3, 192(r1)
; P9BE-NEXT: lbz r5, 200(r1)
+; P9BE-NEXT: std r3, 192(r1)
; P9BE-NEXT: stdx r3, 0, r4
; P9BE-NEXT: lbz r4, 200(r1)
; P9BE-NEXT: ld r3, 192(r1)
; P8LE-LABEL: caller_10:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -80(r1)
+; P8LE-NEXT: std r0, 96(r1)
; P8LE-NEXT: sth r4, 56(r1)
; P8LE-NEXT: addi r5, r1, 70
; P8LE-NEXT: std r3, 48(r1)
; P9LE-LABEL: caller_10:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -80(r1)
+; P9LE-NEXT: std r0, 96(r1)
; P9LE-NEXT: sth r4, 56(r1)
; P9LE-NEXT: addi r4, r1, 70
-; P9LE-NEXT: std r3, 48(r1)
; P9LE-NEXT: lhz r5, 56(r1)
+; P9LE-NEXT: std r3, 48(r1)
; P9LE-NEXT: stdx r3, 0, r4
; P9LE-NEXT: mr r3, r4
; P9LE-NEXT: sth r5, 78(r1)
; P8BE-LABEL: caller_10:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -144(r1)
+; P8BE-NEXT: std r0, 160(r1)
; P8BE-NEXT: sth r4, 200(r1)
; P8BE-NEXT: addi r5, r1, 134
; P8BE-NEXT: std r3, 192(r1)
; P9BE-LABEL: caller_10:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -144(r1)
+; P9BE-NEXT: std r0, 160(r1)
; P9BE-NEXT: sth r4, 200(r1)
; P9BE-NEXT: addi r4, r1, 134
-; P9BE-NEXT: std r3, 192(r1)
; P9BE-NEXT: lhz r5, 200(r1)
+; P9BE-NEXT: std r3, 192(r1)
; P9BE-NEXT: stdx r3, 0, r4
; P9BE-NEXT: mr r3, r4
; P9BE-NEXT: sth r5, 142(r1)
; P8LE-LABEL: caller_12:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -80(r1)
+; P8LE-NEXT: std r0, 96(r1)
; P8LE-NEXT: stw r4, 56(r1)
; P8LE-NEXT: addi r5, r1, 68
; P8LE-NEXT: std r3, 48(r1)
; P9LE-LABEL: caller_12:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -80(r1)
+; P9LE-NEXT: std r0, 96(r1)
; P9LE-NEXT: stw r4, 56(r1)
; P9LE-NEXT: addi r4, r1, 68
-; P9LE-NEXT: std r3, 48(r1)
; P9LE-NEXT: lwz r5, 56(r1)
+; P9LE-NEXT: std r3, 48(r1)
; P9LE-NEXT: std r3, 68(r1)
; P9LE-NEXT: mr r3, r4
; P9LE-NEXT: stw r5, 76(r1)
; P8BE-LABEL: caller_12:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -144(r1)
+; P8BE-NEXT: std r0, 160(r1)
; P8BE-NEXT: stw r4, 200(r1)
; P8BE-NEXT: addi r5, r1, 132
; P8BE-NEXT: std r3, 192(r1)
; P9BE-LABEL: caller_12:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -144(r1)
+; P9BE-NEXT: std r0, 160(r1)
; P9BE-NEXT: stw r4, 200(r1)
; P9BE-NEXT: addi r4, r1, 132
-; P9BE-NEXT: std r3, 192(r1)
; P9BE-NEXT: lwz r5, 200(r1)
+; P9BE-NEXT: std r3, 192(r1)
; P9BE-NEXT: std r3, 132(r1)
; P9BE-NEXT: mr r3, r4
; P9BE-NEXT: stw r5, 140(r1)
; P8LE-LABEL: caller_14:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -80(r1)
+; P8LE-NEXT: std r0, 96(r1)
; P8LE-NEXT: stw r4, 56(r1)
; P8LE-NEXT: addi r5, r1, 66
; P8LE-NEXT: rldicl r4, r4, 32, 32
; P9LE-LABEL: caller_14:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -80(r1)
+; P9LE-NEXT: std r0, 96(r1)
; P9LE-NEXT: stw r4, 56(r1)
-; P9LE-NEXT: rldicl r4, r4, 32, 32
; P9LE-NEXT: lwz r5, 56(r1)
+; P9LE-NEXT: rldicl r4, r4, 32, 32
; P9LE-NEXT: std r3, 48(r1)
; P9LE-NEXT: sth r4, 60(r1)
; P9LE-NEXT: addi r4, r1, 66
; P8BE-LABEL: caller_14:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -144(r1)
; P8BE-NEXT: rldicl r6, r4, 48, 16
+; P8BE-NEXT: std r0, 160(r1)
; P8BE-NEXT: addi r5, r1, 130
; P8BE-NEXT: std r3, 192(r1)
-; P8BE-NEXT: sth r4, 204(r1)
-; P8BE-NEXT: stw r6, 200(r1)
; P8BE-NEXT: stdx r3, 0, r5
; P8BE-NEXT: mr r3, r5
+; P8BE-NEXT: stw r6, 200(r1)
; P8BE-NEXT: lwz r6, 200(r1)
+; P8BE-NEXT: sth r4, 204(r1)
; P8BE-NEXT: stw r6, 138(r1)
; P8BE-NEXT: bl callee
; P8BE-NEXT: nop
; P9BE-LABEL: caller_14:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -144(r1)
; P9BE-NEXT: rldicl r5, r4, 48, 16
+; P9BE-NEXT: std r0, 160(r1)
; P9BE-NEXT: sth r4, 204(r1)
; P9BE-NEXT: addi r4, r1, 130
; P9BE-NEXT: std r3, 192(r1)
; P8LE-LABEL: caller_16:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -80(r1)
; P8LE-NEXT: addi r5, r1, 64
+; P8LE-NEXT: std r0, 96(r1)
; P8LE-NEXT: std r3, 48(r1)
; P8LE-NEXT: std r4, 56(r1)
; P8LE-NEXT: std r3, 64(r1)
; P9LE-LABEL: caller_16:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -80(r1)
; P9LE-NEXT: addi r5, r1, 64
+; P9LE-NEXT: std r0, 96(r1)
; P9LE-NEXT: std r3, 48(r1)
; P9LE-NEXT: std r4, 56(r1)
; P9LE-NEXT: stw r4, 72(r1)
; P8BE-LABEL: caller_16:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -144(r1)
; P8BE-NEXT: addi r5, r1, 128
+; P8BE-NEXT: std r0, 160(r1)
; P8BE-NEXT: rldicl r6, r4, 32, 32
; P8BE-NEXT: std r3, 192(r1)
; P8BE-NEXT: std r4, 200(r1)
; P9BE-LABEL: caller_16:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -144(r1)
+; P9BE-NEXT: std r0, 160(r1)
; P9BE-NEXT: std r4, 200(r1)
; P9BE-NEXT: rldicl r5, r4, 32, 32
; P9BE-NEXT: addi r4, r1, 128
; P8LE-LABEL: caller_18:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -96(r1)
; P8LE-NEXT: addi r6, r1, 78
+; P8LE-NEXT: std r0, 112(r1)
; P8LE-NEXT: std r3, 48(r1)
-; P8LE-NEXT: sth r5, 64(r1)
; P8LE-NEXT: std r4, 56(r1)
; P8LE-NEXT: stdx r3, 0, r6
; P8LE-NEXT: mr r3, r6
+; P8LE-NEXT: sth r5, 64(r1)
; P8LE-NEXT: stw r4, 86(r1)
; P8LE-NEXT: bl callee
; P8LE-NEXT: nop
; P9LE-LABEL: caller_18:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -96(r1)
+; P9LE-NEXT: std r0, 112(r1)
; P9LE-NEXT: sth r5, 64(r1)
; P9LE-NEXT: addi r5, r1, 78
; P9LE-NEXT: std r3, 48(r1)
; P8BE-LABEL: caller_18:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -144(r1)
; P8BE-NEXT: addi r6, r1, 126
+; P8BE-NEXT: std r0, 160(r1)
; P8BE-NEXT: sth r5, 208(r1)
; P8BE-NEXT: rldicl r5, r4, 32, 32
; P8BE-NEXT: std r3, 192(r1)
; P9BE-LABEL: caller_18:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -144(r1)
+; P9BE-NEXT: std r0, 160(r1)
; P9BE-NEXT: std r4, 200(r1)
; P9BE-NEXT: sth r5, 208(r1)
; P9BE-NEXT: rldicl r5, r4, 32, 32
; P8LE-LABEL: caller_1:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -64(r1)
+; P8LE-NEXT: std r0, 80(r1)
; P8LE-NEXT: stb r3, 48(r1)
; P8LE-NEXT: lbz r3, 48(r1)
; P8LE-NEXT: stb r3, 63(r1)
; P9LE-LABEL: caller_1:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -64(r1)
+; P9LE-NEXT: std r0, 80(r1)
; P9LE-NEXT: stb r3, 48(r1)
; P9LE-NEXT: lbz r3, 48(r1)
; P9LE-NEXT: stb r3, 63(r1)
; P8BE-LABEL: caller_1:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -128(r1)
+; P8BE-NEXT: std r0, 144(r1)
; P8BE-NEXT: stb r3, 183(r1)
; P8BE-NEXT: lbz r3, 183(r1)
; P8BE-NEXT: stb r3, 127(r1)
; P9BE-LABEL: caller_1:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -128(r1)
+; P9BE-NEXT: std r0, 144(r1)
; P9BE-NEXT: stb r3, 183(r1)
; P9BE-NEXT: lbz r3, 183(r1)
; P9BE-NEXT: stb r3, 127(r1)
; P8LE-LABEL: caller_2:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -64(r1)
+; P8LE-NEXT: std r0, 80(r1)
; P8LE-NEXT: sth r3, 48(r1)
; P8LE-NEXT: lhz r3, 48(r1)
; P8LE-NEXT: sth r3, 62(r1)
; P9LE-LABEL: caller_2:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -64(r1)
+; P9LE-NEXT: std r0, 80(r1)
; P9LE-NEXT: sth r3, 48(r1)
; P9LE-NEXT: lhz r3, 48(r1)
; P9LE-NEXT: sth r3, 62(r1)
; P8BE-LABEL: caller_2:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -128(r1)
+; P8BE-NEXT: std r0, 144(r1)
; P8BE-NEXT: sth r3, 182(r1)
; P8BE-NEXT: lhz r3, 182(r1)
; P8BE-NEXT: sth r3, 126(r1)
; P9BE-LABEL: caller_2:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -128(r1)
+; P9BE-NEXT: std r0, 144(r1)
; P9BE-NEXT: sth r3, 182(r1)
; P9BE-NEXT: lhz r3, 182(r1)
; P9BE-NEXT: sth r3, 126(r1)
; P8LE-LABEL: caller_3:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -64(r1)
+; P8LE-NEXT: std r0, 80(r1)
; P8LE-NEXT: rldicl r4, r3, 48, 16
; P8LE-NEXT: sth r3, 48(r1)
; P8LE-NEXT: stb r4, 50(r1)
; P9LE-LABEL: caller_3:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -64(r1)
+; P9LE-NEXT: std r0, 80(r1)
; P9LE-NEXT: sth r3, 48(r1)
; P9LE-NEXT: rldicl r3, r3, 48, 16
; P9LE-NEXT: stb r3, 50(r1)
; P8BE-LABEL: caller_3:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -128(r1)
; P8BE-NEXT: rldicl r4, r3, 56, 8
+; P8BE-NEXT: std r0, 144(r1)
; P8BE-NEXT: stb r3, 183(r1)
; P8BE-NEXT: sth r4, 181(r1)
; P8BE-NEXT: lbz r4, 183(r1)
; P9BE-LABEL: caller_3:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -128(r1)
; P9BE-NEXT: rldicl r4, r3, 56, 8
+; P9BE-NEXT: std r0, 144(r1)
; P9BE-NEXT: stb r3, 183(r1)
; P9BE-NEXT: sth r4, 181(r1)
; P9BE-NEXT: lbz r4, 183(r1)
; P8LE-LABEL: caller_4:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -64(r1)
+; P8LE-NEXT: std r0, 80(r1)
; P8LE-NEXT: stw r3, 48(r1)
; P8LE-NEXT: lwz r3, 48(r1)
; P8LE-NEXT: stw r3, 60(r1)
; P9LE-LABEL: caller_4:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -64(r1)
+; P9LE-NEXT: std r0, 80(r1)
; P9LE-NEXT: stw r3, 48(r1)
; P9LE-NEXT: lwz r3, 48(r1)
; P9LE-NEXT: stw r3, 60(r1)
; P8BE-LABEL: caller_4:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -128(r1)
+; P8BE-NEXT: std r0, 144(r1)
; P8BE-NEXT: stw r3, 180(r1)
; P8BE-NEXT: lwz r3, 180(r1)
; P8BE-NEXT: stw r3, 124(r1)
; P9BE-LABEL: caller_4:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -128(r1)
+; P9BE-NEXT: std r0, 144(r1)
; P9BE-NEXT: stw r3, 180(r1)
; P9BE-NEXT: lwz r3, 180(r1)
; P9BE-NEXT: stw r3, 124(r1)
; P8LE-LABEL: caller_5:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -64(r1)
; P8LE-NEXT: rldicl r4, r3, 32, 32
+; P8LE-NEXT: std r0, 80(r1)
; P8LE-NEXT: stw r3, 48(r1)
-; P8LE-NEXT: stw r3, 59(r1)
-; P8LE-NEXT: addi r3, r1, 59
; P8LE-NEXT: stb r4, 52(r1)
; P8LE-NEXT: lbz r4, 52(r1)
+; P8LE-NEXT: stw r3, 59(r1)
+; P8LE-NEXT: addi r3, r1, 59
; P8LE-NEXT: stb r4, 63(r1)
; P8LE-NEXT: bl callee
; P8LE-NEXT: nop
; P9LE-LABEL: caller_5:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -64(r1)
; P9LE-NEXT: rldicl r4, r3, 32, 32
+; P9LE-NEXT: std r0, 80(r1)
; P9LE-NEXT: stw r3, 48(r1)
; P9LE-NEXT: stw r3, 59(r1)
; P9LE-NEXT: addi r3, r1, 59
; P8BE-LABEL: caller_5:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -128(r1)
+; P8BE-NEXT: std r0, 144(r1)
; P8BE-NEXT: stb r3, 183(r1)
; P8BE-NEXT: rldicl r3, r3, 56, 8
; P8BE-NEXT: lbz r4, 183(r1)
; P9BE-LABEL: caller_5:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -128(r1)
+; P9BE-NEXT: std r0, 144(r1)
; P9BE-NEXT: stb r3, 183(r1)
-; P9BE-NEXT: rldicl r3, r3, 56, 8
; P9BE-NEXT: lbz r4, 183(r1)
+; P9BE-NEXT: rldicl r3, r3, 56, 8
; P9BE-NEXT: stw r3, 179(r1)
; P9BE-NEXT: stw r3, 123(r1)
; P9BE-NEXT: addi r3, r1, 123
; P8LE-LABEL: caller_6:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -64(r1)
+; P8LE-NEXT: std r0, 80(r1)
; P8LE-NEXT: rldicl r4, r3, 32, 32
; P8LE-NEXT: stw r3, 48(r1)
; P8LE-NEXT: sth r4, 52(r1)
; P9LE-LABEL: caller_6:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -64(r1)
+; P9LE-NEXT: std r0, 80(r1)
; P9LE-NEXT: stw r3, 48(r1)
; P9LE-NEXT: rldicl r3, r3, 32, 32
; P9LE-NEXT: sth r3, 52(r1)
; P8BE-LABEL: caller_6:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -128(r1)
; P8BE-NEXT: rldicl r4, r3, 48, 16
+; P8BE-NEXT: std r0, 144(r1)
; P8BE-NEXT: sth r3, 182(r1)
; P8BE-NEXT: stw r4, 178(r1)
; P8BE-NEXT: lhz r4, 182(r1)
; P9BE-LABEL: caller_6:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -128(r1)
; P9BE-NEXT: rldicl r4, r3, 48, 16
+; P9BE-NEXT: std r0, 144(r1)
; P9BE-NEXT: sth r3, 182(r1)
; P9BE-NEXT: stw r4, 178(r1)
; P9BE-NEXT: lhz r4, 182(r1)
; P8LE-LABEL: caller_7:
; P8LE: # %bb.0: # %entry
; P8LE-NEXT: mflr r0
-; P8LE-NEXT: std r0, 16(r1)
; P8LE-NEXT: stdu r1, -64(r1)
; P8LE-NEXT: rldicl r4, r3, 32, 32
; P8LE-NEXT: rldicl r5, r3, 16, 48
+; P8LE-NEXT: std r0, 80(r1)
; P8LE-NEXT: stw r3, 48(r1)
-; P8LE-NEXT: stw r3, 57(r1)
-; P8LE-NEXT: addi r3, r1, 57
; P8LE-NEXT: sth r4, 52(r1)
; P8LE-NEXT: stb r5, 54(r1)
; P8LE-NEXT: lhz r4, 52(r1)
; P8LE-NEXT: lbz r5, 54(r1)
+; P8LE-NEXT: stw r3, 57(r1)
+; P8LE-NEXT: addi r3, r1, 57
; P8LE-NEXT: sth r4, 61(r1)
; P8LE-NEXT: stb r5, 63(r1)
; P8LE-NEXT: bl callee
; P9LE-LABEL: caller_7:
; P9LE: # %bb.0: # %entry
; P9LE-NEXT: mflr r0
-; P9LE-NEXT: std r0, 16(r1)
; P9LE-NEXT: stdu r1, -64(r1)
; P9LE-NEXT: rldicl r4, r3, 32, 32
+; P9LE-NEXT: std r0, 80(r1)
; P9LE-NEXT: stw r3, 48(r1)
; P9LE-NEXT: stw r3, 57(r1)
; P9LE-NEXT: sth r4, 52(r1)
; P8BE-LABEL: caller_7:
; P8BE: # %bb.0: # %entry
; P8BE-NEXT: mflr r0
-; P8BE-NEXT: std r0, 16(r1)
; P8BE-NEXT: stdu r1, -128(r1)
; P8BE-NEXT: rldicl r4, r3, 56, 8
+; P8BE-NEXT: std r0, 144(r1)
; P8BE-NEXT: stb r3, 183(r1)
; P8BE-NEXT: rldicl r3, r3, 40, 24
; P8BE-NEXT: sth r4, 181(r1)
; P8BE-NEXT: stw r3, 177(r1)
; P8BE-NEXT: stw r3, 121(r1)
; P8BE-NEXT: addi r3, r1, 121
-; P8BE-NEXT: stb r5, 127(r1)
; P8BE-NEXT: sth r4, 125(r1)
+; P8BE-NEXT: stb r5, 127(r1)
; P8BE-NEXT: bl callee
; P8BE-NEXT: nop
; P8BE-NEXT: li r3, 0
; P9BE-LABEL: caller_7:
; P9BE: # %bb.0: # %entry
; P9BE-NEXT: mflr r0
-; P9BE-NEXT: std r0, 16(r1)
; P9BE-NEXT: stdu r1, -128(r1)
; P9BE-NEXT: rldicl r4, r3, 56, 8
+; P9BE-NEXT: std r0, 144(r1)
; P9BE-NEXT: stb r3, 183(r1)
; P9BE-NEXT: lbz r5, 183(r1)
; P9BE-NEXT: rldicl r3, r3, 40, 24
; P9BE-NEXT: sth r4, 181(r1)
; P9BE-NEXT: stw r3, 177(r1)
+; P9BE-NEXT: lhz r4, 181(r1)
; P9BE-NEXT: stw r3, 121(r1)
; P9BE-NEXT: addi r3, r1, 121
-; P9BE-NEXT: lhz r4, 181(r1)
; P9BE-NEXT: stb r5, 127(r1)
; P9BE-NEXT: sth r4, 125(r1)
; P9BE-NEXT: bl callee
; PPC64LE-LABEL: ClobberLR:
; PPC64LE: # %bb.0: # %entry
; PPC64LE-NEXT: mflr r0
-; PPC64LE-NEXT: std r0, 16(r1)
; PPC64LE-NEXT: stdu r1, -32(r1)
+; PPC64LE-NEXT: std r0, 48(r1)
; PPC64LE-NEXT: #APP
; PPC64LE-NEXT: #NO_APP
; PPC64LE-NEXT: addi r1, r1, 32
; PPC64BE-LABEL: ClobberLR:
; PPC64BE: # %bb.0: # %entry
; PPC64BE-NEXT: mflr r0
-; PPC64BE-NEXT: std r0, 16(r1)
; PPC64BE-NEXT: stdu r1, -48(r1)
+; PPC64BE-NEXT: std r0, 64(r1)
; PPC64BE-NEXT: #APP
; PPC64BE-NEXT: #NO_APP
; PPC64BE-NEXT: addi r1, r1, 48
; PPC64LE-LABEL: ClobberLR_BR:
; PPC64LE: # %bb.0: # %entry
; PPC64LE-NEXT: mflr r0
-; PPC64LE-NEXT: std r0, 16(r1)
; PPC64LE-NEXT: stdu r1, -32(r1)
+; PPC64LE-NEXT: std r0, 48(r1)
; PPC64LE-NEXT: #APP
; PPC64LE-NEXT: nop
; PPC64LE-NEXT: #NO_APP
; PPC64BE-LABEL: ClobberLR_BR:
; PPC64BE: # %bb.0: # %entry
; PPC64BE-NEXT: mflr r0
-; PPC64BE-NEXT: std r0, 16(r1)
; PPC64BE-NEXT: stdu r1, -48(r1)
+; PPC64BE-NEXT: std r0, 64(r1)
; PPC64BE-NEXT: #APP
; PPC64BE-NEXT: nop
; PPC64BE-NEXT: #NO_APP
; PPC64LE-LABEL: DefLR:
; PPC64LE: # %bb.0: # %entry
; PPC64LE-NEXT: mflr r0
-; PPC64LE-NEXT: std r0, 16(r1)
; PPC64LE-NEXT: stdu r1, -32(r1)
+; PPC64LE-NEXT: std r0, 48(r1)
; PPC64LE-NEXT: #APP
; PPC64LE-NEXT: #NO_APP
; PPC64LE-NEXT: addi r1, r1, 32
; PPC64BE-LABEL: DefLR:
; PPC64BE: # %bb.0: # %entry
; PPC64BE-NEXT: mflr r0
-; PPC64BE-NEXT: std r0, 16(r1)
; PPC64BE-NEXT: stdu r1, -48(r1)
+; PPC64BE-NEXT: std r0, 64(r1)
; PPC64BE-NEXT: #APP
; PPC64BE-NEXT: #NO_APP
; PPC64BE-NEXT: addi r1, r1, 48
; PPC64LE-LABEL: EarlyClobberLR:
; PPC64LE: # %bb.0: # %entry
; PPC64LE-NEXT: mflr r0
-; PPC64LE-NEXT: std r0, 16(r1)
; PPC64LE-NEXT: stdu r1, -32(r1)
+; PPC64LE-NEXT: std r0, 48(r1)
; PPC64LE-NEXT: #APP
; PPC64LE-NEXT: #NO_APP
; PPC64LE-NEXT: addi r1, r1, 32
; PPC64BE-LABEL: EarlyClobberLR:
; PPC64BE: # %bb.0: # %entry
; PPC64BE-NEXT: mflr r0
-; PPC64BE-NEXT: std r0, 16(r1)
; PPC64BE-NEXT: stdu r1, -48(r1)
+; PPC64BE-NEXT: std r0, 64(r1)
; PPC64BE-NEXT: #APP
; PPC64BE-NEXT: #NO_APP
; PPC64BE-NEXT: addi r1, r1, 48
; PPC64LE-NEXT: mflr r0
; PPC64LE-NEXT: std r15, -136(r1) # 8-byte Folded Spill
; PPC64LE-NEXT: std r16, -128(r1) # 8-byte Folded Spill
-; PPC64LE-NEXT: std r0, 16(r1)
; PPC64LE-NEXT: stdu r1, -176(r1)
+; PPC64LE-NEXT: std r0, 192(r1)
; PPC64LE-NEXT: #APP
; PPC64LE-NEXT: #NO_APP
; PPC64LE-NEXT: addi r1, r1, 176
; PPC64BE-LABEL: ClobberMulti:
; PPC64BE: # %bb.0: # %entry
; PPC64BE-NEXT: mflr r0
-; PPC64BE-NEXT: std r0, 16(r1)
; PPC64BE-NEXT: stdu r1, -192(r1)
+; PPC64BE-NEXT: std r0, 208(r1)
; PPC64BE-NEXT: std r15, 56(r1) # 8-byte Folded Spill
; PPC64BE-NEXT: std r16, 64(r1) # 8-byte Folded Spill
; PPC64BE-NEXT: #APP
define ptr @nest_caller(ptr %arg) nounwind {
; CHECK-LABEL: nest_caller:
; CHECK: mr 11, 3
+; CHECK: std 0, 128(1)
; CHECK-NEXT: bl nest_receiver
; CHECK: blr
; LE-P9-LABEL: main:
; LE-P9: # %bb.0: # %_main_entry
; LE-P9-NEXT: mflr r0
-; LE-P9-NEXT: std r0, 16(r1)
; LE-P9-NEXT: stdu r1, -32(r1)
+; LE-P9-NEXT: std r0, 48(r1)
; LE-P9-NEXT: bl callee
; LE-P9-NEXT: nop
; LE-P9-NEXT: li r3, 0
; BE-P9-LABEL: main:
; BE-P9: # %bb.0: # %_main_entry
; BE-P9-NEXT: mflr r0
-; BE-P9-NEXT: std r0, 16(r1)
; BE-P9-NEXT: stdu r1, -112(r1)
+; BE-P9-NEXT: std r0, 128(r1)
; BE-P9-NEXT: bl callee
; BE-P9-NEXT: nop
; BE-P9-NEXT: li r3, 0
; BE-P9-LABEL: caller:
; BE-P9: # %bb.0: # %entry
; BE-P9-NEXT: mflr r0
-; BE-P9-NEXT: std r0, 16(r1)
-; BE-P9-NEXT: hashst r0, -16(r1)
; BE-P9-NEXT: stdu r1, -128(r1)
+; BE-P9-NEXT: std r0, 144(r1)
+; BE-P9-NEXT: hashst r0, -16(r1)
; BE-P9-NEXT: std r31, 120(r1) # 8-byte Folded Spill
; BE-P9-NEXT: mr r31, r4
; BE-P9-NEXT: bl .callee[PR]
; BE-P8-LABEL: caller:
; BE-P8: # %bb.0: # %entry
; BE-P8-NEXT: mflr r0
-; BE-P8-NEXT: std r0, 16(r1)
-; BE-P8-NEXT: hashst r0, -16(r1)
; BE-P8-NEXT: stdu r1, -128(r1)
+; BE-P8-NEXT: std r0, 144(r1)
+; BE-P8-NEXT: hashst r0, -16(r1)
; BE-P8-NEXT: std r31, 120(r1) # 8-byte Folded Spill
; BE-P8-NEXT: mr r31, r4
; BE-P8-NEXT: bl .callee[PR]
; BE-32BIT-P9-LABEL: caller:
; BE-32BIT-P9: # %bb.0: # %entry
; BE-32BIT-P9-NEXT: mflr r0
-; BE-32BIT-P9-NEXT: stw r0, 8(r1)
-; BE-32BIT-P9-NEXT: hashst r0, -16(r1)
; BE-32BIT-P9-NEXT: stwu r1, -80(r1)
+; BE-32BIT-P9-NEXT: stw r0, 88(r1)
+; BE-32BIT-P9-NEXT: hashst r0, -16(r1)
; BE-32BIT-P9-NEXT: stw r31, 76(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: mr r31, r4
; BE-32BIT-P9-NEXT: bl .callee[PR]
; BE-32BIT-P8-LABEL: caller:
; BE-32BIT-P8: # %bb.0: # %entry
; BE-32BIT-P8-NEXT: mflr r0
-; BE-32BIT-P8-NEXT: stw r0, 8(r1)
-; BE-32BIT-P8-NEXT: hashst r0, -16(r1)
; BE-32BIT-P8-NEXT: stwu r1, -80(r1)
+; BE-32BIT-P8-NEXT: stw r0, 88(r1)
+; BE-32BIT-P8-NEXT: hashst r0, -16(r1)
; BE-32BIT-P8-NEXT: stw r31, 76(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: mr r31, r4
; BE-32BIT-P8-NEXT: bl .callee[PR]
; BE-P9-PRIV-LABEL: caller:
; BE-P9-PRIV: # %bb.0: # %entry
; BE-P9-PRIV-NEXT: mflr r0
-; BE-P9-PRIV-NEXT: std r0, 16(r1)
-; BE-P9-PRIV-NEXT: hashstp r0, -16(r1)
; BE-P9-PRIV-NEXT: stdu r1, -128(r1)
+; BE-P9-PRIV-NEXT: std r0, 144(r1)
+; BE-P9-PRIV-NEXT: hashstp r0, -16(r1)
; BE-P9-PRIV-NEXT: std r31, 120(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: mr r31, r4
; BE-P9-PRIV-NEXT: bl .callee[PR]
; BE-P8-PRIV-LABEL: caller:
; BE-P8-PRIV: # %bb.0: # %entry
; BE-P8-PRIV-NEXT: mflr r0
-; BE-P8-PRIV-NEXT: std r0, 16(r1)
-; BE-P8-PRIV-NEXT: hashstp r0, -16(r1)
; BE-P8-PRIV-NEXT: stdu r1, -128(r1)
+; BE-P8-PRIV-NEXT: std r0, 144(r1)
+; BE-P8-PRIV-NEXT: hashstp r0, -16(r1)
; BE-P8-PRIV-NEXT: std r31, 120(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: mr r31, r4
; BE-P8-PRIV-NEXT: bl .callee[PR]
; BE-32BIT-P9-PRIV-LABEL: caller:
; BE-32BIT-P9-PRIV: # %bb.0: # %entry
; BE-32BIT-P9-PRIV-NEXT: mflr r0
-; BE-32BIT-P9-PRIV-NEXT: stw r0, 8(r1)
-; BE-32BIT-P9-PRIV-NEXT: hashstp r0, -16(r1)
; BE-32BIT-P9-PRIV-NEXT: stwu r1, -80(r1)
+; BE-32BIT-P9-PRIV-NEXT: stw r0, 88(r1)
+; BE-32BIT-P9-PRIV-NEXT: hashstp r0, -16(r1)
; BE-32BIT-P9-PRIV-NEXT: stw r31, 76(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: mr r31, r4
; BE-32BIT-P9-PRIV-NEXT: bl .callee[PR]
; BE-32BIT-P8-PRIV-LABEL: caller:
; BE-32BIT-P8-PRIV: # %bb.0: # %entry
; BE-32BIT-P8-PRIV-NEXT: mflr r0
-; BE-32BIT-P8-PRIV-NEXT: stw r0, 8(r1)
-; BE-32BIT-P8-PRIV-NEXT: hashstp r0, -16(r1)
; BE-32BIT-P8-PRIV-NEXT: stwu r1, -80(r1)
+; BE-32BIT-P8-PRIV-NEXT: stw r0, 88(r1)
+; BE-32BIT-P8-PRIV-NEXT: hashstp r0, -16(r1)
; BE-32BIT-P8-PRIV-NEXT: stw r31, 76(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: mr r31, r4
; BE-32BIT-P8-PRIV-NEXT: bl .callee[PR]
;
; BE-P9-LABEL: spill:
; BE-P9: # %bb.0: # %entry
-; BE-P9-NEXT: mflr r0
; BE-P9-NEXT: mfcr r12
-; BE-P9-NEXT: std r0, 16(r1)
-; BE-P9-NEXT: hashst r0, -488(r1)
+; BE-P9-NEXT: mflr r0
; BE-P9-NEXT: stw r12, 8(r1)
; BE-P9-NEXT: stdu r1, -624(r1)
-; BE-P9-NEXT: lwz r4, 12(r3)
+; BE-P9-NEXT: std r0, 640(r1)
+; BE-P9-NEXT: hashst r0, -488(r1)
; BE-P9-NEXT: std r14, 336(r1) # 8-byte Folded Spill
-; BE-P9-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v20, 144(r1) # 16-byte Folded Spill
; BE-P9-NEXT: stxv v21, 160(r1) # 16-byte Folded Spill
+; BE-P9-NEXT: lwz r4, 12(r3)
+; BE-P9-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v22, 176(r1) # 16-byte Folded Spill
; BE-P9-NEXT: std r16, 352(r1) # 8-byte Folded Spill
-; BE-P9-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v23, 192(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r18, 368(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v24, 208(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r19, 376(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r18, 368(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v25, 224(r1) # 16-byte Folded Spill
+; BE-P9-NEXT: std r19, 376(r1) # 8-byte Folded Spill
; BE-P9-NEXT: std r20, 384(r1) # 8-byte Folded Spill
-; BE-P9-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v26, 240(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r22, 400(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v27, 256(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r23, 408(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r22, 400(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v28, 272(r1) # 16-byte Folded Spill
+; BE-P9-NEXT: std r23, 408(r1) # 8-byte Folded Spill
; BE-P9-NEXT: std r24, 416(r1) # 8-byte Folded Spill
-; BE-P9-NEXT: std r25, 424(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v29, 288(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r26, 432(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r25, 424(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v30, 304(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r27, 440(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r26, 432(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v31, 320(r1) # 16-byte Folded Spill
+; BE-P9-NEXT: std r27, 440(r1) # 8-byte Folded Spill
; BE-P9-NEXT: std r28, 448(r1) # 8-byte Folded Spill
; BE-P9-NEXT: std r29, 456(r1) # 8-byte Folded Spill
; BE-P9-NEXT: std r30, 464(r1) # 8-byte Folded Spill
; BE-P8: # %bb.0: # %entry
; BE-P8-NEXT: mfcr r12
; BE-P8-NEXT: mflr r0
-; BE-P8-NEXT: std r0, 16(r1)
-; BE-P8-NEXT: hashst r0, -488(r1)
; BE-P8-NEXT: stw r12, 8(r1)
; BE-P8-NEXT: stdu r1, -624(r1)
; BE-P8-NEXT: li r4, 144
+; BE-P8-NEXT: std r0, 640(r1)
+; BE-P8-NEXT: hashst r0, -488(r1)
; BE-P8-NEXT: std r14, 336(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r16, 352(r1) # 8-byte Folded Spill
-; BE-P8-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v20, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 160
+; BE-P8-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r18, 368(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r19, 376(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r20, 384(r1) # 8-byte Folded Spill
-; BE-P8-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v21, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 176
+; BE-P8-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r22, 400(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r23, 408(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r24, 416(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r3, 120(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v22, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 192
+; BE-P8-NEXT: stfd f14, 480(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v23, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 208
-; BE-P8-NEXT: stfd f14, 480(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f15, 488(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v24, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 224
-; BE-P8-NEXT: stfd f15, 488(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f16, 496(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v25, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 240
-; BE-P8-NEXT: stfd f16, 496(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f17, 504(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v26, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 256
-; BE-P8-NEXT: stfd f17, 504(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f18, 512(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v27, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 272
-; BE-P8-NEXT: stfd f18, 512(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f19, 520(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v28, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 288
-; BE-P8-NEXT: stfd f19, 520(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f20, 528(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v29, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 304
-; BE-P8-NEXT: stfd f20, 528(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f21, 536(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v30, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 320
-; BE-P8-NEXT: stfd f21, 536(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f22, 544(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v31, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: lwz r4, 12(r3)
-; BE-P8-NEXT: stfd f22, 544(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stfd f23, 552(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stfd f24, 560(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stfd f25, 568(r1) # 8-byte Folded Spill
;
; BE-32BIT-P9-LABEL: spill:
; BE-32BIT-P9: # %bb.0: # %entry
-; BE-32BIT-P9-NEXT: mflr r0
; BE-32BIT-P9-NEXT: mfcr r12
-; BE-32BIT-P9-NEXT: stw r0, 8(r1)
-; BE-32BIT-P9-NEXT: hashst r0, -424(r1)
+; BE-32BIT-P9-NEXT: mflr r0
; BE-32BIT-P9-NEXT: stw r12, 4(r1)
; BE-32BIT-P9-NEXT: stwu r1, -496(r1)
-; BE-32BIT-P9-NEXT: lwz r4, 12(r3)
+; BE-32BIT-P9-NEXT: stw r0, 504(r1)
+; BE-32BIT-P9-NEXT: hashst r0, -424(r1)
; BE-32BIT-P9-NEXT: stw r13, 276(r1) # 4-byte Folded Spill
-; BE-32BIT-P9-NEXT: stw r14, 280(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v20, 80(r1) # 16-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v21, 96(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT: lwz r4, 12(r3)
+; BE-32BIT-P9-NEXT: stw r14, 280(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v22, 112(r1) # 16-byte Folded Spill
; BE-32BIT-P9-NEXT: stw r15, 284(r1) # 4-byte Folded Spill
-; BE-32BIT-P9-NEXT: stw r16, 288(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v23, 128(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-NEXT: stw r17, 292(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT: stw r16, 288(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v24, 144(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-NEXT: stw r18, 296(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT: stw r17, 292(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v25, 160(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT: stw r18, 296(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stw r19, 300(r1) # 4-byte Folded Spill
-; BE-32BIT-P9-NEXT: stw r20, 304(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v26, 176(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-NEXT: stw r21, 308(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT: stw r20, 304(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v27, 192(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-NEXT: stw r22, 312(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT: stw r21, 308(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v28, 208(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT: stw r22, 312(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stw r23, 316(r1) # 4-byte Folded Spill
-; BE-32BIT-P9-NEXT: stw r24, 320(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v29, 224(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-NEXT: stw r25, 324(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT: stw r24, 320(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v30, 240(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-NEXT: stw r26, 328(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT: stw r25, 324(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stxv v31, 256(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT: stw r26, 328(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stw r27, 332(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stw r28, 336(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stw r29, 340(r1) # 4-byte Folded Spill
; BE-32BIT-P8: # %bb.0: # %entry
; BE-32BIT-P8-NEXT: mfcr r12
; BE-32BIT-P8-NEXT: mflr r0
-; BE-32BIT-P8-NEXT: stw r0, 8(r1)
-; BE-32BIT-P8-NEXT: hashst r0, -424(r1)
; BE-32BIT-P8-NEXT: stw r12, 4(r1)
; BE-32BIT-P8-NEXT: stwu r1, -496(r1)
; BE-32BIT-P8-NEXT: li r4, 80
+; BE-32BIT-P8-NEXT: stw r0, 504(r1)
+; BE-32BIT-P8-NEXT: hashst r0, -424(r1)
; BE-32BIT-P8-NEXT: stw r13, 276(r1) # 4-byte Folded Spill
-; BE-32BIT-P8-NEXT: stw r14, 280(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v20, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 96
-; BE-32BIT-P8-NEXT: stw r15, 284(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r14, 280(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v21, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 112
-; BE-32BIT-P8-NEXT: stw r16, 288(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r15, 284(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v22, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 128
-; BE-32BIT-P8-NEXT: stw r17, 292(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r16, 288(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v23, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 144
-; BE-32BIT-P8-NEXT: stw r18, 296(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r17, 292(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v24, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 160
-; BE-32BIT-P8-NEXT: stw r19, 300(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r18, 296(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v25, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 176
-; BE-32BIT-P8-NEXT: stw r20, 304(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r19, 300(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v26, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 192
-; BE-32BIT-P8-NEXT: stw r21, 308(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r20, 304(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v27, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 208
-; BE-32BIT-P8-NEXT: stw r22, 312(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r21, 308(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v28, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 224
-; BE-32BIT-P8-NEXT: stw r23, 316(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r22, 312(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v29, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 240
-; BE-32BIT-P8-NEXT: stw r24, 320(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r23, 316(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v30, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 256
-; BE-32BIT-P8-NEXT: stw r25, 324(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT: stw r24, 320(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v31, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: lwz r4, 12(r3)
+; BE-32BIT-P8-NEXT: stw r25, 324(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stw r26, 328(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stw r27, 332(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stw r28, 336(r1) # 4-byte Folded Spill
;
; BE-P9-PRIV-LABEL: spill:
; BE-P9-PRIV: # %bb.0: # %entry
-; BE-P9-PRIV-NEXT: mflr r0
; BE-P9-PRIV-NEXT: mfcr r12
-; BE-P9-PRIV-NEXT: std r0, 16(r1)
-; BE-P9-PRIV-NEXT: hashstp r0, -488(r1)
+; BE-P9-PRIV-NEXT: mflr r0
; BE-P9-PRIV-NEXT: stw r12, 8(r1)
; BE-P9-PRIV-NEXT: stdu r1, -624(r1)
-; BE-P9-PRIV-NEXT: lwz r4, 12(r3)
+; BE-P9-PRIV-NEXT: std r0, 640(r1)
+; BE-P9-PRIV-NEXT: hashstp r0, -488(r1)
; BE-P9-PRIV-NEXT: std r14, 336(r1) # 8-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v20, 144(r1) # 16-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v21, 160(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT: lwz r4, 12(r3)
+; BE-P9-PRIV-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v22, 176(r1) # 16-byte Folded Spill
; BE-P9-PRIV-NEXT: std r16, 352(r1) # 8-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v23, 192(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r18, 368(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v24, 208(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r19, 376(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r18, 368(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v25, 224(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r19, 376(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: std r20, 384(r1) # 8-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v26, 240(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r22, 400(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v27, 256(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r23, 408(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r22, 400(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v28, 272(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r23, 408(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: std r24, 416(r1) # 8-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r25, 424(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v29, 288(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r26, 432(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r25, 424(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v30, 304(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r27, 440(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r26, 432(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v31, 320(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r27, 440(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: std r28, 448(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: std r29, 456(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: std r30, 464(r1) # 8-byte Folded Spill
; BE-P8-PRIV: # %bb.0: # %entry
; BE-P8-PRIV-NEXT: mfcr r12
; BE-P8-PRIV-NEXT: mflr r0
-; BE-P8-PRIV-NEXT: std r0, 16(r1)
-; BE-P8-PRIV-NEXT: hashstp r0, -488(r1)
; BE-P8-PRIV-NEXT: stw r12, 8(r1)
; BE-P8-PRIV-NEXT: stdu r1, -624(r1)
; BE-P8-PRIV-NEXT: li r4, 144
+; BE-P8-PRIV-NEXT: std r0, 640(r1)
+; BE-P8-PRIV-NEXT: hashstp r0, -488(r1)
; BE-P8-PRIV-NEXT: std r14, 336(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r16, 352(r1) # 8-byte Folded Spill
-; BE-P8-PRIV-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v20, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 160
+; BE-P8-PRIV-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r18, 368(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r19, 376(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r20, 384(r1) # 8-byte Folded Spill
-; BE-P8-PRIV-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v21, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 176
+; BE-P8-PRIV-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r22, 400(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r23, 408(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r24, 416(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r3, 120(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v22, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 192
+; BE-P8-PRIV-NEXT: stfd f14, 480(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v23, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 208
-; BE-P8-PRIV-NEXT: stfd f14, 480(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f15, 488(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v24, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 224
-; BE-P8-PRIV-NEXT: stfd f15, 488(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f16, 496(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v25, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 240
-; BE-P8-PRIV-NEXT: stfd f16, 496(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f17, 504(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v26, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 256
-; BE-P8-PRIV-NEXT: stfd f17, 504(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f18, 512(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v27, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 272
-; BE-P8-PRIV-NEXT: stfd f18, 512(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f19, 520(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v28, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 288
-; BE-P8-PRIV-NEXT: stfd f19, 520(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f20, 528(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v29, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 304
-; BE-P8-PRIV-NEXT: stfd f20, 528(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f21, 536(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v30, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 320
-; BE-P8-PRIV-NEXT: stfd f21, 536(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f22, 544(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v31, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: lwz r4, 12(r3)
-; BE-P8-PRIV-NEXT: stfd f22, 544(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stfd f23, 552(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stfd f24, 560(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stfd f25, 568(r1) # 8-byte Folded Spill
;
; BE-32BIT-P9-PRIV-LABEL: spill:
; BE-32BIT-P9-PRIV: # %bb.0: # %entry
-; BE-32BIT-P9-PRIV-NEXT: mflr r0
; BE-32BIT-P9-PRIV-NEXT: mfcr r12
-; BE-32BIT-P9-PRIV-NEXT: stw r0, 8(r1)
-; BE-32BIT-P9-PRIV-NEXT: hashstp r0, -424(r1)
+; BE-32BIT-P9-PRIV-NEXT: mflr r0
; BE-32BIT-P9-PRIV-NEXT: stw r12, 4(r1)
; BE-32BIT-P9-PRIV-NEXT: stwu r1, -496(r1)
-; BE-32BIT-P9-PRIV-NEXT: lwz r4, 12(r3)
+; BE-32BIT-P9-PRIV-NEXT: stw r0, 504(r1)
+; BE-32BIT-P9-PRIV-NEXT: hashstp r0, -424(r1)
; BE-32BIT-P9-PRIV-NEXT: stw r13, 276(r1) # 4-byte Folded Spill
-; BE-32BIT-P9-PRIV-NEXT: stw r14, 280(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v20, 80(r1) # 16-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v21, 96(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT: lwz r4, 12(r3)
+; BE-32BIT-P9-PRIV-NEXT: stw r14, 280(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v22, 112(r1) # 16-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stw r15, 284(r1) # 4-byte Folded Spill
-; BE-32BIT-P9-PRIV-NEXT: stw r16, 288(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v23, 128(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-PRIV-NEXT: stw r17, 292(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT: stw r16, 288(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v24, 144(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-PRIV-NEXT: stw r18, 296(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT: stw r17, 292(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v25, 160(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT: stw r18, 296(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stw r19, 300(r1) # 4-byte Folded Spill
-; BE-32BIT-P9-PRIV-NEXT: stw r20, 304(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v26, 176(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-PRIV-NEXT: stw r21, 308(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT: stw r20, 304(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v27, 192(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-PRIV-NEXT: stw r22, 312(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT: stw r21, 308(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v28, 208(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT: stw r22, 312(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stw r23, 316(r1) # 4-byte Folded Spill
-; BE-32BIT-P9-PRIV-NEXT: stw r24, 320(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v29, 224(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-PRIV-NEXT: stw r25, 324(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT: stw r24, 320(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v30, 240(r1) # 16-byte Folded Spill
-; BE-32BIT-P9-PRIV-NEXT: stw r26, 328(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT: stw r25, 324(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stxv v31, 256(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT: stw r26, 328(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stw r27, 332(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stw r28, 336(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: stw r29, 340(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV: # %bb.0: # %entry
; BE-32BIT-P8-PRIV-NEXT: mfcr r12
; BE-32BIT-P8-PRIV-NEXT: mflr r0
-; BE-32BIT-P8-PRIV-NEXT: stw r0, 8(r1)
-; BE-32BIT-P8-PRIV-NEXT: hashstp r0, -424(r1)
; BE-32BIT-P8-PRIV-NEXT: stw r12, 4(r1)
; BE-32BIT-P8-PRIV-NEXT: stwu r1, -496(r1)
; BE-32BIT-P8-PRIV-NEXT: li r4, 80
+; BE-32BIT-P8-PRIV-NEXT: stw r0, 504(r1)
+; BE-32BIT-P8-PRIV-NEXT: hashstp r0, -424(r1)
; BE-32BIT-P8-PRIV-NEXT: stw r13, 276(r1) # 4-byte Folded Spill
-; BE-32BIT-P8-PRIV-NEXT: stw r14, 280(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v20, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 96
-; BE-32BIT-P8-PRIV-NEXT: stw r15, 284(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r14, 280(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v21, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 112
-; BE-32BIT-P8-PRIV-NEXT: stw r16, 288(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r15, 284(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v22, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 128
-; BE-32BIT-P8-PRIV-NEXT: stw r17, 292(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r16, 288(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v23, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 144
-; BE-32BIT-P8-PRIV-NEXT: stw r18, 296(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r17, 292(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v24, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 160
-; BE-32BIT-P8-PRIV-NEXT: stw r19, 300(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r18, 296(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v25, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 176
-; BE-32BIT-P8-PRIV-NEXT: stw r20, 304(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r19, 300(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v26, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 192
-; BE-32BIT-P8-PRIV-NEXT: stw r21, 308(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r20, 304(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v27, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 208
-; BE-32BIT-P8-PRIV-NEXT: stw r22, 312(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r21, 308(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v28, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 224
-; BE-32BIT-P8-PRIV-NEXT: stw r23, 316(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r22, 312(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v29, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 240
-; BE-32BIT-P8-PRIV-NEXT: stw r24, 320(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r23, 316(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v30, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: li r4, 256
-; BE-32BIT-P8-PRIV-NEXT: stw r25, 324(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT: stw r24, 320(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stxvd2x v31, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: lwz r4, 12(r3)
+; BE-32BIT-P8-PRIV-NEXT: stw r25, 324(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stw r26, 328(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stw r27, 332(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: stw r28, 336(r1) # 4-byte Folded Spill
; BE-P9-NEXT: beq cr0, L..BB2_2
; BE-P9-NEXT: # %bb.1: # %if.end
; BE-P9-NEXT: mflr r0
-; BE-P9-NEXT: std r0, 16(r1)
-; BE-P9-NEXT: hashst r0, -16(r1)
; BE-P9-NEXT: stdu r1, -144(r1)
+; BE-P9-NEXT: std r0, 160(r1)
+; BE-P9-NEXT: hashst r0, -16(r1)
; BE-P9-NEXT: std r31, 136(r1) # 8-byte Folded Spill
; BE-P9-NEXT: mr r31, r3
; BE-P9-NEXT: lwz r3, 12(r3)
; BE-P8-NEXT: beq cr0, L..BB2_2
; BE-P8-NEXT: # %bb.1: # %if.end
; BE-P8-NEXT: mflr r0
-; BE-P8-NEXT: std r0, 16(r1)
-; BE-P8-NEXT: hashst r0, -16(r1)
; BE-P8-NEXT: stdu r1, -144(r1)
+; BE-P8-NEXT: std r0, 160(r1)
+; BE-P8-NEXT: hashst r0, -16(r1)
; BE-P8-NEXT: std r31, 136(r1) # 8-byte Folded Spill
; BE-P8-NEXT: mr r31, r3
; BE-P8-NEXT: lwz r3, 12(r3)
; BE-32BIT-P9-NEXT: beq cr0, L..BB2_2
; BE-32BIT-P9-NEXT: # %bb.1: # %if.end
; BE-32BIT-P9-NEXT: mflr r0
-; BE-32BIT-P9-NEXT: stw r0, 8(r1)
-; BE-32BIT-P9-NEXT: hashst r0, -16(r1)
; BE-32BIT-P9-NEXT: stwu r1, -80(r1)
+; BE-32BIT-P9-NEXT: stw r0, 88(r1)
+; BE-32BIT-P9-NEXT: hashst r0, -16(r1)
; BE-32BIT-P9-NEXT: stw r31, 76(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: mr r31, r3
; BE-32BIT-P9-NEXT: lwz r3, 12(r3)
; BE-32BIT-P8-NEXT: beq cr0, L..BB2_2
; BE-32BIT-P8-NEXT: # %bb.1: # %if.end
; BE-32BIT-P8-NEXT: mflr r0
-; BE-32BIT-P8-NEXT: stw r0, 8(r1)
-; BE-32BIT-P8-NEXT: hashst r0, -16(r1)
; BE-32BIT-P8-NEXT: stwu r1, -80(r1)
+; BE-32BIT-P8-NEXT: stw r0, 88(r1)
+; BE-32BIT-P8-NEXT: hashst r0, -16(r1)
; BE-32BIT-P8-NEXT: stw r31, 76(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: mr r31, r3
; BE-32BIT-P8-NEXT: lwz r3, 12(r3)
; BE-P9-PRIV-NEXT: beq cr0, L..BB2_2
; BE-P9-PRIV-NEXT: # %bb.1: # %if.end
; BE-P9-PRIV-NEXT: mflr r0
-; BE-P9-PRIV-NEXT: std r0, 16(r1)
-; BE-P9-PRIV-NEXT: hashstp r0, -16(r1)
; BE-P9-PRIV-NEXT: stdu r1, -144(r1)
+; BE-P9-PRIV-NEXT: std r0, 160(r1)
+; BE-P9-PRIV-NEXT: hashstp r0, -16(r1)
; BE-P9-PRIV-NEXT: std r31, 136(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: mr r31, r3
; BE-P9-PRIV-NEXT: lwz r3, 12(r3)
; BE-P8-PRIV-NEXT: beq cr0, L..BB2_2
; BE-P8-PRIV-NEXT: # %bb.1: # %if.end
; BE-P8-PRIV-NEXT: mflr r0
-; BE-P8-PRIV-NEXT: std r0, 16(r1)
-; BE-P8-PRIV-NEXT: hashstp r0, -16(r1)
; BE-P8-PRIV-NEXT: stdu r1, -144(r1)
+; BE-P8-PRIV-NEXT: std r0, 160(r1)
+; BE-P8-PRIV-NEXT: hashstp r0, -16(r1)
; BE-P8-PRIV-NEXT: std r31, 136(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: mr r31, r3
; BE-P8-PRIV-NEXT: lwz r3, 12(r3)
; BE-32BIT-P9-PRIV-NEXT: beq cr0, L..BB2_2
; BE-32BIT-P9-PRIV-NEXT: # %bb.1: # %if.end
; BE-32BIT-P9-PRIV-NEXT: mflr r0
-; BE-32BIT-P9-PRIV-NEXT: stw r0, 8(r1)
-; BE-32BIT-P9-PRIV-NEXT: hashstp r0, -16(r1)
; BE-32BIT-P9-PRIV-NEXT: stwu r1, -80(r1)
+; BE-32BIT-P9-PRIV-NEXT: stw r0, 88(r1)
+; BE-32BIT-P9-PRIV-NEXT: hashstp r0, -16(r1)
; BE-32BIT-P9-PRIV-NEXT: stw r31, 76(r1) # 4-byte Folded Spill
; BE-32BIT-P9-PRIV-NEXT: mr r31, r3
; BE-32BIT-P9-PRIV-NEXT: lwz r3, 12(r3)
; BE-32BIT-P8-PRIV-NEXT: beq cr0, L..BB2_2
; BE-32BIT-P8-PRIV-NEXT: # %bb.1: # %if.end
; BE-32BIT-P8-PRIV-NEXT: mflr r0
-; BE-32BIT-P8-PRIV-NEXT: stw r0, 8(r1)
-; BE-32BIT-P8-PRIV-NEXT: hashstp r0, -16(r1)
; BE-32BIT-P8-PRIV-NEXT: stwu r1, -80(r1)
+; BE-32BIT-P8-PRIV-NEXT: stw r0, 88(r1)
+; BE-32BIT-P8-PRIV-NEXT: hashstp r0, -16(r1)
; BE-32BIT-P8-PRIV-NEXT: stw r31, 76(r1) # 4-byte Folded Spill
; BE-32BIT-P8-PRIV-NEXT: mr r31, r3
; BE-32BIT-P8-PRIV-NEXT: lwz r3, 12(r3)
; LE-P9: # %bb.0: # %entry
; LE-P9-NEXT: mflr r0
; LE-P9-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; LE-P9-NEXT: std r0, 16(r1)
-; LE-P9-NEXT: hashst r0, -24(r1)
; LE-P9-NEXT: stdu r1, -64(r1)
+; LE-P9-NEXT: std r0, 80(r1)
+; LE-P9-NEXT: hashst r0, -24(r1)
; LE-P9-NEXT: mr r30, r4
; LE-P9-NEXT: bl callee
; LE-P9-NEXT: nop
; LE-P8: # %bb.0: # %entry
; LE-P8-NEXT: mflr r0
; LE-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; LE-P8-NEXT: std r0, 16(r1)
-; LE-P8-NEXT: hashst r0, -24(r1)
; LE-P8-NEXT: stdu r1, -64(r1)
+; LE-P8-NEXT: std r0, 80(r1)
+; LE-P8-NEXT: hashst r0, -24(r1)
; LE-P8-NEXT: mr r30, r4
; LE-P8-NEXT: bl callee
; LE-P8-NEXT: nop
; LE-P9-O0-LABEL: caller:
; LE-P9-O0: # %bb.0: # %entry
; LE-P9-O0-NEXT: mflr r0
-; LE-P9-O0-NEXT: std r0, 16(r1)
-; LE-P9-O0-NEXT: hashst r0, -8(r1)
; LE-P9-O0-NEXT: stdu r1, -112(r1)
+; LE-P9-O0-NEXT: std r0, 128(r1)
+; LE-P9-O0-NEXT: hashst r0, -8(r1)
; LE-P9-O0-NEXT: # kill: def $r4 killed $r4 killed $x4
; LE-P9-O0-NEXT: stw r4, 100(r1) # 4-byte Folded Spill
; LE-P9-O0-NEXT: # kill: def $r3 killed $r3 killed $x3
; LE-P8-O0-LABEL: caller:
; LE-P8-O0: # %bb.0: # %entry
; LE-P8-O0-NEXT: mflr r0
-; LE-P8-O0-NEXT: std r0, 16(r1)
-; LE-P8-O0-NEXT: hashst r0, -8(r1)
; LE-P8-O0-NEXT: stdu r1, -112(r1)
+; LE-P8-O0-NEXT: std r0, 128(r1)
+; LE-P8-O0-NEXT: hashst r0, -8(r1)
; LE-P8-O0-NEXT: # kill: def $r4 killed $r4 killed $x4
; LE-P8-O0-NEXT: stw r4, 100(r1) # 4-byte Folded Spill
; LE-P8-O0-NEXT: # kill: def $r3 killed $r3 killed $x3
; BE-P9-LABEL: caller:
; BE-P9: # %bb.0: # %entry
; BE-P9-NEXT: mflr r0
-; BE-P9-NEXT: std r0, 16(r1)
-; BE-P9-NEXT: hashst r0, -24(r1)
; BE-P9-NEXT: stdu r1, -144(r1)
+; BE-P9-NEXT: std r0, 160(r1)
+; BE-P9-NEXT: hashst r0, -24(r1)
; BE-P9-NEXT: std r30, 128(r1) # 8-byte Folded Spill
; BE-P9-NEXT: mr r30, r4
; BE-P9-NEXT: bl callee
; BE-P8-LABEL: caller:
; BE-P8: # %bb.0: # %entry
; BE-P8-NEXT: mflr r0
-; BE-P8-NEXT: std r0, 16(r1)
-; BE-P8-NEXT: hashst r0, -24(r1)
; BE-P8-NEXT: stdu r1, -144(r1)
+; BE-P8-NEXT: std r0, 160(r1)
+; BE-P8-NEXT: hashst r0, -24(r1)
; BE-P8-NEXT: std r30, 128(r1) # 8-byte Folded Spill
; BE-P8-NEXT: mr r30, r4
; BE-P8-NEXT: bl callee
; BE-32BIT-P9-LABEL: caller:
; BE-32BIT-P9: # %bb.0: # %entry
; BE-32BIT-P9-NEXT: mflr r0
-; BE-32BIT-P9-NEXT: stw r0, 4(r1)
-; BE-32BIT-P9-NEXT: hashst r0, -16(r1)
; BE-32BIT-P9-NEXT: stwu r1, -32(r1)
+; BE-32BIT-P9-NEXT: stw r0, 36(r1)
+; BE-32BIT-P9-NEXT: hashst r0, -16(r1)
; BE-32BIT-P9-NEXT: stw r30, 24(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: mr r30, r4
; BE-32BIT-P9-NEXT: bl callee
; BE-32BIT-P8-LABEL: caller:
; BE-32BIT-P8: # %bb.0: # %entry
; BE-32BIT-P8-NEXT: mflr r0
-; BE-32BIT-P8-NEXT: stw r0, 4(r1)
-; BE-32BIT-P8-NEXT: hashst r0, -16(r1)
; BE-32BIT-P8-NEXT: stwu r1, -32(r1)
+; BE-32BIT-P8-NEXT: stw r0, 36(r1)
+; BE-32BIT-P8-NEXT: hashst r0, -16(r1)
; BE-32BIT-P8-NEXT: stw r30, 24(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: mr r30, r4
; BE-32BIT-P8-NEXT: bl callee
; LE-P9-PRIV: # %bb.0: # %entry
; LE-P9-PRIV-NEXT: mflr r0
; LE-P9-PRIV-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r0, 16(r1)
-; LE-P9-PRIV-NEXT: hashstp r0, -24(r1)
; LE-P9-PRIV-NEXT: stdu r1, -64(r1)
+; LE-P9-PRIV-NEXT: std r0, 80(r1)
+; LE-P9-PRIV-NEXT: hashstp r0, -24(r1)
; LE-P9-PRIV-NEXT: mr r30, r4
; LE-P9-PRIV-NEXT: bl callee
; LE-P9-PRIV-NEXT: nop
; LE-P8-PRIV: # %bb.0: # %entry
; LE-P8-PRIV-NEXT: mflr r0
; LE-P8-PRIV-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; LE-P8-PRIV-NEXT: std r0, 16(r1)
-; LE-P8-PRIV-NEXT: hashstp r0, -24(r1)
; LE-P8-PRIV-NEXT: stdu r1, -64(r1)
+; LE-P8-PRIV-NEXT: std r0, 80(r1)
+; LE-P8-PRIV-NEXT: hashstp r0, -24(r1)
; LE-P8-PRIV-NEXT: mr r30, r4
; LE-P8-PRIV-NEXT: bl callee
; LE-P8-PRIV-NEXT: nop
; BE-P9-PRIV-LABEL: caller:
; BE-P9-PRIV: # %bb.0: # %entry
; BE-P9-PRIV-NEXT: mflr r0
-; BE-P9-PRIV-NEXT: std r0, 16(r1)
-; BE-P9-PRIV-NEXT: hashstp r0, -24(r1)
; BE-P9-PRIV-NEXT: stdu r1, -144(r1)
+; BE-P9-PRIV-NEXT: std r0, 160(r1)
+; BE-P9-PRIV-NEXT: hashstp r0, -24(r1)
; BE-P9-PRIV-NEXT: std r30, 128(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: mr r30, r4
; BE-P9-PRIV-NEXT: bl callee
; BE-P8-PRIV-LABEL: caller:
; BE-P8-PRIV: # %bb.0: # %entry
; BE-P8-PRIV-NEXT: mflr r0
-; BE-P8-PRIV-NEXT: std r0, 16(r1)
-; BE-P8-PRIV-NEXT: hashstp r0, -24(r1)
; BE-P8-PRIV-NEXT: stdu r1, -144(r1)
+; BE-P8-PRIV-NEXT: std r0, 160(r1)
+; BE-P8-PRIV-NEXT: hashstp r0, -24(r1)
; BE-P8-PRIV-NEXT: std r30, 128(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: mr r30, r4
; BE-P8-PRIV-NEXT: bl callee
;
; LE-P9-LABEL: spill:
; LE-P9: # %bb.0: # %entry
-; LE-P9-NEXT: mflr r0
; LE-P9-NEXT: mfcr r12
-; LE-P9-NEXT: std r0, 16(r1)
-; LE-P9-NEXT: hashst r0, -488(r1)
+; LE-P9-NEXT: mflr r0
; LE-P9-NEXT: stw r12, 8(r1)
; LE-P9-NEXT: stdu r1, -544(r1)
-; LE-P9-NEXT: lwz r4, 12(r3)
+; LE-P9-NEXT: std r0, 560(r1)
+; LE-P9-NEXT: hashst r0, -488(r1)
; LE-P9-NEXT: std r14, 256(r1) # 8-byte Folded Spill
-; LE-P9-NEXT: std r15, 264(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v20, 64(r1) # 16-byte Folded Spill
; LE-P9-NEXT: stxv v21, 80(r1) # 16-byte Folded Spill
+; LE-P9-NEXT: lwz r4, 12(r3)
+; LE-P9-NEXT: std r15, 264(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v22, 96(r1) # 16-byte Folded Spill
; LE-P9-NEXT: std r16, 272(r1) # 8-byte Folded Spill
-; LE-P9-NEXT: std r17, 280(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v23, 112(r1) # 16-byte Folded Spill
-; LE-P9-NEXT: std r18, 288(r1) # 8-byte Folded Spill
+; LE-P9-NEXT: std r17, 280(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v24, 128(r1) # 16-byte Folded Spill
-; LE-P9-NEXT: std r19, 296(r1) # 8-byte Folded Spill
+; LE-P9-NEXT: std r18, 288(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v25, 144(r1) # 16-byte Folded Spill
+; LE-P9-NEXT: std r19, 296(r1) # 8-byte Folded Spill
; LE-P9-NEXT: std r20, 304(r1) # 8-byte Folded Spill
-; LE-P9-NEXT: std r21, 312(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v26, 160(r1) # 16-byte Folded Spill
-; LE-P9-NEXT: std r22, 320(r1) # 8-byte Folded Spill
+; LE-P9-NEXT: std r21, 312(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v27, 176(r1) # 16-byte Folded Spill
-; LE-P9-NEXT: std r23, 328(r1) # 8-byte Folded Spill
+; LE-P9-NEXT: std r22, 320(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v28, 192(r1) # 16-byte Folded Spill
+; LE-P9-NEXT: std r23, 328(r1) # 8-byte Folded Spill
; LE-P9-NEXT: std r24, 336(r1) # 8-byte Folded Spill
-; LE-P9-NEXT: std r25, 344(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v29, 208(r1) # 16-byte Folded Spill
-; LE-P9-NEXT: std r26, 352(r1) # 8-byte Folded Spill
+; LE-P9-NEXT: std r25, 344(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v30, 224(r1) # 16-byte Folded Spill
-; LE-P9-NEXT: std r27, 360(r1) # 8-byte Folded Spill
+; LE-P9-NEXT: std r26, 352(r1) # 8-byte Folded Spill
; LE-P9-NEXT: stxv v31, 240(r1) # 16-byte Folded Spill
+; LE-P9-NEXT: std r27, 360(r1) # 8-byte Folded Spill
; LE-P9-NEXT: std r28, 368(r1) # 8-byte Folded Spill
; LE-P9-NEXT: std r29, 376(r1) # 8-byte Folded Spill
; LE-P9-NEXT: std r30, 384(r1) # 8-byte Folded Spill
; LE-P8: # %bb.0: # %entry
; LE-P8-NEXT: mfcr r12
; LE-P8-NEXT: mflr r0
-; LE-P8-NEXT: std r0, 16(r1)
-; LE-P8-NEXT: hashst r0, -488(r1)
; LE-P8-NEXT: stw r12, 8(r1)
; LE-P8-NEXT: stdu r1, -544(r1)
; LE-P8-NEXT: li r4, 64
+; LE-P8-NEXT: std r0, 560(r1)
+; LE-P8-NEXT: hashst r0, -488(r1)
; LE-P8-NEXT: std r14, 256(r1) # 8-byte Folded Spill
; LE-P8-NEXT: std r15, 264(r1) # 8-byte Folded Spill
; LE-P8-NEXT: std r16, 272(r1) # 8-byte Folded Spill
-; LE-P8-NEXT: std r17, 280(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v20, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 80
+; LE-P8-NEXT: std r17, 280(r1) # 8-byte Folded Spill
; LE-P8-NEXT: std r18, 288(r1) # 8-byte Folded Spill
; LE-P8-NEXT: std r19, 296(r1) # 8-byte Folded Spill
; LE-P8-NEXT: std r20, 304(r1) # 8-byte Folded Spill
-; LE-P8-NEXT: std r21, 312(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v21, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 96
+; LE-P8-NEXT: std r21, 312(r1) # 8-byte Folded Spill
; LE-P8-NEXT: std r22, 320(r1) # 8-byte Folded Spill
; LE-P8-NEXT: std r23, 328(r1) # 8-byte Folded Spill
; LE-P8-NEXT: std r24, 336(r1) # 8-byte Folded Spill
; LE-P8-NEXT: std r3, 40(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v22, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 112
+; LE-P8-NEXT: stfd f14, 400(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v23, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 128
-; LE-P8-NEXT: stfd f14, 400(r1) # 8-byte Folded Spill
+; LE-P8-NEXT: stfd f15, 408(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v24, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 144
-; LE-P8-NEXT: stfd f15, 408(r1) # 8-byte Folded Spill
+; LE-P8-NEXT: stfd f16, 416(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v25, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 160
-; LE-P8-NEXT: stfd f16, 416(r1) # 8-byte Folded Spill
+; LE-P8-NEXT: stfd f17, 424(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v26, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 176
-; LE-P8-NEXT: stfd f17, 424(r1) # 8-byte Folded Spill
+; LE-P8-NEXT: stfd f18, 432(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v27, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 192
-; LE-P8-NEXT: stfd f18, 432(r1) # 8-byte Folded Spill
+; LE-P8-NEXT: stfd f19, 440(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v28, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 208
-; LE-P8-NEXT: stfd f19, 440(r1) # 8-byte Folded Spill
+; LE-P8-NEXT: stfd f20, 448(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v29, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 224
-; LE-P8-NEXT: stfd f20, 448(r1) # 8-byte Folded Spill
+; LE-P8-NEXT: stfd f21, 456(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v30, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: li r4, 240
-; LE-P8-NEXT: stfd f21, 456(r1) # 8-byte Folded Spill
+; LE-P8-NEXT: stfd f22, 464(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stxvd2x v31, r1, r4 # 16-byte Folded Spill
; LE-P8-NEXT: lwz r4, 12(r3)
-; LE-P8-NEXT: stfd f22, 464(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stfd f23, 472(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stfd f24, 480(r1) # 8-byte Folded Spill
; LE-P8-NEXT: stfd f25, 488(r1) # 8-byte Folded Spill
; LE-P9-O0: # %bb.0: # %entry
; LE-P9-O0-NEXT: mflr r0
; LE-P9-O0-NEXT: mfcr r12
-; LE-P9-O0-NEXT: std r0, 16(r1)
-; LE-P9-O0-NEXT: hashst r0, -488(r1)
; LE-P9-O0-NEXT: stw r12, 8(r1)
; LE-P9-O0-NEXT: stdu r1, -608(r1)
+; LE-P9-O0-NEXT: std r0, 624(r1)
+; LE-P9-O0-NEXT: hashst r0, -488(r1)
; LE-P9-O0-NEXT: std r14, 320(r1) # 8-byte Folded Spill
; LE-P9-O0-NEXT: std r15, 328(r1) # 8-byte Folded Spill
; LE-P9-O0-NEXT: std r16, 336(r1) # 8-byte Folded Spill
; LE-P8-O0: # %bb.0: # %entry
; LE-P8-O0-NEXT: mflr r0
; LE-P8-O0-NEXT: mfcr r12
-; LE-P8-O0-NEXT: std r0, 16(r1)
-; LE-P8-O0-NEXT: hashst r0, -488(r1)
; LE-P8-O0-NEXT: stw r12, 8(r1)
; LE-P8-O0-NEXT: stdu r1, -608(r1)
+; LE-P8-O0-NEXT: std r0, 624(r1)
+; LE-P8-O0-NEXT: hashst r0, -488(r1)
; LE-P8-O0-NEXT: std r14, 320(r1) # 8-byte Folded Spill
; LE-P8-O0-NEXT: std r15, 328(r1) # 8-byte Folded Spill
; LE-P8-O0-NEXT: std r16, 336(r1) # 8-byte Folded Spill
;
; BE-P9-LABEL: spill:
; BE-P9: # %bb.0: # %entry
-; BE-P9-NEXT: mflr r0
; BE-P9-NEXT: mfcr r12
-; BE-P9-NEXT: std r0, 16(r1)
-; BE-P9-NEXT: hashst r0, -488(r1)
+; BE-P9-NEXT: mflr r0
; BE-P9-NEXT: stw r12, 8(r1)
; BE-P9-NEXT: stdu r1, -624(r1)
-; BE-P9-NEXT: lwz r4, 12(r3)
+; BE-P9-NEXT: std r0, 640(r1)
+; BE-P9-NEXT: hashst r0, -488(r1)
; BE-P9-NEXT: std r14, 336(r1) # 8-byte Folded Spill
-; BE-P9-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v20, 144(r1) # 16-byte Folded Spill
; BE-P9-NEXT: stxv v21, 160(r1) # 16-byte Folded Spill
+; BE-P9-NEXT: lwz r4, 12(r3)
+; BE-P9-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v22, 176(r1) # 16-byte Folded Spill
; BE-P9-NEXT: std r16, 352(r1) # 8-byte Folded Spill
-; BE-P9-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v23, 192(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r18, 368(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v24, 208(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r19, 376(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r18, 368(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v25, 224(r1) # 16-byte Folded Spill
+; BE-P9-NEXT: std r19, 376(r1) # 8-byte Folded Spill
; BE-P9-NEXT: std r20, 384(r1) # 8-byte Folded Spill
-; BE-P9-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v26, 240(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r22, 400(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v27, 256(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r23, 408(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r22, 400(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v28, 272(r1) # 16-byte Folded Spill
+; BE-P9-NEXT: std r23, 408(r1) # 8-byte Folded Spill
; BE-P9-NEXT: std r24, 416(r1) # 8-byte Folded Spill
-; BE-P9-NEXT: std r25, 424(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v29, 288(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r26, 432(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r25, 424(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v30, 304(r1) # 16-byte Folded Spill
-; BE-P9-NEXT: std r27, 440(r1) # 8-byte Folded Spill
+; BE-P9-NEXT: std r26, 432(r1) # 8-byte Folded Spill
; BE-P9-NEXT: stxv v31, 320(r1) # 16-byte Folded Spill
+; BE-P9-NEXT: std r27, 440(r1) # 8-byte Folded Spill
; BE-P9-NEXT: std r28, 448(r1) # 8-byte Folded Spill
; BE-P9-NEXT: std r29, 456(r1) # 8-byte Folded Spill
; BE-P9-NEXT: std r30, 464(r1) # 8-byte Folded Spill
; BE-P8: # %bb.0: # %entry
; BE-P8-NEXT: mfcr r12
; BE-P8-NEXT: mflr r0
-; BE-P8-NEXT: std r0, 16(r1)
-; BE-P8-NEXT: hashst r0, -488(r1)
; BE-P8-NEXT: stw r12, 8(r1)
; BE-P8-NEXT: stdu r1, -624(r1)
; BE-P8-NEXT: li r4, 144
+; BE-P8-NEXT: std r0, 640(r1)
+; BE-P8-NEXT: hashst r0, -488(r1)
; BE-P8-NEXT: std r14, 336(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r16, 352(r1) # 8-byte Folded Spill
-; BE-P8-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v20, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 160
+; BE-P8-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r18, 368(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r19, 376(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r20, 384(r1) # 8-byte Folded Spill
-; BE-P8-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v21, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 176
+; BE-P8-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r22, 400(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r23, 408(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r24, 416(r1) # 8-byte Folded Spill
; BE-P8-NEXT: std r3, 120(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v22, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 192
+; BE-P8-NEXT: stfd f14, 480(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v23, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 208
-; BE-P8-NEXT: stfd f14, 480(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f15, 488(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v24, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 224
-; BE-P8-NEXT: stfd f15, 488(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f16, 496(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v25, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 240
-; BE-P8-NEXT: stfd f16, 496(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f17, 504(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v26, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 256
-; BE-P8-NEXT: stfd f17, 504(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f18, 512(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v27, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 272
-; BE-P8-NEXT: stfd f18, 512(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f19, 520(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v28, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 288
-; BE-P8-NEXT: stfd f19, 520(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f20, 528(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v29, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 304
-; BE-P8-NEXT: stfd f20, 528(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f21, 536(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v30, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: li r4, 320
-; BE-P8-NEXT: stfd f21, 536(r1) # 8-byte Folded Spill
+; BE-P8-NEXT: stfd f22, 544(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stxvd2x v31, r1, r4 # 16-byte Folded Spill
; BE-P8-NEXT: lwz r4, 12(r3)
-; BE-P8-NEXT: stfd f22, 544(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stfd f23, 552(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stfd f24, 560(r1) # 8-byte Folded Spill
; BE-P8-NEXT: stfd f25, 568(r1) # 8-byte Folded Spill
; BE-32BIT-P9-LABEL: spill:
; BE-32BIT-P9: # %bb.0: # %entry
; BE-32BIT-P9-NEXT: mflr r0
-; BE-32BIT-P9-NEXT: stw r0, 4(r1)
-; BE-32BIT-P9-NEXT: hashst r0, -424(r1)
; BE-32BIT-P9-NEXT: stwu r1, -448(r1)
; BE-32BIT-P9-NEXT: mfcr r12
+; BE-32BIT-P9-NEXT: stw r0, 452(r1)
+; BE-32BIT-P9-NEXT: hashst r0, -424(r1)
; BE-32BIT-P9-NEXT: stw r14, 232(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stw r15, 236(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: stw r16, 240(r1) # 4-byte Folded Spill
; BE-32BIT-P8-LABEL: spill:
; BE-32BIT-P8: # %bb.0: # %entry
; BE-32BIT-P8-NEXT: mflr r0
-; BE-32BIT-P8-NEXT: stw r0, 4(r1)
-; BE-32BIT-P8-NEXT: hashst r0, -424(r1)
; BE-32BIT-P8-NEXT: stwu r1, -448(r1)
; BE-32BIT-P8-NEXT: mfcr r12
; BE-32BIT-P8-NEXT: li r4, 32
+; BE-32BIT-P8-NEXT: stw r0, 452(r1)
+; BE-32BIT-P8-NEXT: hashst r0, -424(r1)
; BE-32BIT-P8-NEXT: stw r14, 232(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stw r15, 236(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stw r16, 240(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: stw r12, 228(r1)
; BE-32BIT-P8-NEXT: stxvd2x v20, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 48
+; BE-32BIT-P8-NEXT: stfd f14, 304(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v21, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 64
-; BE-32BIT-P8-NEXT: stfd f14, 304(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT: stfd f15, 312(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v22, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 80
-; BE-32BIT-P8-NEXT: stfd f15, 312(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT: stfd f16, 320(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v23, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 96
-; BE-32BIT-P8-NEXT: stfd f16, 320(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT: stfd f17, 328(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v24, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 112
-; BE-32BIT-P8-NEXT: stfd f17, 328(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT: stfd f18, 336(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v25, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 128
-; BE-32BIT-P8-NEXT: stfd f18, 336(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT: stfd f19, 344(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v26, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 144
-; BE-32BIT-P8-NEXT: stfd f19, 344(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT: stfd f20, 352(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v27, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 160
-; BE-32BIT-P8-NEXT: stfd f20, 352(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT: stfd f21, 360(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v28, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 176
-; BE-32BIT-P8-NEXT: stfd f21, 360(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT: stfd f22, 368(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v29, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 192
-; BE-32BIT-P8-NEXT: stfd f22, 368(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT: stfd f23, 376(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v30, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: li r4, 208
-; BE-32BIT-P8-NEXT: stfd f23, 376(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT: stfd f24, 384(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stxvd2x v31, r1, r4 # 16-byte Folded Spill
; BE-32BIT-P8-NEXT: lwz r4, 12(r3)
-; BE-32BIT-P8-NEXT: stfd f24, 384(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stfd f25, 392(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stfd f26, 400(r1) # 8-byte Folded Spill
; BE-32BIT-P8-NEXT: stfd f27, 408(r1) # 8-byte Folded Spill
;
; LE-P9-PRIV-LABEL: spill:
; LE-P9-PRIV: # %bb.0: # %entry
-; LE-P9-PRIV-NEXT: mflr r0
; LE-P9-PRIV-NEXT: mfcr r12
-; LE-P9-PRIV-NEXT: std r0, 16(r1)
-; LE-P9-PRIV-NEXT: hashstp r0, -488(r1)
+; LE-P9-PRIV-NEXT: mflr r0
; LE-P9-PRIV-NEXT: stw r12, 8(r1)
; LE-P9-PRIV-NEXT: stdu r1, -544(r1)
-; LE-P9-PRIV-NEXT: lwz r4, 12(r3)
+; LE-P9-PRIV-NEXT: std r0, 560(r1)
+; LE-P9-PRIV-NEXT: hashstp r0, -488(r1)
; LE-P9-PRIV-NEXT: std r14, 256(r1) # 8-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r15, 264(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v20, 64(r1) # 16-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v21, 80(r1) # 16-byte Folded Spill
+; LE-P9-PRIV-NEXT: lwz r4, 12(r3)
+; LE-P9-PRIV-NEXT: std r15, 264(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v22, 96(r1) # 16-byte Folded Spill
; LE-P9-PRIV-NEXT: std r16, 272(r1) # 8-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r17, 280(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v23, 112(r1) # 16-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r18, 288(r1) # 8-byte Folded Spill
+; LE-P9-PRIV-NEXT: std r17, 280(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v24, 128(r1) # 16-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r19, 296(r1) # 8-byte Folded Spill
+; LE-P9-PRIV-NEXT: std r18, 288(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v25, 144(r1) # 16-byte Folded Spill
+; LE-P9-PRIV-NEXT: std r19, 296(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: std r20, 304(r1) # 8-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r21, 312(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v26, 160(r1) # 16-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r22, 320(r1) # 8-byte Folded Spill
+; LE-P9-PRIV-NEXT: std r21, 312(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v27, 176(r1) # 16-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r23, 328(r1) # 8-byte Folded Spill
+; LE-P9-PRIV-NEXT: std r22, 320(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v28, 192(r1) # 16-byte Folded Spill
+; LE-P9-PRIV-NEXT: std r23, 328(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: std r24, 336(r1) # 8-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r25, 344(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v29, 208(r1) # 16-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r26, 352(r1) # 8-byte Folded Spill
+; LE-P9-PRIV-NEXT: std r25, 344(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v30, 224(r1) # 16-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r27, 360(r1) # 8-byte Folded Spill
+; LE-P9-PRIV-NEXT: std r26, 352(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: stxv v31, 240(r1) # 16-byte Folded Spill
+; LE-P9-PRIV-NEXT: std r27, 360(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: std r28, 368(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: std r29, 376(r1) # 8-byte Folded Spill
; LE-P9-PRIV-NEXT: std r30, 384(r1) # 8-byte Folded Spill
; LE-P8-PRIV: # %bb.0: # %entry
; LE-P8-PRIV-NEXT: mfcr r12
; LE-P8-PRIV-NEXT: mflr r0
-; LE-P8-PRIV-NEXT: std r0, 16(r1)
-; LE-P8-PRIV-NEXT: hashstp r0, -488(r1)
; LE-P8-PRIV-NEXT: stw r12, 8(r1)
; LE-P8-PRIV-NEXT: stdu r1, -544(r1)
; LE-P8-PRIV-NEXT: li r4, 64
+; LE-P8-PRIV-NEXT: std r0, 560(r1)
+; LE-P8-PRIV-NEXT: hashstp r0, -488(r1)
; LE-P8-PRIV-NEXT: std r14, 256(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: std r15, 264(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: std r16, 272(r1) # 8-byte Folded Spill
-; LE-P8-PRIV-NEXT: std r17, 280(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v20, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 80
+; LE-P8-PRIV-NEXT: std r17, 280(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: std r18, 288(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: std r19, 296(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: std r20, 304(r1) # 8-byte Folded Spill
-; LE-P8-PRIV-NEXT: std r21, 312(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v21, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 96
+; LE-P8-PRIV-NEXT: std r21, 312(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: std r22, 320(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: std r23, 328(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: std r24, 336(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: std r3, 40(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v22, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 112
+; LE-P8-PRIV-NEXT: stfd f14, 400(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v23, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 128
-; LE-P8-PRIV-NEXT: stfd f14, 400(r1) # 8-byte Folded Spill
+; LE-P8-PRIV-NEXT: stfd f15, 408(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v24, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 144
-; LE-P8-PRIV-NEXT: stfd f15, 408(r1) # 8-byte Folded Spill
+; LE-P8-PRIV-NEXT: stfd f16, 416(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v25, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 160
-; LE-P8-PRIV-NEXT: stfd f16, 416(r1) # 8-byte Folded Spill
+; LE-P8-PRIV-NEXT: stfd f17, 424(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v26, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 176
-; LE-P8-PRIV-NEXT: stfd f17, 424(r1) # 8-byte Folded Spill
+; LE-P8-PRIV-NEXT: stfd f18, 432(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v27, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 192
-; LE-P8-PRIV-NEXT: stfd f18, 432(r1) # 8-byte Folded Spill
+; LE-P8-PRIV-NEXT: stfd f19, 440(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v28, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 208
-; LE-P8-PRIV-NEXT: stfd f19, 440(r1) # 8-byte Folded Spill
+; LE-P8-PRIV-NEXT: stfd f20, 448(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v29, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 224
-; LE-P8-PRIV-NEXT: stfd f20, 448(r1) # 8-byte Folded Spill
+; LE-P8-PRIV-NEXT: stfd f21, 456(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v30, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: li r4, 240
-; LE-P8-PRIV-NEXT: stfd f21, 456(r1) # 8-byte Folded Spill
+; LE-P8-PRIV-NEXT: stfd f22, 464(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stxvd2x v31, r1, r4 # 16-byte Folded Spill
; LE-P8-PRIV-NEXT: lwz r4, 12(r3)
-; LE-P8-PRIV-NEXT: stfd f22, 464(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stfd f23, 472(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stfd f24, 480(r1) # 8-byte Folded Spill
; LE-P8-PRIV-NEXT: stfd f25, 488(r1) # 8-byte Folded Spill
;
; BE-P9-PRIV-LABEL: spill:
; BE-P9-PRIV: # %bb.0: # %entry
-; BE-P9-PRIV-NEXT: mflr r0
; BE-P9-PRIV-NEXT: mfcr r12
-; BE-P9-PRIV-NEXT: std r0, 16(r1)
-; BE-P9-PRIV-NEXT: hashstp r0, -488(r1)
+; BE-P9-PRIV-NEXT: mflr r0
; BE-P9-PRIV-NEXT: stw r12, 8(r1)
; BE-P9-PRIV-NEXT: stdu r1, -624(r1)
-; BE-P9-PRIV-NEXT: lwz r4, 12(r3)
+; BE-P9-PRIV-NEXT: std r0, 640(r1)
+; BE-P9-PRIV-NEXT: hashstp r0, -488(r1)
; BE-P9-PRIV-NEXT: std r14, 336(r1) # 8-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v20, 144(r1) # 16-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v21, 160(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT: lwz r4, 12(r3)
+; BE-P9-PRIV-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v22, 176(r1) # 16-byte Folded Spill
; BE-P9-PRIV-NEXT: std r16, 352(r1) # 8-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v23, 192(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r18, 368(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v24, 208(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r19, 376(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r18, 368(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v25, 224(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r19, 376(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: std r20, 384(r1) # 8-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v26, 240(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r22, 400(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v27, 256(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r23, 408(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r22, 400(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v28, 272(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r23, 408(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: std r24, 416(r1) # 8-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r25, 424(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v29, 288(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r26, 432(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r25, 424(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v30, 304(r1) # 16-byte Folded Spill
-; BE-P9-PRIV-NEXT: std r27, 440(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r26, 432(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: stxv v31, 320(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT: std r27, 440(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: std r28, 448(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: std r29, 456(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: std r30, 464(r1) # 8-byte Folded Spill
; BE-P8-PRIV: # %bb.0: # %entry
; BE-P8-PRIV-NEXT: mfcr r12
; BE-P8-PRIV-NEXT: mflr r0
-; BE-P8-PRIV-NEXT: std r0, 16(r1)
-; BE-P8-PRIV-NEXT: hashstp r0, -488(r1)
; BE-P8-PRIV-NEXT: stw r12, 8(r1)
; BE-P8-PRIV-NEXT: stdu r1, -624(r1)
; BE-P8-PRIV-NEXT: li r4, 144
+; BE-P8-PRIV-NEXT: std r0, 640(r1)
+; BE-P8-PRIV-NEXT: hashstp r0, -488(r1)
; BE-P8-PRIV-NEXT: std r14, 336(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r15, 344(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r16, 352(r1) # 8-byte Folded Spill
-; BE-P8-PRIV-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v20, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 160
+; BE-P8-PRIV-NEXT: std r17, 360(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r18, 368(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r19, 376(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r20, 384(r1) # 8-byte Folded Spill
-; BE-P8-PRIV-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v21, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 176
+; BE-P8-PRIV-NEXT: std r21, 392(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r22, 400(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r23, 408(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r24, 416(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: std r3, 120(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v22, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 192
+; BE-P8-PRIV-NEXT: stfd f14, 480(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v23, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 208
-; BE-P8-PRIV-NEXT: stfd f14, 480(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f15, 488(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v24, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 224
-; BE-P8-PRIV-NEXT: stfd f15, 488(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f16, 496(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v25, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 240
-; BE-P8-PRIV-NEXT: stfd f16, 496(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f17, 504(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v26, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 256
-; BE-P8-PRIV-NEXT: stfd f17, 504(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f18, 512(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v27, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 272
-; BE-P8-PRIV-NEXT: stfd f18, 512(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f19, 520(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v28, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 288
-; BE-P8-PRIV-NEXT: stfd f19, 520(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f20, 528(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v29, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 304
-; BE-P8-PRIV-NEXT: stfd f20, 528(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f21, 536(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v30, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: li r4, 320
-; BE-P8-PRIV-NEXT: stfd f21, 536(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT: stfd f22, 544(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stxvd2x v31, r1, r4 # 16-byte Folded Spill
; BE-P8-PRIV-NEXT: lwz r4, 12(r3)
-; BE-P8-PRIV-NEXT: stfd f22, 544(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stfd f23, 552(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stfd f24, 560(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: stfd f25, 568(r1) # 8-byte Folded Spill
; LE-P9-NEXT: # %bb.1: # %if.end
; LE-P9-NEXT: mflr r0
; LE-P9-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; LE-P9-NEXT: std r0, 16(r1)
-; LE-P9-NEXT: hashst r0, -24(r1)
; LE-P9-NEXT: stdu r1, -64(r1)
+; LE-P9-NEXT: std r0, 80(r1)
+; LE-P9-NEXT: hashst r0, -24(r1)
; LE-P9-NEXT: mr r30, r3
; LE-P9-NEXT: lwz r3, 12(r3)
; LE-P9-NEXT: stw r3, 36(r1)
; LE-P8-NEXT: # %bb.1: # %if.end
; LE-P8-NEXT: mflr r0
; LE-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; LE-P8-NEXT: std r0, 16(r1)
-; LE-P8-NEXT: hashst r0, -24(r1)
; LE-P8-NEXT: stdu r1, -64(r1)
+; LE-P8-NEXT: std r0, 80(r1)
+; LE-P8-NEXT: hashst r0, -24(r1)
; LE-P8-NEXT: mr r30, r3
; LE-P8-NEXT: lwz r3, 12(r3)
; LE-P8-NEXT: stw r3, 36(r1)
; LE-P9-O0-LABEL: shrinkwrap:
; LE-P9-O0: # %bb.0: # %entry
; LE-P9-O0-NEXT: mflr r0
-; LE-P9-O0-NEXT: std r0, 16(r1)
-; LE-P9-O0-NEXT: hashst r0, -8(r1)
; LE-P9-O0-NEXT: stdu r1, -128(r1)
+; LE-P9-O0-NEXT: std r0, 144(r1)
+; LE-P9-O0-NEXT: hashst r0, -8(r1)
; LE-P9-O0-NEXT: mr. r4, r3
; LE-P9-O0-NEXT: std r4, 104(r1) # 8-byte Folded Spill
; LE-P9-O0-NEXT: li r3, 0
; LE-P8-O0-LABEL: shrinkwrap:
; LE-P8-O0: # %bb.0: # %entry
; LE-P8-O0-NEXT: mflr r0
-; LE-P8-O0-NEXT: std r0, 16(r1)
-; LE-P8-O0-NEXT: hashst r0, -8(r1)
; LE-P8-O0-NEXT: stdu r1, -128(r1)
+; LE-P8-O0-NEXT: std r0, 144(r1)
+; LE-P8-O0-NEXT: hashst r0, -8(r1)
; LE-P8-O0-NEXT: mr. r4, r3
; LE-P8-O0-NEXT: std r4, 104(r1) # 8-byte Folded Spill
; LE-P8-O0-NEXT: li r3, 0
; BE-P9-NEXT: beq cr0, .LBB2_2
; BE-P9-NEXT: # %bb.1: # %if.end
; BE-P9-NEXT: mflr r0
-; BE-P9-NEXT: std r0, 16(r1)
-; BE-P9-NEXT: hashst r0, -24(r1)
; BE-P9-NEXT: stdu r1, -144(r1)
+; BE-P9-NEXT: std r0, 160(r1)
+; BE-P9-NEXT: hashst r0, -24(r1)
; BE-P9-NEXT: std r30, 128(r1) # 8-byte Folded Spill
; BE-P9-NEXT: mr r30, r3
; BE-P9-NEXT: lwz r3, 12(r3)
; BE-P8-NEXT: beq cr0, .LBB2_2
; BE-P8-NEXT: # %bb.1: # %if.end
; BE-P8-NEXT: mflr r0
-; BE-P8-NEXT: std r0, 16(r1)
-; BE-P8-NEXT: hashst r0, -24(r1)
; BE-P8-NEXT: stdu r1, -144(r1)
+; BE-P8-NEXT: std r0, 160(r1)
+; BE-P8-NEXT: hashst r0, -24(r1)
; BE-P8-NEXT: std r30, 128(r1) # 8-byte Folded Spill
; BE-P8-NEXT: mr r30, r3
; BE-P8-NEXT: lwz r3, 12(r3)
; BE-32BIT-P9-LABEL: shrinkwrap:
; BE-32BIT-P9: # %bb.0: # %entry
; BE-32BIT-P9-NEXT: mflr r0
-; BE-32BIT-P9-NEXT: stw r0, 4(r1)
-; BE-32BIT-P9-NEXT: hashst r0, -16(r1)
; BE-32BIT-P9-NEXT: stwu r1, -32(r1)
; BE-32BIT-P9-NEXT: cmplwi r3, 0
+; BE-32BIT-P9-NEXT: stw r0, 36(r1)
+; BE-32BIT-P9-NEXT: hashst r0, -16(r1)
; BE-32BIT-P9-NEXT: stw r30, 24(r1) # 4-byte Folded Spill
; BE-32BIT-P9-NEXT: beq cr0, .LBB2_2
; BE-32BIT-P9-NEXT: # %bb.1: # %if.end
; BE-32BIT-P8-LABEL: shrinkwrap:
; BE-32BIT-P8: # %bb.0: # %entry
; BE-32BIT-P8-NEXT: mflr r0
-; BE-32BIT-P8-NEXT: stw r0, 4(r1)
-; BE-32BIT-P8-NEXT: hashst r0, -16(r1)
; BE-32BIT-P8-NEXT: stwu r1, -32(r1)
; BE-32BIT-P8-NEXT: cmplwi r3, 0
+; BE-32BIT-P8-NEXT: stw r0, 36(r1)
+; BE-32BIT-P8-NEXT: hashst r0, -16(r1)
; BE-32BIT-P8-NEXT: stw r30, 24(r1) # 4-byte Folded Spill
; BE-32BIT-P8-NEXT: beq cr0, .LBB2_2
; BE-32BIT-P8-NEXT: # %bb.1: # %if.end
; LE-P9-PRIV-NEXT: # %bb.1: # %if.end
; LE-P9-PRIV-NEXT: mflr r0
; LE-P9-PRIV-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; LE-P9-PRIV-NEXT: std r0, 16(r1)
-; LE-P9-PRIV-NEXT: hashstp r0, -24(r1)
; LE-P9-PRIV-NEXT: stdu r1, -64(r1)
+; LE-P9-PRIV-NEXT: std r0, 80(r1)
+; LE-P9-PRIV-NEXT: hashstp r0, -24(r1)
; LE-P9-PRIV-NEXT: mr r30, r3
; LE-P9-PRIV-NEXT: lwz r3, 12(r3)
; LE-P9-PRIV-NEXT: stw r3, 36(r1)
; LE-P8-PRIV-NEXT: # %bb.1: # %if.end
; LE-P8-PRIV-NEXT: mflr r0
; LE-P8-PRIV-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; LE-P8-PRIV-NEXT: std r0, 16(r1)
-; LE-P8-PRIV-NEXT: hashstp r0, -24(r1)
; LE-P8-PRIV-NEXT: stdu r1, -64(r1)
+; LE-P8-PRIV-NEXT: std r0, 80(r1)
+; LE-P8-PRIV-NEXT: hashstp r0, -24(r1)
; LE-P8-PRIV-NEXT: mr r30, r3
; LE-P8-PRIV-NEXT: lwz r3, 12(r3)
; LE-P8-PRIV-NEXT: stw r3, 36(r1)
; BE-P9-PRIV-NEXT: beq cr0, .LBB2_2
; BE-P9-PRIV-NEXT: # %bb.1: # %if.end
; BE-P9-PRIV-NEXT: mflr r0
-; BE-P9-PRIV-NEXT: std r0, 16(r1)
-; BE-P9-PRIV-NEXT: hashstp r0, -24(r1)
; BE-P9-PRIV-NEXT: stdu r1, -144(r1)
+; BE-P9-PRIV-NEXT: std r0, 160(r1)
+; BE-P9-PRIV-NEXT: hashstp r0, -24(r1)
; BE-P9-PRIV-NEXT: std r30, 128(r1) # 8-byte Folded Spill
; BE-P9-PRIV-NEXT: mr r30, r3
; BE-P9-PRIV-NEXT: lwz r3, 12(r3)
; BE-P8-PRIV-NEXT: beq cr0, .LBB2_2
; BE-P8-PRIV-NEXT: # %bb.1: # %if.end
; BE-P8-PRIV-NEXT: mflr r0
-; BE-P8-PRIV-NEXT: std r0, 16(r1)
-; BE-P8-PRIV-NEXT: hashstp r0, -24(r1)
; BE-P8-PRIV-NEXT: stdu r1, -144(r1)
+; BE-P8-PRIV-NEXT: std r0, 160(r1)
+; BE-P8-PRIV-NEXT: hashstp r0, -24(r1)
; BE-P8-PRIV-NEXT: std r30, 128(r1) # 8-byte Folded Spill
; BE-P8-PRIV-NEXT: mr r30, r3
; BE-P8-PRIV-NEXT: lwz r3, 12(r3)
; LE-P9-O0: # %bb.0: # %entry
; LE-P9-O0-NEXT: mflr r0
; LE-P9-O0-NEXT: std r30, -16(r1)
+; LE-P9-O0-NEXT: mr r30, r1
; LE-P9-O0-NEXT: std r0, 16(r1)
; LE-P9-O0-NEXT: hashst r0, -24(r1)
-; LE-P9-O0-NEXT: mr r30, r1
; LE-P9-O0-NEXT: clrldi r0, r1, 49
; LE-P9-O0-NEXT: lis r12, -1
; LE-P9-O0-NEXT: subc r0, r12, r0
; LE-P8-O0: # %bb.0: # %entry
; LE-P8-O0-NEXT: mflr r0
; LE-P8-O0-NEXT: std r30, -16(r1)
+; LE-P8-O0-NEXT: mr r30, r1
; LE-P8-O0-NEXT: std r0, 16(r1)
; LE-P8-O0-NEXT: hashst r0, -24(r1)
-; LE-P8-O0-NEXT: mr r30, r1
; LE-P8-O0-NEXT: clrldi r0, r1, 49
; LE-P8-O0-NEXT: lis r12, -1
; LE-P8-O0-NEXT: subc r0, r12, r0
; PC64LE-LABEL: test_fadd_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl __gcc_qadd
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_fadd_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl __gcc_qadd
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_fadd_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl __gcc_qadd
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_fsub_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl __gcc_qsub
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_fsub_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl __gcc_qsub
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_fsub_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl __gcc_qsub
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_fmul_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl __gcc_qmul
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_fmul_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl __gcc_qmul
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_fmul_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl __gcc_qmul
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_fdiv_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl __gcc_qdiv
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_fdiv_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl __gcc_qdiv
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_fdiv_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl __gcc_qdiv
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_frem_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl fmodl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_frem_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl fmodl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_frem_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl fmodl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_fma_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl fmal
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_fma_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl fmal
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_fma_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl fmal
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_sqrt_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl sqrtl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_sqrt_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl sqrtl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_sqrt_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl sqrtl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_pow_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl powl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_pow_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl powl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_pow_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl powl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_powi_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
; PC64LE-NEXT: clrldi 5, 5, 32
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl __powitf2
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_powi_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
; PC64LE9-NEXT: clrldi 5, 5, 32
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl __powitf2
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_powi_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
; PC64-NEXT: clrldi 5, 5, 32
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl __powitf2
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_sin_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl sinl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_sin_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl sinl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_sin_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl sinl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_cos_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl cosl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_cos_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl cosl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_cos_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl cosl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_exp_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl expl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_exp_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl expl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_exp_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl expl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_exp2_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl exp2l
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_exp2_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl exp2l
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_exp2_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl exp2l
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_log_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl logl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_log_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl logl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_log_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl logl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_log2_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl log2l
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_log2_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl log2l
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_log2_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl log2l
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_log10_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl log10l
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_log10_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl log10l
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_log10_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl log10l
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_rint_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl rintl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_rint_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl rintl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_rint_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl rintl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_nearbyint_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl nearbyintl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_nearbyint_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl nearbyintl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_nearbyint_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl nearbyintl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_maxnum_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl fmaxl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_maxnum_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl fmaxl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_maxnum_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl fmaxl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_minnum_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl fminl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_minnum_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl fminl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_minnum_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl fminl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_ceil_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl ceill
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_ceil_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl ceill
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_ceil_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl ceill
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_floor_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl floorl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_floor_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl floorl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_floor_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl floorl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_round_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl roundl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_round_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl roundl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_round_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl roundl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_trunc_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl truncl
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_trunc_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl truncl
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_trunc_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl truncl
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_fptosi_ppc_i64_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl __fixtfdi
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_fptosi_ppc_i64_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl __fixtfdi
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_fptosi_ppc_i64_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl __fixtfdi
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-LABEL: test_fptoui_ppc_i64_ppc_fp128:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl __fixunstfdi
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: test_fptoui_ppc_i64_ppc_fp128:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl __fixunstfdi
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: test_fptoui_ppc_i64_ppc_fp128:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl __fixunstfdi
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
; PC64LE-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -48(1)
; PC64LE-NEXT: addis 3, 2, .LCPI31_0@toc@ha
; PC64LE-NEXT: xxlxor 3, 3, 3
+; PC64LE-NEXT: std 0, 64(1)
; PC64LE-NEXT: lfs 0, .LCPI31_0@toc@l(3)
; PC64LE-NEXT: lis 3, -32768
; PC64LE-NEXT: fcmpo 0, 2, 3
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
; PC64LE9-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -48(1)
; PC64LE9-NEXT: addis 3, 2, .LCPI31_0@toc@ha
; PC64LE9-NEXT: xxlxor 3, 3, 3
+; PC64LE9-NEXT: std 0, 64(1)
; PC64LE9-NEXT: lfs 0, .LCPI31_0@toc@l(3)
; PC64LE9-NEXT: fcmpo 1, 2, 3
; PC64LE9-NEXT: lis 3, -32768
-; PC64LE9-NEXT: fcmpo 0, 1, 0
; PC64LE9-NEXT: xxlxor 3, 3, 3
+; PC64LE9-NEXT: fcmpo 0, 1, 0
; PC64LE9-NEXT: crand 20, 2, 4
; PC64LE9-NEXT: crandc 21, 0, 2
; PC64LE9-NEXT: cror 20, 21, 20
;
; PC64-LABEL: test_fptoui_ppc_i32_ppc_fp128:
; PC64: # %bb.0: # %entry
-; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: mfcr 12
+; PC64-NEXT: mflr 0
; PC64-NEXT: stw 12, 8(1)
; PC64-NEXT: stdu 1, -128(1)
; PC64-NEXT: addis 3, 2, .LCPI31_0@toc@ha
+; PC64-NEXT: std 0, 144(1)
; PC64-NEXT: lfs 0, .LCPI31_0@toc@l(3)
; PC64-NEXT: addis 3, 2, .LCPI31_1@toc@ha
; PC64-NEXT: lfs 4, .LCPI31_1@toc@l(3)
; PC64LE-NEXT: stfd 29, -24(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 30, -16(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, -8(1) # 8-byte Folded Spill
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: mr 29, 3
; PC64LE-NEXT: xxlxor 2, 2, 2
; PC64LE-NEXT: li 3, 0
; PC64LE9-NEXT: stfd 29, -24(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stfd 30, -16(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stfd 31, -8(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
-; PC64LE9-NEXT: lfs 31, 0(3)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: mr 29, 3
-; PC64LE9-NEXT: li 3, 0
; PC64LE9-NEXT: xxlxor 2, 2, 2
-; PC64LE9-NEXT: xxlxor 4, 4, 4
; PC64LE9-NEXT: mr 30, 4
+; PC64LE9-NEXT: lfs 31, 0(3)
+; PC64LE9-NEXT: li 3, 0
+; PC64LE9-NEXT: xxlxor 4, 4, 4
; PC64LE9-NEXT: std 3, 8(4)
; PC64LE9-NEXT: fmr 1, 31
; PC64LE9-NEXT: fmr 3, 31
; PC64-LABEL: test_constrained_libcall_multichain:
; PC64: # %bb.0:
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -176(1)
+; PC64-NEXT: std 0, 192(1)
; PC64-NEXT: std 29, 120(1) # 8-byte Folded Spill
; PC64-NEXT: mr 29, 3
; PC64-NEXT: li 3, 0
; PC64LE-LABEL: i64_to_ppcq:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl __floatditf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: i64_to_ppcq:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl __floatditf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: i64_to_ppcq:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl __floatditf
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-NEXT: std 30, -32(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 30, -16(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, -8(1) # 8-byte Folded Spill
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -64(1)
+; PC64LE-NEXT: std 0, 80(1)
; PC64LE-NEXT: mr 30, 3
; PC64LE-NEXT: bl __floatditf
; PC64LE-NEXT: nop
; PC64LE9-NEXT: std 30, -32(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stfd 30, -16(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stfd 31, -8(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: mr 30, 3
; PC64LE9-NEXT: bl __floatditf
; PC64LE9-NEXT: nop
; PC64-LABEL: u64_to_ppcq:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -144(1)
+; PC64-NEXT: std 0, 160(1)
; PC64-NEXT: std 30, 112(1) # 8-byte Folded Spill
; PC64-NEXT: stfd 30, 128(1) # 8-byte Folded Spill
; PC64-NEXT: mr 30, 3
; PC64LE-LABEL: i128_to_ppcq:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl __floattitf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: i128_to_ppcq:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl __floattitf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64-LABEL: i128_to_ppcq:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: bl __floattitf
; PC64-NEXT: nop
; PC64-NEXT: addi 1, 1, 112
; PC64LE-NEXT: std 30, -32(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 30, -16(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, -8(1) # 8-byte Folded Spill
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -64(1)
+; PC64LE-NEXT: std 0, 80(1)
; PC64LE-NEXT: mr 30, 4
; PC64LE-NEXT: bl __floattitf
; PC64LE-NEXT: nop
; PC64LE9-NEXT: std 30, -32(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stfd 30, -16(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stfd 31, -8(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: mr 30, 4
; PC64LE9-NEXT: bl __floattitf
; PC64LE9-NEXT: nop
; PC64-LABEL: u128_to_ppcq:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -144(1)
+; PC64-NEXT: std 0, 160(1)
; PC64-NEXT: std 30, 112(1) # 8-byte Folded Spill
; PC64-NEXT: stfd 30, 128(1) # 8-byte Folded Spill
; PC64-NEXT: mr 30, 3
; PC64LE-LABEL: ppcq_to_s1:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: .cfi_def_cfa_offset 32
; PC64LE-NEXT: .cfi_offset lr, 16
; PC64LE-NEXT: bl __gcc_qtou
; PC64LE9-LABEL: ppcq_to_s1:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: .cfi_def_cfa_offset 32
; PC64LE9-NEXT: .cfi_offset lr, 16
; PC64LE9-NEXT: bl __gcc_qtou
; PC64-LABEL: ppcq_to_s1:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: .cfi_def_cfa_offset 112
; PC64-NEXT: .cfi_offset lr, 16
; PC64-NEXT: bl __gcc_qtou
; PC64LE-LABEL: ppcq_to_u1:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: .cfi_def_cfa_offset 32
; PC64LE-NEXT: .cfi_offset lr, 16
; PC64LE-NEXT: bl __fixunstfsi
; PC64LE9-LABEL: ppcq_to_u1:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: .cfi_def_cfa_offset 32
; PC64LE9-NEXT: .cfi_offset lr, 16
; PC64LE9-NEXT: bl __fixunstfsi
; PC64-LABEL: ppcq_to_u1:
; PC64: # %bb.0: # %entry
; PC64-NEXT: mflr 0
-; PC64-NEXT: std 0, 16(1)
; PC64-NEXT: stdu 1, -112(1)
+; PC64-NEXT: std 0, 128(1)
; PC64-NEXT: .cfi_def_cfa_offset 112
; PC64-NEXT: .cfi_offset lr, 16
; PC64-NEXT: bl __fixunstfsi
; CHECK-LABEL: caller:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC0@toc@ha
; CHECK-LABEL: caller_const:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LCPI2_0@toc@ha
; CHECK-LABEL: use_result:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl test_result
; CHECK-LABEL: caller_result:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl test_result
; CHECK-LABEL: main:
; CHECK: # %bb.0: # %L.entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: addis 3, 2, .LC0@toc@ha
; CHECK-LABEL: testFunc:
; CHECK: # %bb.0: # %L.entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -32(1)
+; CHECK-NEXT: std 0, 48(1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl .L2$pb
; CHECK-NEXT: mflr 0
; CHECK-NEXT: std 29, -24(1) # 8-byte Folded Spill
; CHECK-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -64(1)
+; CHECK-NEXT: std 0, 80(1)
; CHECK-NEXT: ld 29, 0(3)
; CHECK-NEXT: ld 30, 32(1)
; CHECK-NEXT: cmpld 30, 29
define void @test(ptr %arg, ptr %arg1, ptr %arg2) unnamed_addr personality ptr @personality {
; CHECK-LABEL: test:
-; CHECK: .cfi_personality 148, DW.ref.personality
-; CHECK-NEXT: .cfi_lsda 20, .Lexception0
-; CHECK-NEXT: .Lfunc_gep0:
-; CHECK-NEXT: addis r2, r12, .TOC.-.Lfunc_gep0@ha
-; CHECK-NEXT: addi r2, r2, .TOC.-.Lfunc_gep0@l
-; CHECK-NEXT: .Lfunc_lep0:
-; CHECK-NEXT: .localentry test, .Lfunc_lep0-.Lfunc_gep0
-; CHECK-NEXT: # %bb.0: # %bb
+; CHECK: # %bb.0: # %bb
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: li r4, 0
; CHECK-NEXT: .cfi_offset r30, -16
; CHECK-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -64(r1)
; CHECK-NEXT: sub r30, r4, r3
; CHECK-NEXT: li r29, -4
+; CHECK-NEXT: std r0, 80(r1)
; CHECK-NEXT: .p2align 5
; CHECK-NEXT: .LBB0_3: # %bb5
; CHECK-NEXT: #
; CHECK-LABEL: b:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -144(r1)
+; CHECK-NEXT: std r0, 160(r1)
; CHECK-NEXT: addis r3, r2, a@toc@ha
; CHECK-NEXT: li r4, 1
; CHECK-NEXT: lfd f0, a@toc@l(r3)
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: mr r30, r3
; CHECK-NEXT: ld r3, 8(r3)
; CHECK-NEXT: lwz r4, 36(r30)
; CHECK-NEXT: rldicl r3, r3, 60, 4
-; CHECK-NEXT: slwi r3, r3, 31
; CHECK-NEXT: clrlwi r4, r4, 31
+; CHECK-NEXT: slwi r3, r3, 31
; CHECK-NEXT: rlwimi r4, r3, 0, 0, 0
; CHECK-NEXT: bl _ZN1llsE1d
; CHECK-NEXT: nop
; CHECK-LABEL: g:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -112(r1)
+; CHECK-NEXT: std r0, 128(r1)
; CHECK-NEXT: bl i
; CHECK-NEXT: nop
; CHECK-NEXT: addis r4, r2, g@toc@ha
; CHECK-LABEL: h:
; CHECK: # %bb.0: # %bb
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -64(1)
; CHECK-NEXT: addis 3, 2, g@toc@ha
+; CHECK-NEXT: std 0, 80(1)
; CHECK-NEXT: std 30, 48(1) # 8-byte Folded Spill
; CHECK-NEXT: lwz 3, g@toc@l(3)
; CHECK-NEXT: extswsli 30, 3, 2
; CHECK-LABEL: d:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -208(r1)
; CHECK-NEXT: addis r3, r2, .LC0@toc@ha
-; CHECK-NEXT: std r29, 184(r1) # 8-byte Folded Spill
+; CHECK-NEXT: std r0, 224(r1)
; CHECK-NEXT: ld r3, .LC0@toc@l(r3)
+; CHECK-NEXT: std r29, 184(r1) # 8-byte Folded Spill
; CHECK-NEXT: std r30, 192(r1) # 8-byte Folded Spill
; CHECK-NEXT: ld r29, 0(r3)
; CHECK-NEXT: bl c
; CHECK: # %bb.0: # %bb
; CHECK-NEXT: mflr r0
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
; CHECK-NEXT: li r3, 1
; CHECK-NEXT: li r30, 0
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: .p2align 4
; CHECK-NEXT: .LBB0_1: # %bb3
; CHECK-NEXT: #
; CHECK: # %bb.0: # %bb
; CHECK-NEXT: mflr r0
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -48(r1)
; CHECK-NEXT: li r30, 3
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: .p2align 5
; CHECK-NEXT: .LBB1_1: # %bb1
; CHECK-NEXT: #
; CHECK: # %bb.0: # %bb
; CHECK-NEXT: mfocrf r12, 32
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stw r12, 8(r1)
; CHECK-NEXT: stdu r1, -48(r1)
-; CHECK-NEXT: ld r3, 0(r3)
+; CHECK-NEXT: std r0, 64(r1)
; CHECK-NEXT: std r30, 32(r1) # 8-byte Folded Spill
; CHECK-NEXT: # implicit-def: $x30
+; CHECK-NEXT: ld r3, 0(r3)
; CHECK-NEXT: cmpdi r3, 0
; CHECK-NEXT: crnot 4*cr2+lt, eq
; CHECK-NEXT: bc 12, 4*cr5+lt, .LBB2_3
; CHECK-NEXT: std r29, -32(r1) # 8-byte Folded Spill
; CHECK-NEXT: std r30, -24(r1) # 8-byte Folded Spill
; CHECK-NEXT: stfd f31, -8(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -64(r1)
; CHECK-NEXT: fmr f31, f1
; CHECK-NEXT: li r30, 0
; CHECK-NEXT: li r29, 0
+; CHECK-NEXT: std r0, 80(r1)
; CHECK-NEXT: .p2align 5
; CHECK-NEXT: .LBB3_1: # %bb1
; CHECK-NEXT: #
; CHECK-NEXT: mflr 0
; CHECK-NEXT: std 29, -24(1) # 8-byte Folded Spill
; CHECK-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -64(1)
+; CHECK-NEXT: std 0, 80(1)
; CHECK-NEXT: lwz 30, 0(3)
; CHECK-NEXT: addis 3, 2, .LC0@toc@ha
; CHECK-NEXT: ld 29, .LC0@toc@l(3)
; CHECK-LABEL: test2:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
; CHECK-NEXT: add r3, r4, r3
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: addi r3, r3, 11
; CHECK-NEXT: clrlwi r3, r3, 16
; CHECK-NEXT: bl __gnu_h2f_ieee
; CHECK-LABEL: baz:
; CHECK: # %bb.0: # %bb
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -16(1)
; CHECK-NEXT: # implicit-def: $r3
+; CHECK-NEXT: stw 0, 20(1)
; CHECK-NEXT: .p2align 4
; CHECK-NEXT: .LBB0_1: # %bb1
; CHECK-NEXT: #
; CHECK-LABEL: wombat:
; CHECK: # %bb.0: # %bb
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -48(1)
; CHECK-NEXT: li 3, .LCPI1_0@l
; CHECK-NEXT: li 5, .LCPI1_1@l
; CHECK-NEXT: lis 4, .LCPI1_0@ha
; CHECK-NEXT: lis 6, .LCPI1_1@ha
+; CHECK-NEXT: stw 0, 52(1)
; CHECK-NEXT: evstdd 29, 24(1) # 8-byte Folded Spill
; CHECK-NEXT: evstdd 30, 32(1) # 8-byte Folded Spill
; CHECK-NEXT: evlddx 30, 4, 3
; CHECK-LABEL: callee:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -16(1)
; CHECK-NEXT: lfs 1, 24(1)
; CHECK-NEXT: lis 3, .L.str@ha
; CHECK-NEXT: lfs 3, 32(1)
; CHECK-NEXT: creqv 6, 6, 6
; CHECK-NEXT: lfs 4, 36(1)
+; CHECK-NEXT: stw 0, 20(1)
; CHECK-NEXT: bl printf
; CHECK-NEXT: lwz 0, 20(1)
; CHECK-NEXT: addi 1, 1, 16
; CHECK-NEXT: .cfi_offset f31, -8
; CHECK-NEXT: std 30, -24(1) # 8-byte Folded Spill
; CHECK-NEXT: stfd 31, -8(1) # 8-byte Folded Spill
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -64(1)
+; CHECK-NEXT: std 0, 80(1)
; CHECK-NEXT: fmr 31, 1
; CHECK-NEXT: mr 30, 4
; CHECK-NEXT: mffs 0
; CHECK-NEXT: .cfi_offset f31, -8
; CHECK-NEXT: std 30, -24(1) # 8-byte Folded Spill
; CHECK-NEXT: stfd 31, -8(1) # 8-byte Folded Spill
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -64(1)
+; CHECK-NEXT: std 0, 80(1)
; CHECK-NEXT: fmr 31, 1
; CHECK-NEXT: mr 30, 4
; CHECK-NEXT: mffs 0
; CHECK-P7-LABEL: hoo5_fmf:
; CHECK-P7: # %bb.0:
; CHECK-P7-NEXT: mflr 0
-; CHECK-P7-NEXT: std 0, 16(1)
; CHECK-P7-NEXT: stdu 1, -112(1)
+; CHECK-P7-NEXT: std 0, 128(1)
; CHECK-P7-NEXT: bl sqrtf128
; CHECK-P7-NEXT: nop
; CHECK-P7-NEXT: addi 1, 1, 112
; CHECK-P8-LABEL: hoo5_fmf:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr 0
-; CHECK-P8-NEXT: std 0, 16(1)
; CHECK-P8-NEXT: stdu 1, -32(1)
+; CHECK-P8-NEXT: std 0, 48(1)
; CHECK-P8-NEXT: bl sqrtf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: addi 1, 1, 32
; CHECK-P7-LABEL: hoo5_safe:
; CHECK-P7: # %bb.0:
; CHECK-P7-NEXT: mflr 0
-; CHECK-P7-NEXT: std 0, 16(1)
; CHECK-P7-NEXT: stdu 1, -112(1)
+; CHECK-P7-NEXT: std 0, 128(1)
; CHECK-P7-NEXT: bl sqrtf128
; CHECK-P7-NEXT: nop
; CHECK-P7-NEXT: addi 1, 1, 112
; CHECK-P8-LABEL: hoo5_safe:
; CHECK-P8: # %bb.0:
; CHECK-P8-NEXT: mflr 0
-; CHECK-P8-NEXT: std 0, 16(1)
; CHECK-P8-NEXT: stdu 1, -32(1)
+; CHECK-P8-NEXT: std 0, 48(1)
; CHECK-P8-NEXT: bl sqrtf128
; CHECK-P8-NEXT: nop
; CHECK-P8-NEXT: addi 1, 1, 32
; CHECK-LABEL: caller:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -240(r1)
+; CHECK-NEXT: std r0, 256(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 240
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: .cfi_offset v20, -192
define void @redundancy_on_ppc_only(i1 %arg7) nounwind {
; PPC64LE-LABEL: redundancy_on_ppc_only:
; PPC64LE: # %bb.0: # %bb
-; PPC64LE-NEXT: mflr 0
; PPC64LE-NEXT: andi. 3, 3, 1
-; PPC64LE-NEXT: std 0, 16(1)
+; PPC64LE-NEXT: mflr 0
; PPC64LE-NEXT: stdu 1, -32(1)
; PPC64LE-NEXT: li 3, 1
; PPC64LE-NEXT: li 4, 0
+; PPC64LE-NEXT: std 0, 48(1)
; PPC64LE-NEXT: iselgt 3, 3, 4
; PPC64LE-NEXT: bl barney.88
; PPC64LE-NEXT: nop
; PPC64LE-LABEL: redundancy_on_ppc_and_other_targets:
; PPC64LE: # %bb.0:
; PPC64LE-NEXT: mflr 0
-; PPC64LE-NEXT: std 0, 16(1)
; PPC64LE-NEXT: stdu 1, -32(1)
; PPC64LE-NEXT: addis 3, 2, .LC0@toc@ha
; PPC64LE-NEXT: li 4, 0
+; PPC64LE-NEXT: std 0, 48(1)
; PPC64LE-NEXT: ld 3, .LC0@toc@l(3)
; PPC64LE-NEXT: std 4, 0(3)
; PPC64LE-NEXT: bl barney.94
; PPC32: foo
; PPC32: mflr 0
-; PPC32: stw 0, 4(1)
; PPC32: stwu 1, -[[STACK:[0-9]+]](1)
+; PPC32: stw 0, 20(1)
; PPC32: lwz [[REG:[0-9]+]], [[RETADDR:[0-9]+]](1)
; PPC32: stw [[REG]], 0(3)
; PPC32: lwz 0, [[RETADDR]](1)
; PPC64: foo
; PPC64: mflr 0
-; PPC64: std 0, [[RETADDR:[0-9]+]]
-; PPC64: stdu 1, -[[STACK:[0-9]+]]
+; PPC64: stdu 1, -[[#%d,STACK:]]
+; PPC64: std 0, [[#%d,RETADDR:]]
; PPC64: ld [[REG:[0-9]+]]
; PPC64: std [[REG]], 0(3)
-; PPC64: addi 1, 1, [[STACK]]
-; PPC64: ld 0, [[RETADDR]]
+; PPC64: addi 1, 1, [[#%d,STACK]]
+; PPC64: ld 0, [[#%d,RETADDR-STACK]]
; PPC64: mtlr 0
; PPC64: blr
; CHECK-LABEL: @test1
; CHECK: mflr {{[0-9]+}}
-; CHECK: std 0, 16(1)
+; CHECK: std 0, 64(1)
; CHECK-DAG: ld 3, 64(1)
; CHECK-DAG: ld [[SR:[0-9]+]], 16(1)
; CHECK: mtlr [[SR]]
; CHECK-64B-LE-LABEL: test0:
; CHECK-64B-LE: # %bb.0: # %entry
; CHECK-64B-LE-NEXT: mflr 0
-; CHECK-64B-LE-NEXT: std 0, 16(1)
; CHECK-64B-LE-NEXT: stdu 1, -32(1)
+; CHECK-64B-LE-NEXT: std 0, 48(1)
; CHECK-64B-LE-NEXT: ld 3, 48(1)
; CHECK-64B-LE-NEXT: addi 1, 1, 32
; CHECK-64B-LE-NEXT: ld 0, 16(1)
; CHECK-64B-BE-LABEL: test0:
; CHECK-64B-BE: # %bb.0: # %entry
; CHECK-64B-BE-NEXT: mflr 0
-; CHECK-64B-BE-NEXT: std 0, 16(1)
; CHECK-64B-BE-NEXT: stdu 1, -48(1)
+; CHECK-64B-BE-NEXT: std 0, 64(1)
; CHECK-64B-BE-NEXT: ld 3, 64(1)
; CHECK-64B-BE-NEXT: addi 1, 1, 48
; CHECK-64B-BE-NEXT: ld 0, 16(1)
; CHECK-32B-BE-LABEL: test0:
; CHECK-32B-BE: # %bb.0: # %entry
; CHECK-32B-BE-NEXT: mflr 0
-; CHECK-32B-BE-NEXT: stw 0, 8(1)
; CHECK-32B-BE-NEXT: stwu 1, -32(1)
+; CHECK-32B-BE-NEXT: stw 0, 40(1)
; CHECK-32B-BE-NEXT: lwz 3, 40(1)
; CHECK-32B-BE-NEXT: addi 1, 1, 32
; CHECK-32B-BE-NEXT: lwz 0, 8(1)
; CHECK-64B-LE-LABEL: test1:
; CHECK-64B-LE: # %bb.0: # %entry
; CHECK-64B-LE-NEXT: mflr 0
-; CHECK-64B-LE-NEXT: std 0, 16(1)
; CHECK-64B-LE-NEXT: stdu 1, -32(1)
+; CHECK-64B-LE-NEXT: std 0, 48(1)
; CHECK-64B-LE-NEXT: ld 3, 0(1)
; CHECK-64B-LE-NEXT: ld 3, 0(3)
; CHECK-64B-LE-NEXT: ld 3, 16(3)
; CHECK-64B-BE-LABEL: test1:
; CHECK-64B-BE: # %bb.0: # %entry
; CHECK-64B-BE-NEXT: mflr 0
-; CHECK-64B-BE-NEXT: std 0, 16(1)
; CHECK-64B-BE-NEXT: stdu 1, -48(1)
+; CHECK-64B-BE-NEXT: std 0, 64(1)
; CHECK-64B-BE-NEXT: ld 3, 0(1)
; CHECK-64B-BE-NEXT: ld 3, 0(3)
; CHECK-64B-BE-NEXT: ld 3, 16(3)
; CHECK-32B-BE-LABEL: test1:
; CHECK-32B-BE: # %bb.0: # %entry
; CHECK-32B-BE-NEXT: mflr 0
-; CHECK-32B-BE-NEXT: stw 0, 8(1)
; CHECK-32B-BE-NEXT: stwu 1, -32(1)
+; CHECK-32B-BE-NEXT: stw 0, 40(1)
; CHECK-32B-BE-NEXT: lwz 3, 0(1)
; CHECK-32B-BE-NEXT: lwz 3, 0(3)
; CHECK-32B-BE-NEXT: lwz 3, 8(3)
; CHECK-64B-LE-LABEL: test2:
; CHECK-64B-LE: # %bb.0: # %entry
; CHECK-64B-LE-NEXT: mflr 0
-; CHECK-64B-LE-NEXT: std 0, 16(1)
; CHECK-64B-LE-NEXT: stdu 1, -32(1)
+; CHECK-64B-LE-NEXT: std 0, 48(1)
; CHECK-64B-LE-NEXT: ld 3, 0(1)
; CHECK-64B-LE-NEXT: ld 3, 0(3)
; CHECK-64B-LE-NEXT: ld 3, 0(3)
; CHECK-64B-BE-LABEL: test2:
; CHECK-64B-BE: # %bb.0: # %entry
; CHECK-64B-BE-NEXT: mflr 0
-; CHECK-64B-BE-NEXT: std 0, 16(1)
; CHECK-64B-BE-NEXT: stdu 1, -48(1)
+; CHECK-64B-BE-NEXT: std 0, 64(1)
; CHECK-64B-BE-NEXT: ld 3, 0(1)
; CHECK-64B-BE-NEXT: ld 3, 0(3)
; CHECK-64B-BE-NEXT: ld 3, 0(3)
; CHECK-32B-BE-LABEL: test2:
; CHECK-32B-BE: # %bb.0: # %entry
; CHECK-32B-BE-NEXT: mflr 0
-; CHECK-32B-BE-NEXT: stw 0, 8(1)
; CHECK-32B-BE-NEXT: stwu 1, -32(1)
+; CHECK-32B-BE-NEXT: stw 0, 40(1)
; CHECK-32B-BE-NEXT: lwz 3, 0(1)
; CHECK-32B-BE-NEXT: lwz 3, 0(3)
; CHECK-32B-BE-NEXT: lwz 3, 0(3)
; BE-LABEL: test_lrint:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: .cfi_def_cfa_offset 112
; BE-NEXT: .cfi_offset lr, 16
; BE-NEXT: bl lrint
; CHECK-LABEL: test_lrint:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl lrint
; BE-LABEL: test_lrintf:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: .cfi_def_cfa_offset 112
; BE-NEXT: .cfi_offset lr, 16
; BE-NEXT: bl lrintf
; CHECK-LABEL: test_lrintf:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl lrintf
; BE-LABEL: test_llrint:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: .cfi_def_cfa_offset 112
; BE-NEXT: .cfi_offset lr, 16
; BE-NEXT: bl llrint
; CHECK-LABEL: test_llrint:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl llrint
; BE-LABEL: test_llrintf:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: .cfi_def_cfa_offset 112
; BE-NEXT: .cfi_offset lr, 16
; BE-NEXT: bl llrintf
; CHECK-LABEL: test_llrintf:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl llrintf
; BE-LABEL: test_lround:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: .cfi_def_cfa_offset 112
; BE-NEXT: .cfi_offset lr, 16
; BE-NEXT: bl lround
; CHECK-LABEL: test_lround:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl lround
; BE-LABEL: test_lroundf:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: .cfi_def_cfa_offset 112
; BE-NEXT: .cfi_offset lr, 16
; BE-NEXT: bl lroundf
; CHECK-LABEL: test_lroundf:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl lroundf
; BE-LABEL: test_llround:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: .cfi_def_cfa_offset 112
; BE-NEXT: .cfi_offset lr, 16
; BE-NEXT: bl llround
; CHECK-LABEL: test_llround:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl llround
; BE-LABEL: test_llroundf:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: .cfi_def_cfa_offset 112
; BE-NEXT: .cfi_offset lr, 16
; BE-NEXT: bl llroundf
; CHECK-LABEL: test_llroundf:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl llroundf
; BE-LABEL: test_nearbyint:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: .cfi_def_cfa_offset 112
; BE-NEXT: .cfi_offset lr, 16
; BE-NEXT: bl nearbyint
; CHECK-LABEL: test_nearbyint:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl nearbyint
; BE-LABEL: test_nearbyintf:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: .cfi_def_cfa_offset 112
; BE-NEXT: .cfi_offset lr, 16
; BE-NEXT: bl nearbyintf
; CHECK-LABEL: test_nearbyintf:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -32(r1)
+; CHECK-NEXT: std r0, 48(r1)
; CHECK-NEXT: .cfi_def_cfa_offset 32
; CHECK-NEXT: .cfi_offset lr, 16
; CHECK-NEXT: bl nearbyintf
; CHECK-LABEL: print_res:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -128(1)
+; CHECK-NEXT: std 0, 144(1)
; CHECK-NEXT: lwz 3, 0(3)
; CHECK-NEXT: addi 3, 3, -1
; CHECK-NEXT: clrldi 4, 3, 32
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
; CHECK-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -48(1)
+; CHECK-NEXT: std 0, 64(1)
; CHECK-NEXT: bl strtol
; CHECK-NEXT: nop
; CHECK-NEXT: mr 30, 3
; CHECK-NEXT: mflr 0
; CHECK-NEXT: std 29, -24(1) # 8-byte Folded Spill
; CHECK-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stdu 1, -64(1)
+; CHECK-NEXT: std 0, 80(1)
; CHECK-NEXT: mr 30, 3
; CHECK-NEXT: bl malloc
; CHECK-NEXT: nop
; CHECK-NEXT: lwzu 8, 4(7)
; CHECK-NEXT: bdz .LBB0_4
; CHECK-NEXT: .p2align 5
-; CHECK-NEXT: .LBB0_3: #
+; CHECK-NEXT: .LBB0_3:
; CHECK-NEXT: add 9, 3, 6
; CHECK-NEXT: extswsli 6, 5, 5
; CHECK-NEXT: add 5, 8, 5
; EFPU2-LABEL: test_dtos:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __truncdfsf2
; EFPU2-NEXT: lwz 0, 20(1)
; EFPU2-NEXT: addi 1, 1, 16
; EFPU2-LABEL: test_ddiv:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __divdf3
; EFPU2-NEXT: lwz 0, 20(1)
; EFPU2-NEXT: addi 1, 1, 16
; EFPU2-LABEL: test_dmul:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __muldf3
; EFPU2-NEXT: lwz 0, 20(1)
; EFPU2-NEXT: addi 1, 1, 16
; EFPU2-LABEL: test_dadd:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __adddf3
; EFPU2-NEXT: lwz 0, 20(1)
; EFPU2-NEXT: addi 1, 1, 16
; EFPU2-LABEL: test_dsub:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __subdf3
; EFPU2-NEXT: lwz 0, 20(1)
; EFPU2-NEXT: addi 1, 1, 16
; EFPU2-LABEL: test_stod:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __extendsfdf2
; EFPU2-NEXT: lwz 0, 20(1)
; EFPU2-NEXT: addi 1, 1, 16
; EFPU2-LABEL: test_dcmpuno:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __unorddf2
; EFPU2-NEXT: cntlzw 3, 3
; EFPU2-NEXT: not 3, 3
; EFPU2-LABEL: test_dcmpord:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __unorddf2
; EFPU2-NEXT: cntlzw 3, 3
; EFPU2-NEXT: rlwinm 3, 3, 27, 31, 31
; EFPU2-LABEL: test_dcmpgt:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __gtdf2
; EFPU2-NEXT: cmpwi 3, 0
; EFPU2-NEXT: ble 0, .LBB37_2
; EFPU2-LABEL: test_dcmpugt:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __ledf2
; EFPU2-NEXT: cmpwi 3, 0
; EFPU2-NEXT: ble 0, .LBB38_2
; EFPU2-LABEL: test_dcmple:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __gtdf2
; EFPU2-NEXT: cmpwi 3, 0
; EFPU2-NEXT: bgt 0, .LBB39_2
; EFPU2-LABEL: test_dcmpule:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __gtdf2
; EFPU2-NEXT: cmpwi 3, 0
; EFPU2-NEXT: bgt 0, .LBB40_2
; EFPU2-LABEL: test_dcmpeq:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __nedf2
; EFPU2-NEXT: cmplwi 3, 0
; EFPU2-NEXT: bne 0, .LBB41_2
; EFPU2-LABEL: test_dcmpueq:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -80(1)
; EFPU2-NEXT: mfcr 12
+; EFPU2-NEXT: stw 0, 84(1)
; EFPU2-NEXT: stw 12, 76(1)
; EFPU2-NEXT: evstdd 27, 24(1) # 8-byte Folded Spill
; EFPU2-NEXT: mr 27, 3
; EFPU2-LABEL: test_dcmpne:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -80(1)
; EFPU2-NEXT: mfcr 12
+; EFPU2-NEXT: stw 0, 84(1)
; EFPU2-NEXT: stw 12, 76(1)
; EFPU2-NEXT: evstdd 27, 24(1) # 8-byte Folded Spill
; EFPU2-NEXT: mr 27, 3
; EFPU2-LABEL: test_dcmpune:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __eqdf2
; EFPU2-NEXT: cmplwi 3, 0
; EFPU2-NEXT: beq 0, .LBB44_2
; EFPU2-LABEL: test_dcmplt:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __ltdf2
; EFPU2-NEXT: cmpwi 3, 0
; EFPU2-NEXT: bge 0, .LBB45_2
; EFPU2-LABEL: test_dcmpult:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __gedf2
; EFPU2-NEXT: cmpwi 3, 0
; EFPU2-NEXT: bge 0, .LBB46_2
; EFPU2-LABEL: test_dcmpge:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __gedf2
; EFPU2-NEXT: not 3, 3
; EFPU2-NEXT: srwi 3, 3, 31
; EFPU2-LABEL: test_dcmpuge:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __ltdf2
; EFPU2-NEXT: cmpwi 3, 0
; EFPU2-NEXT: blt 0, .LBB48_2
; EFPU2-LABEL: test_dtoui:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __fixunsdfsi
; EFPU2-NEXT: lwz 0, 20(1)
; EFPU2-NEXT: addi 1, 1, 16
; EFPU2-LABEL: test_dtosi:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __fixdfsi
; EFPU2-NEXT: lwz 0, 20(1)
; EFPU2-NEXT: addi 1, 1, 16
; EFPU2-LABEL: test_dfromui:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __floatunsidf
; EFPU2-NEXT: lwz 0, 20(1)
; EFPU2-NEXT: addi 1, 1, 16
; EFPU2-LABEL: test_dfromsi:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -16(1)
+; EFPU2-NEXT: stw 0, 20(1)
; EFPU2-NEXT: bl __floatsidf
; EFPU2-NEXT: lwz 0, 20(1)
; EFPU2-NEXT: addi 1, 1, 16
; SPE-LABEL: test_spill:
; SPE: # %bb.0: # %entry
; SPE-NEXT: mflr 0
-; SPE-NEXT: stw 0, 4(1)
; SPE-NEXT: stwu 1, -288(1)
; SPE-NEXT: li 5, 256
-; SPE-NEXT: evstddx 30, 1, 5 # 8-byte Folded Spill
-; SPE-NEXT: li 5, .LCPI55_0@
+; SPE-NEXT: stw 0, 292(1)
; SPE-NEXT: lis 6, .LCPI55_0@ha
+; SPE-NEXT: evstddx 30, 1, 5 # 8-byte Folded Spill
+; SPE-NEXT: li 5, .LCPI55_0@l
; SPE-NEXT: evlddx 5, 6, 5
-; SPE-NEXT: stw 31, 284(1) # 4-byte Folded Spill
+; SPE-NEXT: stw 31, 284(1) # 4-byte Folded Spill
; SPE-NEXT: evstdd 14, 128(1) # 8-byte Folded Spill
; SPE-NEXT: evstdd 15, 136(1) # 8-byte Folded Spill
; SPE-NEXT: evstdd 16, 144(1) # 8-byte Folded Spill
; SPE-NEXT: evldd 16, 144(1) # 8-byte Folded Reload
; SPE-NEXT: evldd 15, 136(1) # 8-byte Folded Reload
; SPE-NEXT: evldd 14, 128(1) # 8-byte Folded Reload
-; SPE-NEXT: lwz 31, 284(1) # 4-byte Folded Reload
+; SPE-NEXT: lwz 31, 284(1) # 4-byte Folded Reload
; SPE-NEXT: lwz 0, 292(1)
; SPE-NEXT: addi 1, 1, 288
; SPE-NEXT: mtlr 0
; EFPU2-LABEL: test_spill:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -144(1)
; EFPU2-NEXT: mr 5, 3
; EFPU2-NEXT: mr 6, 4
+; EFPU2-NEXT: stw 0, 148(1)
; EFPU2-NEXT: evstdd 27, 104(1) # 8-byte Folded Spill
; EFPU2-NEXT: evstdd 28, 112(1) # 8-byte Folded Spill
; EFPU2-NEXT: evstdd 29, 120(1) # 8-byte Folded Spill
; CHECK-LABEL: test_fma:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -32(1)
; CHECK-NEXT: cmpwi 3, 0
+; CHECK-NEXT: stw 0, 36(1)
; CHECK-NEXT: evstdd 29, 8(1) # 8-byte Folded Spill
; CHECK-NEXT: evstdd 30, 16(1) # 8-byte Folded Spill
; CHECK-NEXT: ble 0, .LBB56_3
; SPE-LABEL: d:
; SPE: # %bb.0: # %entry
; SPE-NEXT: mflr 0
-; SPE-NEXT: stw 0, 4(1)
; SPE-NEXT: stwu 1, -48(1)
+; SPE-NEXT: stw 0, 52(1)
; SPE-NEXT: lwz 4, 0(4)
; SPE-NEXT: lwz 3, 0(3)
; SPE-NEXT: evstdd 29, 24(1) # 8-byte Folded Spill
; EFPU2-LABEL: d:
; EFPU2: # %bb.0: # %entry
; EFPU2-NEXT: mflr 0
-; EFPU2-NEXT: stw 0, 4(1)
; EFPU2-NEXT: stwu 1, -64(1)
+; EFPU2-NEXT: stw 0, 68(1)
; EFPU2-NEXT: lwz 3, 0(3)
; EFPU2-NEXT: evstdd 26, 16(1) # 8-byte Folded Spill
; EFPU2-NEXT: evstdd 27, 24(1) # 8-byte Folded Spill
; CHECK-LABEL: dont_fold_srem_i64:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -16(1)
+; CHECK-NEXT: stw 0, 20(1)
; CHECK-NEXT: .cfi_def_cfa_offset 16
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: li 5, 0
; PPC-LABEL: test_srem_vec:
; PPC: # %bb.0:
; PPC-NEXT: mflr 0
-; PPC-NEXT: stw 0, 4(1)
; PPC-NEXT: stwu 1, -48(1)
+; PPC-NEXT: stw 0, 52(1)
+; PPC-NEXT: clrlwi 5, 5, 31
; PPC-NEXT: stw 29, 36(1) # 4-byte Folded Spill
; PPC-NEXT: mr 29, 6
-; PPC-NEXT: clrlwi 5, 5, 31
; PPC-NEXT: clrlwi 6, 7, 31
; PPC-NEXT: clrlwi 3, 3, 31
; PPC-NEXT: stw 27, 28(1) # 4-byte Folded Spill
; CHECK-NEXT: mfocrf 12, 32
; CHECK-NEXT: mflr 0
; CHECK-NEXT: std 31, -8(1)
-; CHECK-NEXT: std 0, 16(1)
; CHECK-NEXT: stw 12, 8(1)
; CHECK-NEXT: stdu 1, -784(1)
; CHECK-NEXT: # kill: def $r3 killed $r3 killed $x3
; CHECK-NEXT: cmpwi 2, 3, 2
+; CHECK-NEXT: std 0, 800(1)
; CHECK-NEXT: mr 31, 1
; CHECK-NEXT: li 3, 0
; CHECK-NEXT: blt 2, .LBB0_3
;
; BE-LABEL: main:
; BE: # %bb.0: # %entry
+; BE-NEXT: mfcr 12
; BE-NEXT: mflr 0
; BE-NEXT: std 31, -8(1)
-; BE-NEXT: std 0, 16(1)
-; BE-NEXT: mfcr 12
; BE-NEXT: stw 12, 8(1)
; BE-NEXT: stdu 1, -800(1)
; BE-NEXT: li 4, 0
; BE-NEXT: # kill: def $r3 killed $r3 killed $x3
; BE-NEXT: cmpwi 2, 3, 2
; BE-NEXT: mr 3, 4
+; BE-NEXT: std 0, 816(1)
; BE-NEXT: mr 31, 1
; BE-NEXT: blt 2, .LBB0_3
; BE-NEXT: # %bb.1: # %if.end
; CHECK-PWR8-NEXT: .cfi_offset lr, 16
; CHECK-PWR8-NEXT: .cfi_offset r30, -16
; CHECK-PWR8-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-PWR8-NEXT: std 0, 16(1)
; CHECK-PWR8-NEXT: stdu 1, -48(1)
-; CHECK-PWR8-NEXT: lxvd2x 0, 0, 3
+; CHECK-PWR8-NEXT: std 0, 64(1)
; CHECK-PWR8-NEXT: mr 30, 4
+; CHECK-PWR8-NEXT: lxvd2x 0, 0, 3
; CHECK-PWR8-NEXT: xxswapd 2, 0
; CHECK-PWR8-NEXT: bl __fixkfdi
; CHECK-PWR8-NEXT: nop
; CHECK-PWR8-NEXT: .cfi_offset lr, 16
; CHECK-PWR8-NEXT: .cfi_offset r30, -16
; CHECK-PWR8-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-PWR8-NEXT: std 0, 16(1)
; CHECK-PWR8-NEXT: stdu 1, -48(1)
-; CHECK-PWR8-NEXT: lxvd2x 0, 0, 3
+; CHECK-PWR8-NEXT: std 0, 64(1)
; CHECK-PWR8-NEXT: mr 30, 4
+; CHECK-PWR8-NEXT: lxvd2x 0, 0, 3
; CHECK-PWR8-NEXT: xxswapd 2, 0
; CHECK-PWR8-NEXT: bl __fixkfsi
; CHECK-PWR8-NEXT: nop
; CHECK-PWR8-NEXT: .cfi_offset lr, 16
; CHECK-PWR8-NEXT: .cfi_offset r30, -16
; CHECK-PWR8-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-PWR8-NEXT: std 0, 16(1)
; CHECK-PWR8-NEXT: stdu 1, -48(1)
-; CHECK-PWR8-NEXT: lxvd2x 0, 0, 3
+; CHECK-PWR8-NEXT: std 0, 64(1)
; CHECK-PWR8-NEXT: mr 30, 4
+; CHECK-PWR8-NEXT: lxvd2x 0, 0, 3
; CHECK-PWR8-NEXT: xxswapd 2, 0
; CHECK-PWR8-NEXT: bl __fixunskfdi
; CHECK-PWR8-NEXT: nop
; CHECK-PWR8-NEXT: .cfi_offset lr, 16
; CHECK-PWR8-NEXT: .cfi_offset r30, -16
; CHECK-PWR8-NEXT: std 30, -16(1) # 8-byte Folded Spill
-; CHECK-PWR8-NEXT: std 0, 16(1)
; CHECK-PWR8-NEXT: stdu 1, -48(1)
-; CHECK-PWR8-NEXT: lxvd2x 0, 0, 3
+; CHECK-PWR8-NEXT: std 0, 64(1)
; CHECK-PWR8-NEXT: mr 30, 4
+; CHECK-PWR8-NEXT: lxvd2x 0, 0, 3
; CHECK-PWR8-NEXT: xxswapd 2, 0
; CHECK-PWR8-NEXT: bl __fixunskfsi
; CHECK-PWR8-NEXT: nop
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
; RUN: -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr < %s | FileCheck %s
; Callee should be tail called in this function since it is at a tail call position.
define dso_local double @speculatable_callee_return_use_only (ptr nocapture %res, double %a) #0 {
; CHECK-LABEL: speculatable_callee_return_use_only:
-; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: b callee
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: b callee
+; CHECK-NEXT: #TC_RETURNd8 callee 0
entry:
%value = tail call double @callee(double %a) #2
ret double %value
; Callee should not be tail called since it is not at a tail call position.
define dso_local void @speculatable_callee_non_return_use_only (ptr nocapture %res, double %a) #0 {
; CHECK-LABEL: speculatable_callee_non_return_use_only:
-; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: mflr r0
-; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
-; CHECK-NEXT: stdu r1, -48(r1)
-; CHECK-NEXT: mr r30, r3
-; CHECK-NEXT: bl callee
-; CHECK-NEXT: stfd f1, 0(r30)
-; CHECK-NEXT: addi r1, r1, 48
-; CHECK-NEXT: ld r0, 16(r1)
-; CHECK-NEXT: ld r30, -16(r1) # 8-byte Folded Reload
-; CHECK-NEXT: mtlr r0
-; CHECK-NEXT: blr
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: mflr r0
+; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
+; CHECK-NEXT: stdu r1, -48(r1)
+; CHECK-NEXT: std r0, 64(r1)
+; CHECK-NEXT: mr r30, r3
+; CHECK-NEXT: bl callee
+; CHECK-NEXT: stfd f1, 0(r30)
+; CHECK-NEXT: addi r1, r1, 48
+; CHECK-NEXT: ld r0, 16(r1)
+; CHECK-NEXT: ld r30, -16(r1) # 8-byte Folded Reload
+; CHECK-NEXT: mtlr r0
+; CHECK-NEXT: blr
entry:
%call = tail call double @callee(double %a) #2
store double %call, ptr %res, align 8
; Callee should not be tail called since it is not at a tail call position.
define dso_local double @speculatable_callee_multi_use (ptr nocapture %res, double %a) #0 {
- ; CHECK-LABEL: speculatable_callee_multi_use:
- ; CHECK: # %bb.0: # %entry
- ; CHECK-NEXT: mflr r0
- ; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
- ; CHECK-NEXT: std r0, 16(r1)
- ; CHECK-NEXT: stdu r1, -48(r1)
- ; CHECK-NEXT: mr r30, r3
- ; CHECK-NEXT: bl callee
- ; CHECK-NEXT: stfd f1, 0(r30)
- ; CHECK-NEXT: addi r1, r1, 48
- ; CHECK-NEXT: ld r0, 16(r1)
- ; CHECK-NEXT: ld r30, -16(r1) # 8-byte Folded Reload
- ; CHECK-NEXT: mtlr r0
- ; CHECK-NEXT: blr
+; CHECK-LABEL: speculatable_callee_multi_use:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: mflr r0
+; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
+; CHECK-NEXT: stdu r1, -48(r1)
+; CHECK-NEXT: std r0, 64(r1)
+; CHECK-NEXT: mr r30, r3
+; CHECK-NEXT: bl callee
+; CHECK-NEXT: stfd f1, 0(r30)
+; CHECK-NEXT: addi r1, r1, 48
+; CHECK-NEXT: ld r0, 16(r1)
+; CHECK-NEXT: ld r30, -16(r1) # 8-byte Folded Reload
+; CHECK-NEXT: mtlr r0
+; CHECK-NEXT: blr
entry:
%call = tail call double @callee(double %a) #2
store double %call, ptr %res, align 8
; Callee should not be tail called since it is not at a tail call position.
; FIXME: A speculatable callee can be tail called if it is moved into a valid tail call position.
define dso_local double @speculatable_callee_intermediate_instructions (ptr nocapture %res, double %a) #0 {
- ; CHECK-LABEL: speculatable_callee_intermediate_instructions:
- ; CHECK: # %bb.0: # %entry
- ; CHECK-NEXT: mflr r0
- ; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
- ; CHECK-NEXT: std r0, 16(r1)
- ; CHECK-NEXT: stdu r1, -48(r1)
- ; CHECK-NEXT: mr r30, r3
- ; CHECK-NEXT: bl callee
- ; CHECK-NEXT: lis r3, 4101
- ; CHECK-NEXT: ori r3, r3, 13107
- ; CHECK-NEXT: rldic r3, r3, 34, 1
- ; CHECK-NEXT: oris r3, r3, 52428
- ; CHECK-NEXT: ori r3, r3, 52429
- ; CHECK-NEXT: std r3, 0(r30)
- ; CHECK-NEXT: addi r1, r1, 48
- ; CHECK-NEXT: ld r0, 16(r1)
- ; CHECK-NEXT: ld r30, -16(r1) # 8-byte Folded Reload
- ; CHECK-NEXT: mtlr r0
- ; CHECK-NEXT: blr
+; CHECK-LABEL: speculatable_callee_intermediate_instructions:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: mflr r0
+; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
+; CHECK-NEXT: stdu r1, -48(r1)
+; CHECK-NEXT: std r0, 64(r1)
+; CHECK-NEXT: mr r30, r3
+; CHECK-NEXT: bl callee
+; CHECK-NEXT: lis r3, 4101
+; CHECK-NEXT: ori r3, r3, 13107
+; CHECK-NEXT: rldic r3, r3, 34, 1
+; CHECK-NEXT: oris r3, r3, 52428
+; CHECK-NEXT: ori r3, r3, 52429
+; CHECK-NEXT: std r3, 0(r30)
+; CHECK-NEXT: addi r1, r1, 48
+; CHECK-NEXT: ld r0, 16(r1)
+; CHECK-NEXT: ld r30, -16(r1) # 8-byte Folded Reload
+; CHECK-NEXT: mtlr r0
+; CHECK-NEXT: blr
entry:
%call = tail call double @callee(double %a) #2
define dso_local double @callee(double) #1 {
+; CHECK-LABEL: callee:
+; CHECK: # %bb.0:
+; CHECK-NEXT: addis r3, r2, .LCPI4_0@toc@ha
+; CHECK-NEXT: lfs f1, .LCPI4_0@toc@l(r3)
+; CHECK-NEXT: blr
ret double 4.5
}
; BE-LABEL: testCompare1:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: addis r4, r2, testCompare1@toc@ha
-; BE-NEXT: lbz r3, 0(r3)
; BE-NEXT: lbz r4, testCompare1@toc@l(r4)
-; BE-NEXT: clrlwi r3, r3, 31
+; BE-NEXT: lbz r3, 0(r3)
; BE-NEXT: clrlwi r4, r4, 31
-; BE-NEXT: clrldi r3, r3, 32
+; BE-NEXT: clrlwi r3, r3, 31
; BE-NEXT: clrldi r4, r4, 32
+; BE-NEXT: clrldi r3, r3, 32
; BE-NEXT: sub r3, r3, r4
; BE-NEXT: rldicl r3, r3, 1, 63
; BE-NEXT: bl fn2
; LE-LABEL: testCompare1:
; LE: # %bb.0: # %entry
; LE-NEXT: mflr r0
-; LE-NEXT: std r0, 16(r1)
; LE-NEXT: stdu r1, -32(r1)
+; LE-NEXT: std r0, 48(r1)
; LE-NEXT: addis r4, r2, testCompare1@toc@ha
-; LE-NEXT: lbz r3, 0(r3)
; LE-NEXT: lbz r4, testCompare1@toc@l(r4)
-; LE-NEXT: clrlwi r3, r3, 31
+; LE-NEXT: lbz r3, 0(r3)
; LE-NEXT: clrlwi r4, r4, 31
-; LE-NEXT: clrldi r3, r3, 32
+; LE-NEXT: clrlwi r3, r3, 31
; LE-NEXT: clrldi r4, r4, 32
+; LE-NEXT: clrldi r3, r3, 32
; LE-NEXT: sub r3, r3, r4
; LE-NEXT: rldicl r3, r3, 1, 63
; LE-NEXT: bl fn2
; BE-LABEL: testCompare1:
; BE: # %bb.0: # %entry
; BE-NEXT: mflr r0
-; BE-NEXT: std r0, 16(r1)
; BE-NEXT: stdu r1, -112(r1)
+; BE-NEXT: std r0, 128(r1)
; BE-NEXT: addis r4, r2, testCompare1@toc@ha
-; BE-NEXT: lbz r3, 0(r3)
; BE-NEXT: lbz r4, testCompare1@toc@l(r4)
-; BE-NEXT: clrlwi r3, r3, 31
+; BE-NEXT: lbz r3, 0(r3)
; BE-NEXT: clrlwi r4, r4, 31
-; BE-NEXT: clrldi r3, r3, 32
+; BE-NEXT: clrlwi r3, r3, 31
; BE-NEXT: clrldi r4, r4, 32
+; BE-NEXT: clrldi r3, r3, 32
; BE-NEXT: sub r3, r4, r3
; BE-NEXT: rldicl r3, r3, 1, 63
; BE-NEXT: bl fn2
; LE-LABEL: testCompare1:
; LE: # %bb.0: # %entry
; LE-NEXT: mflr r0
-; LE-NEXT: std r0, 16(r1)
; LE-NEXT: stdu r1, -32(r1)
+; LE-NEXT: std r0, 48(r1)
; LE-NEXT: addis r4, r2, testCompare1@toc@ha
-; LE-NEXT: lbz r3, 0(r3)
; LE-NEXT: lbz r4, testCompare1@toc@l(r4)
-; LE-NEXT: clrlwi r3, r3, 31
+; LE-NEXT: lbz r3, 0(r3)
; LE-NEXT: clrlwi r4, r4, 31
-; LE-NEXT: clrldi r3, r3, 32
+; LE-NEXT: clrlwi r3, r3, 31
; LE-NEXT: clrldi r4, r4, 32
+; LE-NEXT: clrldi r3, r3, 32
; LE-NEXT: sub r3, r4, r3
; LE-NEXT: rldicl r3, r3, 1, 63
; LE-NEXT: bl fn2
; CHECK-NEXT: std r28, -32(r1) # 8-byte Folded Spill
; CHECK-NEXT: std r29, -24(r1) # 8-byte Folded Spill
; CHECK-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-NEXT: std r0, 16(r1)
; CHECK-NEXT: stdu r1, -64(r1)
; CHECK-NEXT: mr r29, r5
; CHECK-NEXT: mr r30, r4
; CHECK-NEXT: mr r28, r3
; CHECK-NEXT: std r2, 24(r1)
+; CHECK-NEXT: std r0, 80(r1)
; CHECK-NEXT: cmpwi r29, 1
; CHECK-NEXT: bc 12, lt, .LBB0_3
; CHECK-NEXT: # %bb.1: # %entry
; CHECK-LABEL: dont_fold_urem_i64:
; CHECK: # %bb.0:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 4(1)
; CHECK-NEXT: stwu 1, -16(1)
+; CHECK-NEXT: stw 0, 20(1)
; CHECK-NEXT: .cfi_def_cfa_offset 16
; CHECK-NEXT: .cfi_offset lr, 4
; CHECK-NEXT: li 5, 0
; PC64LE-LABEL: constrained_vector_frem_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl fmodf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_frem_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl fmodf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_frem_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_frem_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 64(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 3
; PC64LE-LABEL: constrained_vector_frem_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: xxsldwi 2, 35, 35, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
+; PC64LE-NEXT: vmr 30, 2
; PC64LE-NEXT: stfd 30, 80(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: xscvspdpn 1, 0
+; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
; PC64LE-NEXT: xscvspdpn 2, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: vmr 31, 3
-; PC64LE-NEXT: vmr 30, 2
; PC64LE-NEXT: bl fmodf
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxswapd 0, 62
; PC64LE9-LABEL: constrained_vector_frem_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 62, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
+; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: xxsldwi 0, 35, 35, 1
-; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 2, 0
; PC64LE9-NEXT: vmr 31, 3
; PC64LE9-NEXT: vmr 30, 2
+; PC64LE9-NEXT: xscvspdpn 2, 0
; PC64LE9-NEXT: bl fmodf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 62
; PC64LE-LABEL: constrained_vector_frem_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stfd 28, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: fmr 28, 2
; PC64LE-NEXT: li 3, 48
; PC64LE-NEXT: fmr 2, 4
; PC64LE-NEXT: stfd 29, 72(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 30, 80(1) # 8-byte Folded Spill
+; PC64LE-NEXT: fmr 30, 5
; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 31, 6
-; PC64LE-NEXT: fmr 30, 5
; PC64LE-NEXT: fmr 29, 3
; PC64LE-NEXT: bl fmod
; PC64LE-NEXT: nop
; PC64LE9-LABEL: constrained_vector_frem_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stfd 28, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: fmr 28, 2
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: fmr 28, 2
; PC64LE9-NEXT: fmr 2, 4
; PC64LE9-NEXT: stfd 29, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE-LABEL: constrained_vector_frem_v4f64:
; PC64LE: # %bb.0:
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -128(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 144(1)
; PC64LE-NEXT: stxvd2x 59, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 60, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_frem_v4f64:
; PC64LE9: # %bb.0:
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -112(1)
+; PC64LE9-NEXT: std 0, 128(1)
; PC64LE9-NEXT: stxv 60, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: stxv 62, 80(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 4
; PC64LE-LABEL: constrained_vector_pow_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl powf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_pow_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl powf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_pow_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_pow_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 64(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 3
; PC64LE-LABEL: constrained_vector_pow_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: xxsldwi 2, 35, 35, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
+; PC64LE-NEXT: vmr 30, 2
; PC64LE-NEXT: stfd 30, 80(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: xscvspdpn 1, 0
+; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
; PC64LE-NEXT: xscvspdpn 2, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: vmr 31, 3
-; PC64LE-NEXT: vmr 30, 2
; PC64LE-NEXT: bl powf
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxswapd 0, 62
; PC64LE9-LABEL: constrained_vector_pow_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 62, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
+; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: xxsldwi 0, 35, 35, 1
-; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 2, 0
; PC64LE9-NEXT: vmr 31, 3
; PC64LE9-NEXT: vmr 30, 2
+; PC64LE9-NEXT: xscvspdpn 2, 0
; PC64LE9-NEXT: bl powf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 62
; PC64LE-LABEL: constrained_vector_pow_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stfd 28, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: fmr 28, 2
; PC64LE-NEXT: li 3, 48
; PC64LE-NEXT: fmr 2, 4
; PC64LE-NEXT: stfd 29, 72(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 30, 80(1) # 8-byte Folded Spill
+; PC64LE-NEXT: fmr 30, 5
; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 31, 6
-; PC64LE-NEXT: fmr 30, 5
; PC64LE-NEXT: fmr 29, 3
; PC64LE-NEXT: bl pow
; PC64LE-NEXT: nop
; PC64LE9-LABEL: constrained_vector_pow_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stfd 28, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: fmr 28, 2
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: fmr 28, 2
; PC64LE9-NEXT: fmr 2, 4
; PC64LE9-NEXT: stfd 29, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE-LABEL: constrained_vector_pow_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -128(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 144(1)
; PC64LE-NEXT: stxvd2x 59, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 60, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_pow_v4f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -112(1)
+; PC64LE9-NEXT: std 0, 128(1)
; PC64LE9-NEXT: stxv 60, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: stxv 62, 80(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 4
; PC64LE-LABEL: constrained_vector_powi_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
; PC64LE-NEXT: clrldi 4, 4, 32
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl __powisf2
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_powi_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
; PC64LE9-NEXT: clrldi 4, 4, 32
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl __powisf2
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_powi_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: std 30, 80(1) # 8-byte Folded Spill
; PC64LE-NEXT: clrldi 30, 5, 32
+; PC64LE-NEXT: mr 4, 30
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
-; PC64LE-NEXT: mr 4, 30
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: vmr 31, 2
; PC64LE-NEXT: xxlor 1, 63, 63
; PC64LE9-LABEL: constrained_vector_powi_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: std 30, 64(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
; PC64LE9-NEXT: clrldi 30, 5, 32
+; PC64LE9-NEXT: stxv 62, 32(1) # 16-byte Folded Spill
; PC64LE9-NEXT: xscpsgndp 1, 63, 63
; PC64LE9-NEXT: mr 4, 30
-; PC64LE9-NEXT: stxv 62, 32(1) # 16-byte Folded Spill
; PC64LE9-NEXT: bl __powidf2
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: mr 4, 30
; PC64LE-LABEL: constrained_vector_powi_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: std 30, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: clrldi 30, 5, 32
; PC64LE-NEXT: li 3, 48
-; PC64LE-NEXT: stfd 30, 80(1) # 8-byte Folded Spill
; PC64LE-NEXT: mr 4, 30
+; PC64LE-NEXT: xscvspdpn 1, 0
+; PC64LE-NEXT: stfd 30, 80(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: vmr 31, 2
-; PC64LE-NEXT: xscvspdpn 1, 0
; PC64LE-NEXT: bl __powisf2
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxswapd 0, 63
; PC64LE9-LABEL: constrained_vector_powi_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: std 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: clrldi 30, 5, 32
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
+; PC64LE9-NEXT: clrldi 30, 5, 32
; PC64LE9-NEXT: vmr 31, 2
-; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
+; PC64LE9-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE9-NEXT: mr 4, 30
+; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: bl __powisf2
; PC64LE9-NEXT: nop
; PC64LE-LABEL: constrained_vector_powi_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: std 30, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: clrldi 30, 6, 32
; PC64LE-NEXT: li 3, 48
-; PC64LE-NEXT: stfd 30, 80(1) # 8-byte Folded Spill
-; PC64LE-NEXT: fmr 30, 2
; PC64LE-NEXT: mr 4, 30
+; PC64LE-NEXT: stfd 30, 80(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
-; PC64LE-NEXT: fmr 31, 3
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
+; PC64LE-NEXT: fmr 31, 3
+; PC64LE-NEXT: fmr 30, 2
; PC64LE-NEXT: bl __powidf2
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxlor 63, 1, 1
; PC64LE9-LABEL: constrained_vector_powi_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: std 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: clrldi 30, 6, 32
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: clrldi 30, 6, 32
; PC64LE9-NEXT: mr 4, 30
; PC64LE9-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE-LABEL: constrained_vector_powi_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -112(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 128(1)
; PC64LE-NEXT: std 30, 96(1) # 8-byte Folded Spill
; PC64LE-NEXT: clrldi 30, 7, 32
+; PC64LE-NEXT: mr 4, 30
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
-; PC64LE-NEXT: mr 4, 30
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: vmr 30, 2
; PC64LE-NEXT: li 3, 80
; PC64LE9-LABEL: constrained_vector_powi_v4f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -96(1)
+; PC64LE9-NEXT: std 0, 112(1)
; PC64LE9-NEXT: std 30, 80(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 2
; PC64LE9-NEXT: clrldi 30, 7, 32
+; PC64LE9-NEXT: stxv 61, 32(1) # 16-byte Folded Spill
; PC64LE9-NEXT: xscpsgndp 1, 62, 62
; PC64LE9-NEXT: mr 4, 30
-; PC64LE9-NEXT: stxv 61, 32(1) # 16-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 64(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 3
; PC64LE9-NEXT: bl __powidf2
; PC64LE-LABEL: constrained_vector_sin_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl sinf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_sin_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl sinf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_sin_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_sin_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
; PC64LE9-NEXT: xscpsgndp 1, 63, 63
; PC64LE-LABEL: constrained_vector_sin_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_sin_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 1, 0
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
+; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: bl sinf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 63
; PC64LE-LABEL: constrained_vector_sin_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
+; PC64LE-NEXT: fmr 30, 2
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 31, 3
-; PC64LE-NEXT: fmr 30, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: bl sin
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxlor 63, 1, 1
; PC64LE9-LABEL: constrained_vector_sin_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: fmr 31, 3
; PC64LE9-NEXT: fmr 30, 2
; PC64LE9-NEXT: bl sin
; PC64LE-LABEL: constrained_vector_sin_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_sin_v4f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 2
; PC64LE9-NEXT: xscpsgndp 1, 62, 62
; PC64LE-LABEL: constrained_vector_cos_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl cosf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_cos_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl cosf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_cos_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_cos_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
; PC64LE9-NEXT: xscpsgndp 1, 63, 63
; PC64LE-LABEL: constrained_vector_cos_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_cos_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 1, 0
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
+; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: bl cosf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 63
; PC64LE-LABEL: constrained_vector_cos_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
+; PC64LE-NEXT: fmr 30, 2
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 31, 3
-; PC64LE-NEXT: fmr 30, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: bl cos
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxlor 63, 1, 1
; PC64LE9-LABEL: constrained_vector_cos_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: fmr 31, 3
; PC64LE9-NEXT: fmr 30, 2
; PC64LE9-NEXT: bl cos
; PC64LE-LABEL: constrained_vector_cos_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_cos_v4f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 2
; PC64LE9-NEXT: xscpsgndp 1, 62, 62
; PC64LE-LABEL: constrained_vector_exp_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl expf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_exp_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl expf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_exp_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_exp_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
; PC64LE9-NEXT: xscpsgndp 1, 63, 63
; PC64LE-LABEL: constrained_vector_exp_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_exp_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 1, 0
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
+; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: bl expf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 63
; PC64LE-LABEL: constrained_vector_exp_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
+; PC64LE-NEXT: fmr 30, 2
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 31, 3
-; PC64LE-NEXT: fmr 30, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: bl exp
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxlor 63, 1, 1
; PC64LE9-LABEL: constrained_vector_exp_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: fmr 31, 3
; PC64LE9-NEXT: fmr 30, 2
; PC64LE9-NEXT: bl exp
; PC64LE-LABEL: constrained_vector_exp_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_exp_v4f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 2
; PC64LE9-NEXT: xscpsgndp 1, 62, 62
; PC64LE-LABEL: constrained_vector_exp2_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl exp2f
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_exp2_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl exp2f
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_exp2_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_exp2_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
; PC64LE9-NEXT: xscpsgndp 1, 63, 63
; PC64LE-LABEL: constrained_vector_exp2_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_exp2_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 1, 0
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
+; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: bl exp2f
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 63
; PC64LE-LABEL: constrained_vector_exp2_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
+; PC64LE-NEXT: fmr 30, 2
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 31, 3
-; PC64LE-NEXT: fmr 30, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: bl exp2
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxlor 63, 1, 1
; PC64LE9-LABEL: constrained_vector_exp2_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: fmr 31, 3
; PC64LE9-NEXT: fmr 30, 2
; PC64LE9-NEXT: bl exp2
; PC64LE-LABEL: constrained_vector_exp2_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_exp2_v4f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 2
; PC64LE9-NEXT: xscpsgndp 1, 62, 62
; PC64LE-LABEL: constrained_vector_log_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl logf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_log_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl logf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_log_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_log_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
; PC64LE9-NEXT: xscpsgndp 1, 63, 63
; PC64LE-LABEL: constrained_vector_log_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_log_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 1, 0
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
+; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: bl logf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 63
; PC64LE-LABEL: constrained_vector_log_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
+; PC64LE-NEXT: fmr 30, 2
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 31, 3
-; PC64LE-NEXT: fmr 30, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: bl log
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxlor 63, 1, 1
; PC64LE9-LABEL: constrained_vector_log_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: fmr 31, 3
; PC64LE9-NEXT: fmr 30, 2
; PC64LE9-NEXT: bl log
; PC64LE-LABEL: constrained_vector_log_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_log_v4f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 2
; PC64LE9-NEXT: xscpsgndp 1, 62, 62
; PC64LE-LABEL: constrained_vector_log10_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl log10f
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_log10_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl log10f
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_log10_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_log10_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
; PC64LE9-NEXT: xscpsgndp 1, 63, 63
; PC64LE-LABEL: constrained_vector_log10_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_log10_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 1, 0
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
+; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: bl log10f
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 63
; PC64LE-LABEL: constrained_vector_log10_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
+; PC64LE-NEXT: fmr 30, 2
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 31, 3
-; PC64LE-NEXT: fmr 30, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: bl log10
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxlor 63, 1, 1
; PC64LE9-LABEL: constrained_vector_log10_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: fmr 31, 3
; PC64LE9-NEXT: fmr 30, 2
; PC64LE9-NEXT: bl log10
; PC64LE-LABEL: constrained_vector_log10_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_log10_v4f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 2
; PC64LE9-NEXT: xscpsgndp 1, 62, 62
; PC64LE-LABEL: constrained_vector_log2_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl log2f
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_log2_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl log2f
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_log2_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_log2_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
; PC64LE9-NEXT: xscpsgndp 1, 63, 63
; PC64LE-LABEL: constrained_vector_log2_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_log2_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 1, 0
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
+; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: bl log2f
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 63
; PC64LE-LABEL: constrained_vector_log2_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
+; PC64LE-NEXT: fmr 30, 2
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 31, 3
-; PC64LE-NEXT: fmr 30, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: bl log2
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxlor 63, 1, 1
; PC64LE9-LABEL: constrained_vector_log2_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: fmr 31, 3
; PC64LE9-NEXT: fmr 30, 2
; PC64LE9-NEXT: bl log2
; PC64LE-LABEL: constrained_vector_log2_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_log2_v4f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 2
; PC64LE9-NEXT: xscpsgndp 1, 62, 62
; PC64LE-LABEL: constrained_vector_nearbyint_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl nearbyintf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_nearbyint_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl nearbyintf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_nearbyint_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_nearbyint_v2f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
; PC64LE9-NEXT: xscpsgndp 1, 63, 63
; PC64LE-LABEL: constrained_vector_nearbyint_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_nearbyint_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 1, 0
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: vmr 31, 2
+; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: bl nearbyintf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 63
; PC64LE-LABEL: constrained_vector_nearby_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -80(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 96(1)
; PC64LE-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
+; PC64LE-NEXT: fmr 30, 2
; PC64LE-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 31, 3
-; PC64LE-NEXT: fmr 30, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: bl nearbyint
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxlor 63, 1, 1
; PC64LE9-LABEL: constrained_vector_nearby_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -64(1)
+; PC64LE9-NEXT: std 0, 80(1)
; PC64LE9-NEXT: stfd 30, 48(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 56(1) # 8-byte Folded Spill
; PC64LE9-NEXT: fmr 31, 3
; PC64LE9-NEXT: fmr 30, 2
; PC64LE9-NEXT: bl nearbyint
; PC64LE-LABEL: constrained_vector_nearbyint_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 61, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE9-LABEL: constrained_vector_nearbyint_v4f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stxv 62, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: vmr 30, 2
; PC64LE9-NEXT: xscpsgndp 1, 62, 62
; PC64LE-LABEL: constrained_vector_maxnum_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl fmaxf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_maxnum_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl fmaxf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_maxnum_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: xxsldwi 2, 35, 35, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
+; PC64LE-NEXT: vmr 30, 2
; PC64LE-NEXT: stfd 30, 80(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: xscvspdpn 1, 0
+; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
; PC64LE-NEXT: xscvspdpn 2, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: vmr 31, 3
-; PC64LE-NEXT: vmr 30, 2
; PC64LE-NEXT: bl fmaxf
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxswapd 0, 62
; PC64LE9-LABEL: constrained_vector_maxnum_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 62, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
+; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: xxsldwi 0, 35, 35, 1
-; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 2, 0
; PC64LE9-NEXT: vmr 31, 3
; PC64LE9-NEXT: vmr 30, 2
+; PC64LE9-NEXT: xscvspdpn 2, 0
; PC64LE9-NEXT: bl fmaxf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 62
; PC64LE-LABEL: constrained_vector_max_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -64(1)
; PC64LE-NEXT: # kill: def $f1 killed $f1 def $vsl1
; PC64LE-NEXT: # kill: def $f5 killed $f5 def $vsl5
; PC64LE-NEXT: # kill: def $f2 killed $f2 def $vsl2
; PC64LE-NEXT: xxmrghd 0, 5, 4
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 80(1)
; PC64LE-NEXT: xxmrghd 1, 2, 1
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 2, 6
; PC64LE9-LABEL: constrained_vector_max_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -48(1)
; PC64LE9-NEXT: # kill: def $f5 killed $f5 def $vsl5
; PC64LE9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; PC64LE9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; PC64LE9-NEXT: xxmrghd 0, 5, 4
; PC64LE9-NEXT: xxmrghd 1, 2, 1
+; PC64LE9-NEXT: std 0, 64(1)
; PC64LE9-NEXT: fmr 2, 6
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
; PC64LE9-NEXT: xvmaxdp 63, 1, 0
; PC64LE-LABEL: constrained_vector_minnum_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -32(1)
+; PC64LE-NEXT: std 0, 48(1)
; PC64LE-NEXT: bl fminf
; PC64LE-NEXT: nop
; PC64LE-NEXT: addi 1, 1, 32
; PC64LE9-LABEL: constrained_vector_minnum_v1f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -32(1)
+; PC64LE9-NEXT: std 0, 48(1)
; PC64LE9-NEXT: bl fminf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: addi 1, 1, 32
; PC64LE-LABEL: constrained_vector_minnum_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -96(1)
; PC64LE-NEXT: xxsldwi 0, 34, 34, 1
; PC64LE-NEXT: xxsldwi 2, 35, 35, 1
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 112(1)
; PC64LE-NEXT: stxvd2x 62, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: li 3, 64
+; PC64LE-NEXT: vmr 30, 2
; PC64LE-NEXT: stfd 30, 80(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
-; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: xscvspdpn 1, 0
+; PC64LE-NEXT: stfd 31, 88(1) # 8-byte Folded Spill
; PC64LE-NEXT: xscvspdpn 2, 2
+; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: vmr 31, 3
-; PC64LE-NEXT: vmr 30, 2
; PC64LE-NEXT: bl fminf
; PC64LE-NEXT: nop
; PC64LE-NEXT: xxswapd 0, 62
; PC64LE9-LABEL: constrained_vector_minnum_v3f32:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -80(1)
; PC64LE9-NEXT: xxsldwi 0, 34, 34, 1
+; PC64LE9-NEXT: std 0, 96(1)
; PC64LE9-NEXT: stfd 30, 64(1) # 8-byte Folded Spill
-; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
; PC64LE9-NEXT: stxv 62, 32(1) # 16-byte Folded Spill
+; PC64LE9-NEXT: stfd 31, 72(1) # 8-byte Folded Spill
+; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
; PC64LE9-NEXT: xscvspdpn 1, 0
; PC64LE9-NEXT: xxsldwi 0, 35, 35, 1
-; PC64LE9-NEXT: stxv 63, 48(1) # 16-byte Folded Spill
-; PC64LE9-NEXT: xscvspdpn 2, 0
; PC64LE9-NEXT: vmr 31, 3
; PC64LE9-NEXT: vmr 30, 2
+; PC64LE9-NEXT: xscvspdpn 2, 0
; PC64LE9-NEXT: bl fminf
; PC64LE9-NEXT: nop
; PC64LE9-NEXT: xxswapd 0, 62
; PC64LE-LABEL: constrained_vector_min_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
-; PC64LE-NEXT: std 0, 16(1)
; PC64LE-NEXT: stdu 1, -64(1)
; PC64LE-NEXT: # kill: def $f1 killed $f1 def $vsl1
; PC64LE-NEXT: # kill: def $f5 killed $f5 def $vsl5
; PC64LE-NEXT: # kill: def $f2 killed $f2 def $vsl2
; PC64LE-NEXT: xxmrghd 0, 5, 4
; PC64LE-NEXT: li 3, 48
+; PC64LE-NEXT: std 0, 80(1)
; PC64LE-NEXT: xxmrghd 1, 2, 1
; PC64LE-NEXT: stxvd2x 63, 1, 3 # 16-byte Folded Spill
; PC64LE-NEXT: fmr 2, 6
; PC64LE9-LABEL: constrained_vector_min_v3f64:
; PC64LE9: # %bb.0: # %entry
; PC64LE9-NEXT: mflr 0
-; PC64LE9-NEXT: std 0, 16(1)
; PC64LE9-NEXT: stdu 1, -48(1)
; PC64LE9-NEXT: # kill: def $f5 killed $f5 def $vsl5
; PC64LE9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; PC64LE9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; PC64LE9-NEXT: xxmrghd 0, 5, 4
; PC64LE9-NEXT: xxmrghd 1, 2, 1
+; PC64LE9-NEXT: std 0, 64(1)
; PC64LE9-NEXT: fmr 2, 6
; PC64LE9-NEXT: stxv 63, 32(1) # 16-byte Folded Spill
; PC64LE9-NEXT: xvmindp 63, 1, 0
; PWR9LE-LABEL: v2ppcf128:
; PWR9LE: # %bb.0: # %entry
; PWR9LE-NEXT: mflr r0
-; PWR9LE-NEXT: std r0, 16(r1)
; PWR9LE-NEXT: stdu r1, -32(r1)
+; PWR9LE-NEXT: std r0, 48(r1)
; PWR9LE-NEXT: bl __gcc_qadd
; PWR9LE-NEXT: nop
; PWR9LE-NEXT: addi r1, r1, 32
; PWR9BE-LABEL: v2ppcf128:
; PWR9BE: # %bb.0: # %entry
; PWR9BE-NEXT: mflr r0
-; PWR9BE-NEXT: std r0, 16(r1)
; PWR9BE-NEXT: stdu r1, -112(r1)
+; PWR9BE-NEXT: std r0, 128(r1)
; PWR9BE-NEXT: bl __gcc_qadd
; PWR9BE-NEXT: nop
; PWR9BE-NEXT: addi r1, r1, 112
; PWR9LE-NEXT: mflr r0
; PWR9LE-NEXT: stfd f30, -16(r1) # 8-byte Folded Spill
; PWR9LE-NEXT: stfd f31, -8(r1) # 8-byte Folded Spill
-; PWR9LE-NEXT: std r0, 16(r1)
; PWR9LE-NEXT: stdu r1, -48(r1)
; PWR9LE-NEXT: fmr f31, f4
; PWR9LE-NEXT: fmr f30, f3
; PWR9LE-NEXT: fmr f3, f1
; PWR9LE-NEXT: fmr f1, f5
; PWR9LE-NEXT: fmr f2, f6
+; PWR9LE-NEXT: std r0, 64(r1)
; PWR9LE-NEXT: bl __gcc_qadd
; PWR9LE-NEXT: nop
; PWR9LE-NEXT: fmr f3, f30
; PWR9BE-LABEL: v2ppcf128_b:
; PWR9BE: # %bb.0: # %entry
; PWR9BE-NEXT: mflr r0
-; PWR9BE-NEXT: std r0, 16(r1)
; PWR9BE-NEXT: stdu r1, -128(r1)
+; PWR9BE-NEXT: std r0, 144(r1)
; PWR9BE-NEXT: stfd f30, 112(r1) # 8-byte Folded Spill
; PWR9BE-NEXT: stfd f31, 120(r1) # 8-byte Folded Spill
; PWR9BE-NEXT: fmr f31, f4
; PWR9LE-LABEL: v2ppcf128_fast:
; PWR9LE: # %bb.0: # %entry
; PWR9LE-NEXT: mflr r0
-; PWR9LE-NEXT: std r0, 16(r1)
; PWR9LE-NEXT: stdu r1, -64(r1)
+; PWR9LE-NEXT: std r0, 80(r1)
; PWR9LE-NEXT: bl __gcc_qadd
; PWR9LE-NEXT: nop
; PWR9LE-NEXT: stfd f2, 40(r1)
; PWR9BE-LABEL: v2ppcf128_fast:
; PWR9BE: # %bb.0: # %entry
; PWR9BE-NEXT: mflr r0
-; PWR9BE-NEXT: std r0, 16(r1)
; PWR9BE-NEXT: stdu r1, -144(r1)
+; PWR9BE-NEXT: std r0, 160(r1)
; PWR9BE-NEXT: bl __gcc_qadd
; PWR9BE-NEXT: nop
; PWR9BE-NEXT: stfd f2, 120(r1)
; PWR9LE-NEXT: stfd f29, -24(r1) # 8-byte Folded Spill
; PWR9LE-NEXT: stfd f30, -16(r1) # 8-byte Folded Spill
; PWR9LE-NEXT: stfd f31, -8(r1) # 8-byte Folded Spill
-; PWR9LE-NEXT: std r0, 16(r1)
; PWR9LE-NEXT: stdu r1, -64(r1)
+; PWR9LE-NEXT: std r0, 80(r1)
; PWR9LE-NEXT: fmr f31, f8
; PWR9LE-NEXT: fmr f30, f7
; PWR9LE-NEXT: fmr f29, f6
; PWR9BE-LABEL: v4ppcf128:
; PWR9BE: # %bb.0: # %entry
; PWR9BE-NEXT: mflr r0
-; PWR9BE-NEXT: std r0, 16(r1)
; PWR9BE-NEXT: stdu r1, -144(r1)
+; PWR9BE-NEXT: std r0, 160(r1)
; PWR9BE-NEXT: stfd f28, 112(r1) # 8-byte Folded Spill
; PWR9BE-NEXT: stfd f29, 120(r1) # 8-byte Folded Spill
; PWR9BE-NEXT: stfd f30, 128(r1) # 8-byte Folded Spill
; PWR9LE-NEXT: stfd f29, -24(r1) # 8-byte Folded Spill
; PWR9LE-NEXT: stfd f30, -16(r1) # 8-byte Folded Spill
; PWR9LE-NEXT: stfd f31, -8(r1) # 8-byte Folded Spill
-; PWR9LE-NEXT: std r0, 16(r1)
; PWR9LE-NEXT: stdu r1, -80(r1)
; PWR9LE-NEXT: fmr f27, f4
; PWR9LE-NEXT: fmr f26, f3
; PWR9LE-NEXT: fmr f3, f1
; PWR9LE-NEXT: fmr f1, f9
; PWR9LE-NEXT: fmr f2, f10
+; PWR9LE-NEXT: std r0, 96(r1)
; PWR9LE-NEXT: fmr f31, f8
; PWR9LE-NEXT: fmr f30, f7
; PWR9LE-NEXT: fmr f29, f6
; PWR9BE-LABEL: v4ppcf128_b:
; PWR9BE: # %bb.0: # %entry
; PWR9BE-NEXT: mflr r0
-; PWR9BE-NEXT: std r0, 16(r1)
; PWR9BE-NEXT: stdu r1, -160(r1)
+; PWR9BE-NEXT: std r0, 176(r1)
; PWR9BE-NEXT: stfd f26, 112(r1) # 8-byte Folded Spill
; PWR9BE-NEXT: stfd f27, 120(r1) # 8-byte Folded Spill
; PWR9BE-NEXT: fmr f27, f4
; PWR9LE-NEXT: stfd f29, -24(r1) # 8-byte Folded Spill
; PWR9LE-NEXT: stfd f30, -16(r1) # 8-byte Folded Spill
; PWR9LE-NEXT: stfd f31, -8(r1) # 8-byte Folded Spill
-; PWR9LE-NEXT: std r0, 16(r1)
; PWR9LE-NEXT: stdu r1, -96(r1)
; PWR9LE-NEXT: fmr f29, f4
; PWR9LE-NEXT: fmr f28, f3
; PWR9LE-NEXT: fmr f3, f5
; PWR9LE-NEXT: fmr f4, f6
+; PWR9LE-NEXT: std r0, 112(r1)
; PWR9LE-NEXT: fmr f31, f8
; PWR9LE-NEXT: fmr f30, f7
; PWR9LE-NEXT: bl __gcc_qadd
; PWR9BE-LABEL: v4ppcf128_fast:
; PWR9BE: # %bb.0: # %entry
; PWR9BE-NEXT: mflr r0
-; PWR9BE-NEXT: std r0, 16(r1)
; PWR9BE-NEXT: stdu r1, -176(r1)
+; PWR9BE-NEXT: std r0, 192(r1)
; PWR9BE-NEXT: stfd f28, 144(r1) # 8-byte Folded Spill
; PWR9BE-NEXT: stfd f29, 152(r1) # 8-byte Folded Spill
; PWR9BE-NEXT: fmr f29, f4
; CHECK-NEXT: # %bb.0: # %entry
; CHECK-NEXT: L..tmp3:
; CHECK-NEXT: mflr 0
-; CHECK-NEXT: stw 0, 8(1)
; CHECK-NEXT: stwu 1, -64(1)
; CHECK-NEXT: li 3, 0
+; CHECK-NEXT: stw 0, 72(1)
; CHECK-NEXT: stw 3, 60(1)
; CHECK-NEXT: L..tmp4:
; CHECK-NEXT: L..tmp5:
projects / platform / upstream / llvm.git / commitdiff