Handle subregs and superregs in callee-saved register mask

[jrtc27]

Summary

If a target lists both a subreg and a superreg in a callee-saved
register mask, the prolog will spill both aliasing registers. Instead,
don't spill the subreg if a superreg is being spilled. This case is hit by the
PowerPC SPE code, as well as a modified RISC-V backend for CHERI I maintain out
of tree.

[jhibbits]

Thanks for doing this! It's been on my TODO list for a little while already for SPE, but I never got around to it.

Is there any provision for spilling only the subreg, not the superreg? It seems to me that whenever the subreg needs spilled, it always also spills the superreg, even if the full superreg is not used.

[fhahn]

llvm/lib/CodeGen/PrologEpilogInserter.cpp

408

nit: I think you could use MCRegisterInfo::subregs() which is slightly less code.

[arsenm]

llvm/lib/CodeGen/PrologEpilogInserter.cpp

408

These masks should eventually be in terms of regunits

[jrtc27]

In D73170#1833793, @jhibbits wrote:

Thanks for doing this! It's been on my TODO list for a little while already for SPE, but I never got around to it.

Is there any provision for spilling only the subreg, not the superreg? It seems to me that whenever the subreg needs spilled, it always also spills the superreg, even if the full superreg is not used.

No, because restoring a subreg often has the side-effect of clearing the rest of the superreg, thereby violating the callee-preserved nature of them. I don't know whether that applies to SPE or not (and therefore whether the previously generated code was technically wrong), but it certainly applies to CHERI RISC-V.

llvm/lib/CodeGen/PrologEpilogInserter.cpp

408

Ah yes, I remember seeing MCRegisterInfo::subregs() go in but originally wrote this patch (not for SPE) over a year ago. I will update to the nicer API.

[jrtc27]

Switch from explicit iterator to recently-added range-based for loop interface. Ok to merge?

[jrtc27]

Ping?

[luismarques]

In D73170#1871167, @jrtc27 wrote:

Ping?

Ping landing this?

[jrtc27]

Rebased

[jrtc27]

Post-D101282 fp-strict.ll also has SPE check lines that get improved by this patch

[nemanjai]

It appears that this is approved but it keeps getting pinged. @jrtc27 Do you need someone to land this for you or are you hoping that someone else also approve this (perhaps @fhahn or @arsenm)?

[jrtc27]

I was speaking with @jhibbits earlier who intends to sanity check the updated SPE test changes, not that I expect there to be any issues

[jhibbits]

The spe.ll respin looks fine to me.

llvm/lib/CodeGen/PrologEpilogInserter.cpp

static void assignCalleeSavedSpillSlots(MachineFunction &F,
                                         const BitVector &SavedRegs,
                                         unsigned &MinCSFrameIndex,
                                         unsigned &MaxCSFrameIndex) {
   if (SavedRegs.empty())
     return;
 
   const TargetRegisterInfo *RegInfo = F.getSubtarget().getRegisterInfo();
   const MCPhysReg *CSRegs = F.getRegInfo().getCalleeSavedRegs();
+  BitVector CSMask(SavedRegs.size());
+
+  for (unsigned i = 0; CSRegs[i]; ++i)
+    CSMask.set(CSRegs[i]);
 
   std::vector<CalleeSavedInfo> CSI;
   for (unsigned i = 0; CSRegs[i]; ++i) {
     unsigned Reg = CSRegs[i];
-    if (SavedRegs.test(Reg))
+    if (SavedRegs.test(Reg)) {
+      bool SavedSuper = false;
+      for (const MCPhysReg &SuperReg : RegInfo->superregs(Reg)) {
+        // Some backends set all aliases for some registers as saved, such as
+        // Mips's $fp, so they appear in SavedRegs but not CSRegs.
+        if (SavedRegs.test(SuperReg) && CSMask.test(SuperReg)) {
+          SavedSuper = true;
+          break;
+        }
+      }
+
+      if (!SavedSuper)
         CSI.push_back(CalleeSavedInfo(Reg));
     }
+  }
 
   const TargetFrameLowering *TFI = F.getSubtarget().getFrameLowering();
   MachineFrameInfo &MFI = F.getFrameInfo();
   if (!TFI->assignCalleeSavedSpillSlots(F, RegInfo, CSI, MinCSFrameIndex,
                                         MaxCSFrameIndex)) {
     // If target doesn't implement this, use generic code.
 
     if (CSI.empty())

llvm/test/CodeGen/PowerPC/fp-strict.ll

 ; NOVSX-NEXT:    stfs f0, -16(r1)
 ; NOVSX-NEXT:    lvx v2, 0, r3
 ; NOVSX-NEXT:    blr
 ;
 ; SPE-LABEL: fmadd_v4f32:
 ; SPE:       # %bb.0:
 ; SPE-NEXT:    mflr r0
 ; SPE-NEXT:    stw r0, 4(r1)
-; SPE-NEXT:    stwu r1, -144(r1)
-; SPE-NEXT:    .cfi_def_cfa_offset 144
+; SPE-NEXT:    stwu r1, -96(r1)
+; SPE-NEXT:    .cfi_def_cfa_offset 96
 ; SPE-NEXT:    .cfi_offset lr, 4
-; SPE-NEXT:    .cfi_offset r21, -44
-; SPE-NEXT:    .cfi_offset r22, -40
-; SPE-NEXT:    .cfi_offset r23, -36
-; SPE-NEXT:    .cfi_offset r24, -32
-; SPE-NEXT:    .cfi_offset r25, -28
-; SPE-NEXT:    .cfi_offset r26, -24
-; SPE-NEXT:    .cfi_offset r27, -20
-; SPE-NEXT:    .cfi_offset r28, -16
-; SPE-NEXT:    .cfi_offset r29, -12
-; SPE-NEXT:    .cfi_offset r30, -8
-; SPE-NEXT:    .cfi_offset r21, -136
-; SPE-NEXT:    .cfi_offset r22, -128
-; SPE-NEXT:    .cfi_offset r23, -120
-; SPE-NEXT:    .cfi_offset r24, -112
-; SPE-NEXT:    .cfi_offset r25, -104
-; SPE-NEXT:    .cfi_offset r26, -96
-; SPE-NEXT:    .cfi_offset r27, -88
-; SPE-NEXT:    .cfi_offset r28, -80
-; SPE-NEXT:    .cfi_offset r29, -72
-; SPE-NEXT:    .cfi_offset r30, -64
-; SPE-NEXT:    stw r27, 124(r1) # 4-byte Folded Spill
+; SPE-NEXT:    .cfi_offset r21, -88
+; SPE-NEXT:    .cfi_offset r22, -80
+; SPE-NEXT:    .cfi_offset r23, -72
+; SPE-NEXT:    .cfi_offset r24, -64
+; SPE-NEXT:    .cfi_offset r25, -56
+; SPE-NEXT:    .cfi_offset r26, -48
+; SPE-NEXT:    .cfi_offset r27, -40
+; SPE-NEXT:    .cfi_offset r28, -32
+; SPE-NEXT:    .cfi_offset r29, -24
+; SPE-NEXT:    .cfi_offset r30, -16
 ; SPE-NEXT:    evstdd r27, 56(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r27, r5
-; SPE-NEXT:    lwz r5, 164(r1)
-; SPE-NEXT:    stw r25, 116(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r26, 120(r1) # 4-byte Folded Spill
+; SPE-NEXT:    lwz r5, 116(r1)
 ; SPE-NEXT:    evstdd r25, 40(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r25, r3
 ; SPE-NEXT:    evstdd r26, 48(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r26, r4
 ; SPE-NEXT:    mr r3, r6
 ; SPE-NEXT:    mr r4, r10
-; SPE-NEXT:    stw r21, 100(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r22, 104(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r23, 108(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r24, 112(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r28, 128(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r29, 132(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r30, 136(r1) # 4-byte Folded Spill
 ; SPE-NEXT:    evstdd r21, 8(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r22, 16(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r23, 24(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r24, 32(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r28, 64(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r28, r7
 ; SPE-NEXT:    evstdd r29, 72(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r29, r8
 ; SPE-NEXT:    evstdd r30, 80(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r30, r9
-; SPE-NEXT:    lwz r24, 152(r1)
-; SPE-NEXT:    lwz r23, 156(r1)
-; SPE-NEXT:    lwz r22, 160(r1)
+; SPE-NEXT:    lwz r24, 104(r1)
+; SPE-NEXT:    lwz r23, 108(r1)
+; SPE-NEXT:    lwz r22, 112(r1)
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    mr r21, r3
 ; SPE-NEXT:    mr r3, r27
 ; SPE-NEXT:    mr r4, r30
 ; SPE-NEXT:    mr r5, r22
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    mr r30, r3
 ; SPE-NEXT:    mr r3, r26

 ; SPE-NEXT:    evldd r28, 64(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r27, 56(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r26, 48(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r25, 40(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r24, 32(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r23, 24(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r22, 16(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r21, 8(r1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz r30, 136(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r29, 132(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r28, 128(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r27, 124(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r26, 120(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r25, 116(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r24, 112(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r23, 108(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r22, 104(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r21, 100(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r0, 148(r1)
-; SPE-NEXT:    addi r1, r1, 144
+; SPE-NEXT:    lwz r0, 100(r1)
+; SPE-NEXT:    addi r1, r1, 96
 ; SPE-NEXT:    mtlr r0
 ; SPE-NEXT:    blr
   %res = call <4 x float> @llvm.experimental.constrained.fma.v4f32(
                         <4 x float> %vf0, <4 x float> %vf1, <4 x float> %vf2,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <4 x float> %res
 }

 ; NOVSX-NEXT:    fmadd f2, f2, f4, f6
 ; NOVSX-NEXT:    fmadd f1, f1, f3, f5
 ; NOVSX-NEXT:    blr
 ;
 ; SPE-LABEL: fmadd_v2f64:
 ; SPE:       # %bb.0:
 ; SPE-NEXT:    mflr r0
 ; SPE-NEXT:    stw r0, 4(r1)
-; SPE-NEXT:    stwu r1, -96(r1)
-; SPE-NEXT:    .cfi_def_cfa_offset 96
+; SPE-NEXT:    stwu r1, -64(r1)
+; SPE-NEXT:    .cfi_def_cfa_offset 64
 ; SPE-NEXT:    .cfi_offset lr, 4
-; SPE-NEXT:    .cfi_offset r26, -24
-; SPE-NEXT:    .cfi_offset r27, -20
-; SPE-NEXT:    .cfi_offset r28, -16
-; SPE-NEXT:    .cfi_offset r29, -12
-; SPE-NEXT:    .cfi_offset r30, -8
-; SPE-NEXT:    .cfi_offset r26, -80
-; SPE-NEXT:    .cfi_offset r27, -72
-; SPE-NEXT:    .cfi_offset r28, -64
-; SPE-NEXT:    .cfi_offset r29, -56
-; SPE-NEXT:    .cfi_offset r30, -48
-; SPE-NEXT:    stw r26, 72(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r27, 76(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r28, 80(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r29, 84(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r30, 88(r1) # 4-byte Folded Spill
+; SPE-NEXT:    .cfi_offset r26, -48
+; SPE-NEXT:    .cfi_offset r27, -40
+; SPE-NEXT:    .cfi_offset r28, -32
+; SPE-NEXT:    .cfi_offset r29, -24
+; SPE-NEXT:    .cfi_offset r30, -16
 ; SPE-NEXT:    evstdd r26, 16(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r27, 24(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r28, 32(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r29, 40(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r30, 48(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evmergelo r27, r7, r8
 ; SPE-NEXT:    evmergelo r9, r9, r10
 ; SPE-NEXT:    evmergelo r4, r5, r6
 ; SPE-NEXT:    mr r30, r3
-; SPE-NEXT:    evldd r8, 112(r1)
+; SPE-NEXT:    evldd r8, 80(r1)
 ; SPE-NEXT:    evmergehi r3, r4, r4
 ; SPE-NEXT:    evmergehi r5, r9, r9
 ; SPE-NEXT:    mr r6, r9
-; SPE-NEXT:    evldd r29, 120(r1)
+; SPE-NEXT:    evldd r29, 88(r1)
 ; SPE-NEXT:    # kill: def $r3 killed $r3 killed $s3
 ; SPE-NEXT:    # kill: def $r4 killed $r4 killed $s4
 ; SPE-NEXT:    # kill: def $r5 killed $r5 killed $s5
 ; SPE-NEXT:    evmergehi r7, r8, r8
-; SPE-NEXT:    evldd r28, 104(r1)
+; SPE-NEXT:    evldd r28, 72(r1)
 ; SPE-NEXT:    # kill: def $r7 killed $r7 killed $s7
 ; SPE-NEXT:    # kill: def $r8 killed $r8 killed $s8
 ; SPE-NEXT:    bl fma
 ; SPE-NEXT:    evmergelo r26, r3, r4
 ; SPE-NEXT:    evmergehi r3, r27, r27
 ; SPE-NEXT:    evmergehi r5, r28, r28
 ; SPE-NEXT:    evmergehi r7, r29, r29
 ; SPE-NEXT:    mr r4, r27
 ; SPE-NEXT:    mr r6, r28
 ; SPE-NEXT:    mr r8, r29
 ; SPE-NEXT:    # kill: def $r3 killed $r3 killed $s3
 ; SPE-NEXT:    # kill: def $r5 killed $r5 killed $s5
 ; SPE-NEXT:    # kill: def $r7 killed $r7 killed $s7
 ; SPE-NEXT:    bl fma
 ; SPE-NEXT:    li r5, 8
 ; SPE-NEXT:    evmergelo r3, r3, r4
 ; SPE-NEXT:    evstddx r3, r30, r5
 ; SPE-NEXT:    evstdd r26, 0(r30)
 ; SPE-NEXT:    evldd r30, 48(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r29, 40(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r28, 32(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r27, 24(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r26, 16(r1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz r30, 88(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r29, 84(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r28, 80(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r27, 76(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r26, 72(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r0, 100(r1)
-; SPE-NEXT:    addi r1, r1, 96
+; SPE-NEXT:    lwz r0, 68(r1)
+; SPE-NEXT:    addi r1, r1, 64
 ; SPE-NEXT:    mtlr r0
 ; SPE-NEXT:    blr
   %res = call <2 x double> @llvm.experimental.constrained.fma.v2f64(
                         <2 x double> %vf0, <2 x double> %vf1, <2 x double> %vf2,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <2 x double> %res
 }

 ; NOVSX-NEXT:    stfs f0, -16(r1)
 ; NOVSX-NEXT:    lvx v2, 0, r3
 ; NOVSX-NEXT:    blr
 ;
 ; SPE-LABEL: fmsub_v4f32:
 ; SPE:       # %bb.0:
 ; SPE-NEXT:    mflr r0
 ; SPE-NEXT:    stw r0, 4(r1)
-; SPE-NEXT:    stwu r1, -144(r1)
-; SPE-NEXT:    .cfi_def_cfa_offset 144
+; SPE-NEXT:    stwu r1, -96(r1)
+; SPE-NEXT:    .cfi_def_cfa_offset 96
 ; SPE-NEXT:    .cfi_offset lr, 4
-; SPE-NEXT:    .cfi_offset r21, -44
-; SPE-NEXT:    .cfi_offset r22, -40
-; SPE-NEXT:    .cfi_offset r23, -36
-; SPE-NEXT:    .cfi_offset r24, -32
-; SPE-NEXT:    .cfi_offset r25, -28
-; SPE-NEXT:    .cfi_offset r26, -24
-; SPE-NEXT:    .cfi_offset r27, -20
-; SPE-NEXT:    .cfi_offset r28, -16
-; SPE-NEXT:    .cfi_offset r29, -12
-; SPE-NEXT:    .cfi_offset r30, -8
-; SPE-NEXT:    .cfi_offset r21, -136
-; SPE-NEXT:    .cfi_offset r22, -128
-; SPE-NEXT:    .cfi_offset r23, -120
-; SPE-NEXT:    .cfi_offset r24, -112
-; SPE-NEXT:    .cfi_offset r25, -104
-; SPE-NEXT:    .cfi_offset r26, -96
-; SPE-NEXT:    .cfi_offset r27, -88
-; SPE-NEXT:    .cfi_offset r28, -80
-; SPE-NEXT:    .cfi_offset r29, -72
-; SPE-NEXT:    .cfi_offset r30, -64
-; SPE-NEXT:    stw r25, 116(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r26, 120(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r27, 124(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r28, 128(r1) # 4-byte Folded Spill
+; SPE-NEXT:    .cfi_offset r21, -88
+; SPE-NEXT:    .cfi_offset r22, -80
+; SPE-NEXT:    .cfi_offset r23, -72
+; SPE-NEXT:    .cfi_offset r24, -64
+; SPE-NEXT:    .cfi_offset r25, -56
+; SPE-NEXT:    .cfi_offset r26, -48
+; SPE-NEXT:    .cfi_offset r27, -40
+; SPE-NEXT:    .cfi_offset r28, -32
+; SPE-NEXT:    .cfi_offset r29, -24
+; SPE-NEXT:    .cfi_offset r30, -16
 ; SPE-NEXT:    evstdd r25, 40(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r25, r3
 ; SPE-NEXT:    evstdd r26, 48(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r26, r4
 ; SPE-NEXT:    evstdd r27, 56(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r27, r5
 ; SPE-NEXT:    evstdd r28, 64(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r28, r7
-; SPE-NEXT:    lwz r3, 160(r1)
-; SPE-NEXT:    lwz r4, 152(r1)
-; SPE-NEXT:    lwz r5, 156(r1)
-; SPE-NEXT:    lwz r7, 164(r1)
-; SPE-NEXT:    stw r22, 104(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r23, 108(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r24, 112(r1) # 4-byte Folded Spill
+; SPE-NEXT:    lwz r3, 112(r1)
+; SPE-NEXT:    lwz r4, 104(r1)
+; SPE-NEXT:    lwz r5, 108(r1)
+; SPE-NEXT:    lwz r7, 116(r1)
 ; SPE-NEXT:    evstdd r22, 16(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    efsneg r22, r3
 ; SPE-NEXT:    evstdd r23, 24(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    efsneg r23, r5
 ; SPE-NEXT:    evstdd r24, 32(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    efsneg r24, r4
 ; SPE-NEXT:    efsneg r5, r7
 ; SPE-NEXT:    mr r3, r6
 ; SPE-NEXT:    mr r4, r10
-; SPE-NEXT:    stw r21, 100(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r29, 132(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r30, 136(r1) # 4-byte Folded Spill
 ; SPE-NEXT:    evstdd r21, 8(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r29, 72(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r29, r8
 ; SPE-NEXT:    evstdd r30, 80(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r30, r9
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    mr r21, r3
 ; SPE-NEXT:    mr r3, r27

 ; SPE-NEXT:    evldd r28, 64(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r27, 56(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r26, 48(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r25, 40(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r24, 32(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r23, 24(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r22, 16(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r21, 8(r1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz r30, 136(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r29, 132(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r28, 128(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r27, 124(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r26, 120(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r25, 116(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r24, 112(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r23, 108(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r22, 104(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r21, 100(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r0, 148(r1)
-; SPE-NEXT:    addi r1, r1, 144
+; SPE-NEXT:    lwz r0, 100(r1)
+; SPE-NEXT:    addi r1, r1, 96
 ; SPE-NEXT:    mtlr r0
 ; SPE-NEXT:    blr
   %neg = fneg <4 x float> %vf2
   %res = call <4 x float> @llvm.experimental.constrained.fma.v4f32(
                         <4 x float> %vf0, <4 x float> %vf1, <4 x float> %neg,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <4 x float> %res

 ; NOVSX-NEXT:    fmsub f2, f2, f4, f6
 ; NOVSX-NEXT:    fmsub f1, f1, f3, f5
 ; NOVSX-NEXT:    blr
 ;
 ; SPE-LABEL: fmsub_v2f64:
 ; SPE:       # %bb.0:
 ; SPE-NEXT:    mflr r0
 ; SPE-NEXT:    stw r0, 4(r1)
-; SPE-NEXT:    stwu r1, -96(r1)
-; SPE-NEXT:    .cfi_def_cfa_offset 96
+; SPE-NEXT:    stwu r1, -64(r1)
+; SPE-NEXT:    .cfi_def_cfa_offset 64
 ; SPE-NEXT:    .cfi_offset lr, 4
-; SPE-NEXT:    .cfi_offset r26, -24
-; SPE-NEXT:    .cfi_offset r27, -20
-; SPE-NEXT:    .cfi_offset r28, -16
-; SPE-NEXT:    .cfi_offset r29, -12
-; SPE-NEXT:    .cfi_offset r30, -8
-; SPE-NEXT:    .cfi_offset r26, -80
-; SPE-NEXT:    .cfi_offset r27, -72
-; SPE-NEXT:    .cfi_offset r28, -64
-; SPE-NEXT:    .cfi_offset r29, -56
-; SPE-NEXT:    .cfi_offset r30, -48
-; SPE-NEXT:    stw r30, 88(r1) # 4-byte Folded Spill
+; SPE-NEXT:    .cfi_offset r26, -48
+; SPE-NEXT:    .cfi_offset r27, -40
+; SPE-NEXT:    .cfi_offset r28, -32
+; SPE-NEXT:    .cfi_offset r29, -24
+; SPE-NEXT:    .cfi_offset r30, -16
 ; SPE-NEXT:    evstdd r30, 48(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r30, r3
-; SPE-NEXT:    evldd r3, 112(r1)
-; SPE-NEXT:    evldd r11, 120(r1)
-; SPE-NEXT:    stw r26, 72(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r27, 76(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r28, 80(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r29, 84(r1) # 4-byte Folded Spill
+; SPE-NEXT:    evldd r3, 80(r1)
+; SPE-NEXT:    evldd r11, 88(r1)
 ; SPE-NEXT:    evstdd r26, 16(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r27, 24(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    efdneg r27, r11
 ; SPE-NEXT:    evstdd r28, 32(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r29, 40(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evmergelo r29, r7, r8
 ; SPE-NEXT:    evmergelo r9, r9, r10
 ; SPE-NEXT:    evmergelo r4, r5, r6
 ; SPE-NEXT:    efdneg r8, r3
 ; SPE-NEXT:    evmergehi r3, r4, r4
 ; SPE-NEXT:    evmergehi r5, r9, r9
 ; SPE-NEXT:    evmergehi r7, r8, r8
 ; SPE-NEXT:    mr r6, r9
-; SPE-NEXT:    evldd r28, 104(r1)
+; SPE-NEXT:    evldd r28, 72(r1)
 ; SPE-NEXT:    # kill: def $r3 killed $r3 killed $s3
 ; SPE-NEXT:    # kill: def $r4 killed $r4 killed $s4
 ; SPE-NEXT:    # kill: def $r5 killed $r5 killed $s5
 ; SPE-NEXT:    # kill: def $r7 killed $r7 killed $s7
 ; SPE-NEXT:    # kill: def $r8 killed $r8 killed $s8
 ; SPE-NEXT:    bl fma
 ; SPE-NEXT:    evmergelo r26, r3, r4
 ; SPE-NEXT:    evmergehi r3, r29, r29

 ; SPE-NEXT:    evmergelo r3, r3, r4
 ; SPE-NEXT:    evstddx r3, r30, r5
 ; SPE-NEXT:    evstdd r26, 0(r30)
 ; SPE-NEXT:    evldd r30, 48(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r29, 40(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r28, 32(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r27, 24(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r26, 16(r1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz r30, 88(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r29, 84(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r28, 80(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r27, 76(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r26, 72(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r0, 100(r1)
-; SPE-NEXT:    addi r1, r1, 96
+; SPE-NEXT:    lwz r0, 68(r1)
+; SPE-NEXT:    addi r1, r1, 64
 ; SPE-NEXT:    mtlr r0
 ; SPE-NEXT:    blr
   %neg = fneg <2 x double> %vf2
   %res = call <2 x double> @llvm.experimental.constrained.fma.v2f64(
                         <2 x double> %vf0, <2 x double> %vf1, <2 x double> %neg,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <2 x double> %res

 ; NOVSX-NEXT:    lvx v3, 0, r3
 ; NOVSX-NEXT:    vsubfp v2, v2, v3
 ; NOVSX-NEXT:    blr
 ;
 ; SPE-LABEL: fnmadd_v4f32:
 ; SPE:       # %bb.0:
 ; SPE-NEXT:    mflr r0
 ; SPE-NEXT:    stw r0, 4(r1)
-; SPE-NEXT:    stwu r1, -144(r1)
-; SPE-NEXT:    .cfi_def_cfa_offset 144
+; SPE-NEXT:    stwu r1, -96(r1)
+; SPE-NEXT:    .cfi_def_cfa_offset 96
 ; SPE-NEXT:    .cfi_offset lr, 4
-; SPE-NEXT:    .cfi_offset r21, -44
-; SPE-NEXT:    .cfi_offset r22, -40
-; SPE-NEXT:    .cfi_offset r23, -36
-; SPE-NEXT:    .cfi_offset r24, -32
-; SPE-NEXT:    .cfi_offset r25, -28
-; SPE-NEXT:    .cfi_offset r26, -24
-; SPE-NEXT:    .cfi_offset r27, -20
-; SPE-NEXT:    .cfi_offset r28, -16
-; SPE-NEXT:    .cfi_offset r29, -12
-; SPE-NEXT:    .cfi_offset r30, -8
-; SPE-NEXT:    .cfi_offset r21, -136
-; SPE-NEXT:    .cfi_offset r22, -128
-; SPE-NEXT:    .cfi_offset r23, -120
-; SPE-NEXT:    .cfi_offset r24, -112
-; SPE-NEXT:    .cfi_offset r25, -104
-; SPE-NEXT:    .cfi_offset r26, -96
-; SPE-NEXT:    .cfi_offset r27, -88
-; SPE-NEXT:    .cfi_offset r28, -80
-; SPE-NEXT:    .cfi_offset r29, -72
-; SPE-NEXT:    .cfi_offset r30, -64
-; SPE-NEXT:    stw r27, 124(r1) # 4-byte Folded Spill
+; SPE-NEXT:    .cfi_offset r21, -88
+; SPE-NEXT:    .cfi_offset r22, -80
+; SPE-NEXT:    .cfi_offset r23, -72
+; SPE-NEXT:    .cfi_offset r24, -64
+; SPE-NEXT:    .cfi_offset r25, -56
+; SPE-NEXT:    .cfi_offset r26, -48
+; SPE-NEXT:    .cfi_offset r27, -40
+; SPE-NEXT:    .cfi_offset r28, -32
+; SPE-NEXT:    .cfi_offset r29, -24
+; SPE-NEXT:    .cfi_offset r30, -16
 ; SPE-NEXT:    evstdd r27, 56(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r27, r5
-; SPE-NEXT:    lwz r5, 164(r1)
-; SPE-NEXT:    stw r25, 116(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r26, 120(r1) # 4-byte Folded Spill
+; SPE-NEXT:    lwz r5, 116(r1)
 ; SPE-NEXT:    evstdd r25, 40(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r25, r3
 ; SPE-NEXT:    evstdd r26, 48(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r26, r4
 ; SPE-NEXT:    mr r3, r6
 ; SPE-NEXT:    mr r4, r10
-; SPE-NEXT:    stw r21, 100(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r22, 104(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r23, 108(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r24, 112(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r28, 128(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r29, 132(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r30, 136(r1) # 4-byte Folded Spill
 ; SPE-NEXT:    evstdd r21, 8(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r22, 16(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r23, 24(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r24, 32(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r28, 64(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r28, r7
 ; SPE-NEXT:    evstdd r29, 72(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r29, r8
 ; SPE-NEXT:    evstdd r30, 80(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r30, r9
-; SPE-NEXT:    lwz r24, 152(r1)
-; SPE-NEXT:    lwz r23, 156(r1)
-; SPE-NEXT:    lwz r22, 160(r1)
+; SPE-NEXT:    lwz r24, 104(r1)
+; SPE-NEXT:    lwz r23, 108(r1)
+; SPE-NEXT:    lwz r22, 112(r1)
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    mr r21, r3
 ; SPE-NEXT:    mr r3, r27
 ; SPE-NEXT:    mr r4, r30
 ; SPE-NEXT:    mr r5, r22
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    mr r30, r3
 ; SPE-NEXT:    mr r3, r26
 ; SPE-NEXT:    mr r4, r29
 ; SPE-NEXT:    mr r5, r23
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    mr r29, r3
 ; SPE-NEXT:    mr r3, r25
 ; SPE-NEXT:    mr r4, r28
 ; SPE-NEXT:    mr r5, r24
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    efsneg r4, r29
 ; SPE-NEXT:    efsneg r5, r30
+; SPE-NEXT:    efsneg r3, r3
 ; SPE-NEXT:    efsneg r6, r21
 ; SPE-NEXT:    evldd r30, 80(r1) # 8-byte Folded Reload
-; SPE-NEXT:    efsneg r3, r3
 ; SPE-NEXT:    evldd r29, 72(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r28, 64(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r27, 56(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r26, 48(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r25, 40(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r24, 32(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r23, 24(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r22, 16(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r21, 8(r1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz r30, 136(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r29, 132(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r28, 128(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r27, 124(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r26, 120(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r25, 116(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r24, 112(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r23, 108(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r22, 104(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r21, 100(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r0, 148(r1)
-; SPE-NEXT:    addi r1, r1, 144
+; SPE-NEXT:    lwz r0, 100(r1)
+; SPE-NEXT:    addi r1, r1, 96
 ; SPE-NEXT:    mtlr r0
 ; SPE-NEXT:    blr
   %fma = call <4 x float> @llvm.experimental.constrained.fma.v4f32(
                         <4 x float> %vf0, <4 x float> %vf1, <4 x float> %vf2,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   %res = fneg <4 x float> %fma
   ret <4 x float> %res

 ; NOVSX-NEXT:    fnmadd f2, f2, f4, f6
 ; NOVSX-NEXT:    fnmadd f1, f1, f3, f5
 ; NOVSX-NEXT:    blr
 ;
 ; SPE-LABEL: fnmadd_v2f64:
 ; SPE:       # %bb.0:
 ; SPE-NEXT:    mflr r0
 ; SPE-NEXT:    stw r0, 4(r1)
-; SPE-NEXT:    stwu r1, -96(r1)
-; SPE-NEXT:    .cfi_def_cfa_offset 96
+; SPE-NEXT:    stwu r1, -64(r1)
+; SPE-NEXT:    .cfi_def_cfa_offset 64
 ; SPE-NEXT:    .cfi_offset lr, 4
-; SPE-NEXT:    .cfi_offset r26, -24
-; SPE-NEXT:    .cfi_offset r27, -20
-; SPE-NEXT:    .cfi_offset r28, -16
-; SPE-NEXT:    .cfi_offset r29, -12
-; SPE-NEXT:    .cfi_offset r30, -8
-; SPE-NEXT:    .cfi_offset r26, -80
-; SPE-NEXT:    .cfi_offset r27, -72
-; SPE-NEXT:    .cfi_offset r28, -64
-; SPE-NEXT:    .cfi_offset r29, -56
-; SPE-NEXT:    .cfi_offset r30, -48
-; SPE-NEXT:    stw r26, 72(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r27, 76(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r28, 80(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r29, 84(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r30, 88(r1) # 4-byte Folded Spill
+; SPE-NEXT:    .cfi_offset r26, -48
+; SPE-NEXT:    .cfi_offset r27, -40
+; SPE-NEXT:    .cfi_offset r28, -32
+; SPE-NEXT:    .cfi_offset r29, -24
+; SPE-NEXT:    .cfi_offset r30, -16
 ; SPE-NEXT:    evstdd r26, 16(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r27, 24(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r28, 32(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r29, 40(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r30, 48(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evmergelo r27, r7, r8
 ; SPE-NEXT:    evmergelo r9, r9, r10
 ; SPE-NEXT:    evmergelo r4, r5, r6
 ; SPE-NEXT:    mr r30, r3
-; SPE-NEXT:    evldd r8, 112(r1)
+; SPE-NEXT:    evldd r8, 80(r1)
 ; SPE-NEXT:    evmergehi r3, r4, r4
 ; SPE-NEXT:    evmergehi r5, r9, r9
 ; SPE-NEXT:    mr r6, r9
-; SPE-NEXT:    evldd r29, 120(r1)
+; SPE-NEXT:    evldd r29, 88(r1)
 ; SPE-NEXT:    # kill: def $r3 killed $r3 killed $s3
 ; SPE-NEXT:    # kill: def $r4 killed $r4 killed $s4
 ; SPE-NEXT:    # kill: def $r5 killed $r5 killed $s5
 ; SPE-NEXT:    evmergehi r7, r8, r8
-; SPE-NEXT:    evldd r28, 104(r1)
+; SPE-NEXT:    evldd r28, 72(r1)
 ; SPE-NEXT:    # kill: def $r7 killed $r7 killed $s7
 ; SPE-NEXT:    # kill: def $r8 killed $r8 killed $s8
 ; SPE-NEXT:    bl fma
 ; SPE-NEXT:    evmergelo r26, r3, r4
 ; SPE-NEXT:    evmergehi r3, r27, r27
 ; SPE-NEXT:    evmergehi r5, r28, r28
 ; SPE-NEXT:    evmergehi r7, r29, r29
 ; SPE-NEXT:    mr r4, r27

 ; SPE-NEXT:    evstddx r3, r30, r5
 ; SPE-NEXT:    efdneg r3, r26
 ; SPE-NEXT:    evstdd r3, 0(r30)
 ; SPE-NEXT:    evldd r30, 48(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r29, 40(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r28, 32(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r27, 24(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r26, 16(r1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz r30, 88(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r29, 84(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r28, 80(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r27, 76(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r26, 72(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r0, 100(r1)
-; SPE-NEXT:    addi r1, r1, 96
+; SPE-NEXT:    lwz r0, 68(r1)
+; SPE-NEXT:    addi r1, r1, 64
 ; SPE-NEXT:    mtlr r0
 ; SPE-NEXT:    blr
   %fma = call <2 x double> @llvm.experimental.constrained.fma.v2f64(
                         <2 x double> %vf0, <2 x double> %vf1, <2 x double> %vf2,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   %res = fneg <2 x double> %fma
   ret <2 x double> %res

 ; NOVSX-NEXT:    lvx v2, 0, r3
 ; NOVSX-NEXT:    vsubfp v2, v5, v2
 ; NOVSX-NEXT:    blr
 ;
 ; SPE-LABEL: fnmsub_v4f32:
 ; SPE:       # %bb.0:
 ; SPE-NEXT:    mflr r0
 ; SPE-NEXT:    stw r0, 4(r1)
-; SPE-NEXT:    stwu r1, -144(r1)
-; SPE-NEXT:    .cfi_def_cfa_offset 144
+; SPE-NEXT:    stwu r1, -96(r1)
+; SPE-NEXT:    .cfi_def_cfa_offset 96
 ; SPE-NEXT:    .cfi_offset lr, 4
-; SPE-NEXT:    .cfi_offset r21, -44
-; SPE-NEXT:    .cfi_offset r22, -40
-; SPE-NEXT:    .cfi_offset r23, -36
-; SPE-NEXT:    .cfi_offset r24, -32
-; SPE-NEXT:    .cfi_offset r25, -28
-; SPE-NEXT:    .cfi_offset r26, -24
-; SPE-NEXT:    .cfi_offset r27, -20
-; SPE-NEXT:    .cfi_offset r28, -16
-; SPE-NEXT:    .cfi_offset r29, -12
-; SPE-NEXT:    .cfi_offset r30, -8
-; SPE-NEXT:    .cfi_offset r21, -136
-; SPE-NEXT:    .cfi_offset r22, -128
-; SPE-NEXT:    .cfi_offset r23, -120
-; SPE-NEXT:    .cfi_offset r24, -112
-; SPE-NEXT:    .cfi_offset r25, -104
-; SPE-NEXT:    .cfi_offset r26, -96
-; SPE-NEXT:    .cfi_offset r27, -88
-; SPE-NEXT:    .cfi_offset r28, -80
-; SPE-NEXT:    .cfi_offset r29, -72
-; SPE-NEXT:    .cfi_offset r30, -64
-; SPE-NEXT:    stw r25, 116(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r26, 120(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r27, 124(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r28, 128(r1) # 4-byte Folded Spill
+; SPE-NEXT:    .cfi_offset r21, -88
+; SPE-NEXT:    .cfi_offset r22, -80
+; SPE-NEXT:    .cfi_offset r23, -72
+; SPE-NEXT:    .cfi_offset r24, -64
+; SPE-NEXT:    .cfi_offset r25, -56
+; SPE-NEXT:    .cfi_offset r26, -48
+; SPE-NEXT:    .cfi_offset r27, -40
+; SPE-NEXT:    .cfi_offset r28, -32
+; SPE-NEXT:    .cfi_offset r29, -24
+; SPE-NEXT:    .cfi_offset r30, -16
 ; SPE-NEXT:    evstdd r25, 40(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r25, r3
 ; SPE-NEXT:    evstdd r26, 48(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r26, r4
 ; SPE-NEXT:    evstdd r27, 56(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r27, r5
 ; SPE-NEXT:    evstdd r28, 64(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r28, r7
-; SPE-NEXT:    lwz r3, 160(r1)
-; SPE-NEXT:    lwz r4, 152(r1)
-; SPE-NEXT:    lwz r5, 156(r1)
-; SPE-NEXT:    lwz r7, 164(r1)
-; SPE-NEXT:    stw r22, 104(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r23, 108(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r24, 112(r1) # 4-byte Folded Spill
+; SPE-NEXT:    lwz r3, 112(r1)
+; SPE-NEXT:    lwz r4, 104(r1)
+; SPE-NEXT:    lwz r5, 108(r1)
+; SPE-NEXT:    lwz r7, 116(r1)
 ; SPE-NEXT:    evstdd r22, 16(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    efsneg r22, r3
 ; SPE-NEXT:    evstdd r23, 24(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    efsneg r23, r5
 ; SPE-NEXT:    evstdd r24, 32(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    efsneg r24, r4
 ; SPE-NEXT:    efsneg r5, r7
 ; SPE-NEXT:    mr r3, r6
 ; SPE-NEXT:    mr r4, r10
-; SPE-NEXT:    stw r21, 100(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r29, 132(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r30, 136(r1) # 4-byte Folded Spill
 ; SPE-NEXT:    evstdd r21, 8(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r29, 72(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r29, r8
 ; SPE-NEXT:    evstdd r30, 80(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r30, r9
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    mr r21, r3
 ; SPE-NEXT:    mr r3, r27
 ; SPE-NEXT:    mr r4, r30
 ; SPE-NEXT:    mr r5, r22
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    mr r30, r3
 ; SPE-NEXT:    mr r3, r26
 ; SPE-NEXT:    mr r4, r29
 ; SPE-NEXT:    mr r5, r23
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    mr r29, r3
 ; SPE-NEXT:    mr r3, r25
 ; SPE-NEXT:    mr r4, r28
 ; SPE-NEXT:    mr r5, r24
 ; SPE-NEXT:    bl fmaf
 ; SPE-NEXT:    efsneg r4, r29
 ; SPE-NEXT:    efsneg r5, r30
+; SPE-NEXT:    efsneg r3, r3
 ; SPE-NEXT:    efsneg r6, r21
 ; SPE-NEXT:    evldd r30, 80(r1) # 8-byte Folded Reload
-; SPE-NEXT:    efsneg r3, r3
 ; SPE-NEXT:    evldd r29, 72(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r28, 64(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r27, 56(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r26, 48(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r25, 40(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r24, 32(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r23, 24(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r22, 16(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r21, 8(r1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz r30, 136(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r29, 132(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r28, 128(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r27, 124(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r26, 120(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r25, 116(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r24, 112(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r23, 108(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r22, 104(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r21, 100(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r0, 148(r1)
-; SPE-NEXT:    addi r1, r1, 144
+; SPE-NEXT:    lwz r0, 100(r1)
+; SPE-NEXT:    addi r1, r1, 96
 ; SPE-NEXT:    mtlr r0
 ; SPE-NEXT:    blr
   %neg = fneg <4 x float> %vf2
   %fma = call <4 x float> @llvm.experimental.constrained.fma.v4f32(
                         <4 x float> %vf0, <4 x float> %vf1, <4 x float> %neg,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   %res = fneg <4 x float> %fma

 ; NOVSX-NEXT:    fnmsub f2, f2, f4, f6
 ; NOVSX-NEXT:    fnmsub f1, f1, f3, f5
 ; NOVSX-NEXT:    blr
 ;
 ; SPE-LABEL: fnmsub_v2f64:
 ; SPE:       # %bb.0:
 ; SPE-NEXT:    mflr r0
 ; SPE-NEXT:    stw r0, 4(r1)
-; SPE-NEXT:    stwu r1, -96(r1)
-; SPE-NEXT:    .cfi_def_cfa_offset 96
+; SPE-NEXT:    stwu r1, -64(r1)
+; SPE-NEXT:    .cfi_def_cfa_offset 64
 ; SPE-NEXT:    .cfi_offset lr, 4
-; SPE-NEXT:    .cfi_offset r26, -24
-; SPE-NEXT:    .cfi_offset r27, -20
-; SPE-NEXT:    .cfi_offset r28, -16
-; SPE-NEXT:    .cfi_offset r29, -12
-; SPE-NEXT:    .cfi_offset r30, -8
-; SPE-NEXT:    .cfi_offset r26, -80
-; SPE-NEXT:    .cfi_offset r27, -72
-; SPE-NEXT:    .cfi_offset r28, -64
-; SPE-NEXT:    .cfi_offset r29, -56
-; SPE-NEXT:    .cfi_offset r30, -48
-; SPE-NEXT:    stw r30, 88(r1) # 4-byte Folded Spill
+; SPE-NEXT:    .cfi_offset r26, -48
+; SPE-NEXT:    .cfi_offset r27, -40
+; SPE-NEXT:    .cfi_offset r28, -32
+; SPE-NEXT:    .cfi_offset r29, -24
+; SPE-NEXT:    .cfi_offset r30, -16
 ; SPE-NEXT:    evstdd r30, 48(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r30, r3
-; SPE-NEXT:    evldd r3, 112(r1)
-; SPE-NEXT:    evldd r11, 120(r1)
-; SPE-NEXT:    stw r26, 72(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r27, 76(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r28, 80(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r29, 84(r1) # 4-byte Folded Spill
+; SPE-NEXT:    evldd r3, 80(r1)
+; SPE-NEXT:    evldd r11, 88(r1)
 ; SPE-NEXT:    evstdd r26, 16(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r27, 24(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    efdneg r27, r11
 ; SPE-NEXT:    evstdd r28, 32(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r29, 40(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evmergelo r29, r7, r8
 ; SPE-NEXT:    evmergelo r9, r9, r10
 ; SPE-NEXT:    evmergelo r4, r5, r6
 ; SPE-NEXT:    efdneg r8, r3
 ; SPE-NEXT:    evmergehi r3, r4, r4
 ; SPE-NEXT:    evmergehi r5, r9, r9
 ; SPE-NEXT:    evmergehi r7, r8, r8
 ; SPE-NEXT:    mr r6, r9
-; SPE-NEXT:    evldd r28, 104(r1)
+; SPE-NEXT:    evldd r28, 72(r1)
 ; SPE-NEXT:    # kill: def $r3 killed $r3 killed $s3
 ; SPE-NEXT:    # kill: def $r4 killed $r4 killed $s4
 ; SPE-NEXT:    # kill: def $r5 killed $r5 killed $s5
 ; SPE-NEXT:    # kill: def $r7 killed $r7 killed $s7
 ; SPE-NEXT:    # kill: def $r8 killed $r8 killed $s8
 ; SPE-NEXT:    bl fma
 ; SPE-NEXT:    evmergelo r26, r3, r4
 ; SPE-NEXT:    evmergehi r3, r29, r29

 ; SPE-NEXT:    evstddx r3, r30, r5
 ; SPE-NEXT:    efdneg r3, r26
 ; SPE-NEXT:    evstdd r3, 0(r30)
 ; SPE-NEXT:    evldd r30, 48(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r29, 40(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r28, 32(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r27, 24(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r26, 16(r1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz r30, 88(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r29, 84(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r28, 80(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r27, 76(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r26, 72(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r0, 100(r1)
-; SPE-NEXT:    addi r1, r1, 96
+; SPE-NEXT:    lwz r0, 68(r1)
+; SPE-NEXT:    addi r1, r1, 64
 ; SPE-NEXT:    mtlr r0
 ; SPE-NEXT:    blr
   %neg = fneg <2 x double> %vf2
   %fma = call <2 x double> @llvm.experimental.constrained.fma.v2f64(
                         <2 x double> %vf0, <2 x double> %vf1, <2 x double> %neg,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   %res = fneg <2 x double> %fma

 ; NOVSX-NEXT:    stfs f0, -16(r1)
 ; NOVSX-NEXT:    lvx v2, 0, r3
 ; NOVSX-NEXT:    blr
 ;
 ; SPE-LABEL: fsqrt_v4f32:
 ; SPE:       # %bb.0:
 ; SPE-NEXT:    mflr r0
 ; SPE-NEXT:    stw r0, 4(r1)
-; SPE-NEXT:    stwu r1, -80(r1)
-; SPE-NEXT:    .cfi_def_cfa_offset 80
+; SPE-NEXT:    stwu r1, -48(r1)
+; SPE-NEXT:    .cfi_def_cfa_offset 48
 ; SPE-NEXT:    .cfi_offset lr, 4
-; SPE-NEXT:    .cfi_offset r27, -20
-; SPE-NEXT:    .cfi_offset r28, -16
-; SPE-NEXT:    .cfi_offset r29, -12
-; SPE-NEXT:    .cfi_offset r30, -8
-; SPE-NEXT:    .cfi_offset r27, -72
-; SPE-NEXT:    .cfi_offset r28, -64
-; SPE-NEXT:    .cfi_offset r29, -56
-; SPE-NEXT:    .cfi_offset r30, -48
-; SPE-NEXT:    stw r28, 64(r1) # 4-byte Folded Spill
+; SPE-NEXT:    .cfi_offset r27, -40
+; SPE-NEXT:    .cfi_offset r28, -32
+; SPE-NEXT:    .cfi_offset r29, -24
+; SPE-NEXT:    .cfi_offset r30, -16
 ; SPE-NEXT:    evstdd r28, 16(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r28, r3
 ; SPE-NEXT:    mr r3, r6
-; SPE-NEXT:    stw r27, 60(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r29, 68(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r30, 72(r1) # 4-byte Folded Spill
 ; SPE-NEXT:    evstdd r27, 8(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r29, 24(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r29, r4
 ; SPE-NEXT:    evstdd r30, 32(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    mr r30, r5
 ; SPE-NEXT:    bl sqrtf
 ; SPE-NEXT:    mr r27, r3
 ; SPE-NEXT:    mr r3, r30
 ; SPE-NEXT:    bl sqrtf
 ; SPE-NEXT:    mr r30, r3
 ; SPE-NEXT:    mr r3, r29
 ; SPE-NEXT:    bl sqrtf
 ; SPE-NEXT:    mr r29, r3
 ; SPE-NEXT:    mr r3, r28
 ; SPE-NEXT:    bl sqrtf
 ; SPE-NEXT:    mr r4, r29
 ; SPE-NEXT:    mr r5, r30
 ; SPE-NEXT:    mr r6, r27
 ; SPE-NEXT:    evldd r30, 32(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r29, 24(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r28, 16(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r27, 8(r1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz r30, 72(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r29, 68(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r28, 64(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r27, 60(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r0, 84(r1)
-; SPE-NEXT:    addi r1, r1, 80
+; SPE-NEXT:    lwz r0, 52(r1)
+; SPE-NEXT:    addi r1, r1, 48
 ; SPE-NEXT:    mtlr r0
 ; SPE-NEXT:    blr
   %res = call <4 x float> @llvm.experimental.constrained.sqrt.v4f32(
                         <4 x float> %vf1,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <4 x float> %res
 }

 ; NOVSX-NEXT:    fsqrt f2, f2
 ; NOVSX-NEXT:    fsqrt f1, f1
 ; NOVSX-NEXT:    blr
 ;
 ; SPE-LABEL: fsqrt_v2f64:
 ; SPE:       # %bb.0:
 ; SPE-NEXT:    mflr r0
 ; SPE-NEXT:    stw r0, 4(r1)
-; SPE-NEXT:    stwu r1, -64(r1)
-; SPE-NEXT:    .cfi_def_cfa_offset 64
+; SPE-NEXT:    stwu r1, -48(r1)
+; SPE-NEXT:    .cfi_def_cfa_offset 48
 ; SPE-NEXT:    .cfi_offset lr, 4
-; SPE-NEXT:    .cfi_offset r28, -16
-; SPE-NEXT:    .cfi_offset r29, -12
-; SPE-NEXT:    .cfi_offset r30, -8
-; SPE-NEXT:    .cfi_offset r28, -48
-; SPE-NEXT:    .cfi_offset r29, -40
-; SPE-NEXT:    .cfi_offset r30, -32
-; SPE-NEXT:    stw r28, 48(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r29, 52(r1) # 4-byte Folded Spill
-; SPE-NEXT:    stw r30, 56(r1) # 4-byte Folded Spill
+; SPE-NEXT:    .cfi_offset r28, -32
+; SPE-NEXT:    .cfi_offset r29, -24
+; SPE-NEXT:    .cfi_offset r30, -16
 ; SPE-NEXT:    evstdd r28, 16(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r29, 24(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd r30, 32(r1) # 8-byte Folded Spill
 ; SPE-NEXT:    evmergelo r29, r7, r8
 ; SPE-NEXT:    evmergelo r4, r5, r6
 ; SPE-NEXT:    mr r30, r3
 ; SPE-NEXT:    evmergehi r3, r4, r4
 ; SPE-NEXT:    # kill: def $r4 killed $r4 killed $s4
 ; SPE-NEXT:    # kill: def $r3 killed $r3 killed $s3
 ; SPE-NEXT:    bl sqrt
 ; SPE-NEXT:    evmergelo r28, r3, r4
 ; SPE-NEXT:    evmergehi r3, r29, r29
 ; SPE-NEXT:    mr r4, r29
 ; SPE-NEXT:    # kill: def $r3 killed $r3 killed $s3
 ; SPE-NEXT:    bl sqrt
 ; SPE-NEXT:    li r5, 8
 ; SPE-NEXT:    evmergelo r3, r3, r4
 ; SPE-NEXT:    evstddx r3, r30, r5
 ; SPE-NEXT:    evstdd r28, 0(r30)
 ; SPE-NEXT:    evldd r30, 32(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r29, 24(r1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd r28, 16(r1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz r30, 56(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r29, 52(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r28, 48(r1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz r0, 68(r1)
-; SPE-NEXT:    addi r1, r1, 64
+; SPE-NEXT:    lwz r0, 52(r1)
+; SPE-NEXT:    addi r1, r1, 48
 ; SPE-NEXT:    mtlr r0
 ; SPE-NEXT:    blr
   %res = call <2 x double> @llvm.experimental.constrained.sqrt.v2f64(
                         <2 x double> %vf1,
                         metadata !"round.dynamic",
                         metadata !"fpexcept.strict") #0
   ret <2 x double> %res
 }
 
 attributes #0 = { strictfp }

llvm/test/CodeGen/PowerPC/spe.ll

 ; SPE-NEXT:    lwz 3, 12(1)
 ; SPE-NEXT:    addi 1, 1, 16
 ; SPE-NEXT:    blr
 ;
 ; EFPU2-LABEL: test_dcmpueq:
 ; EFPU2:       # %bb.0: # %entry
 ; EFPU2-NEXT:    mflr 0
 ; EFPU2-NEXT:    stw 0, 4(1)
-; EFPU2-NEXT:    stwu 1, -96(1)
+; EFPU2-NEXT:    stwu 1, -80(1)
 ; EFPU2-NEXT:    mfcr 12
-; EFPU2-NEXT:    stw 27, 76(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 28, 80(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 29, 84(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 30, 88(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 12, 72(1)
+; EFPU2-NEXT:    stw 12, 76(1)
 ; EFPU2-NEXT:    evstdd 27, 24(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    mr 27, 3
 ; EFPU2-NEXT:    evstdd 28, 32(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    mr 28, 4
 ; EFPU2-NEXT:    evstdd 29, 40(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    mr 29, 5
 ; EFPU2-NEXT:    evstdd 30, 48(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    mr 30, 6

 ; EFPU2-NEXT:  .LBB42_3: # %tr
 ; EFPU2-NEXT:    li 3, 1
 ; EFPU2-NEXT:  .LBB42_4: # %ret
 ; EFPU2-NEXT:    stw 3, 20(1)
 ; EFPU2-NEXT:    lwz 3, 20(1)
 ; EFPU2-NEXT:    evldd 30, 48(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    evldd 29, 40(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    evldd 28, 32(1) # 8-byte Folded Reload
-; EFPU2-NEXT:    lwz 12, 72(1)
+; EFPU2-NEXT:    lwz 12, 76(1)
 ; EFPU2-NEXT:    evldd 27, 24(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    mtcrf 32, 12 # cr2
-; EFPU2-NEXT:    lwz 30, 88(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 29, 84(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 28, 80(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 27, 76(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 0, 100(1)
-; EFPU2-NEXT:    addi 1, 1, 96
+; EFPU2-NEXT:    lwz 0, 84(1)
+; EFPU2-NEXT:    addi 1, 1, 80
 ; EFPU2-NEXT:    mtlr 0
 ; EFPU2-NEXT:    blr
   entry:
   %r = alloca i32, align 4
   %c = fcmp ueq double %a, %b
   br i1 %c, label %tr, label %fa
 tr:
   store i32 1, i32* %r, align 4

 ; SPE-NEXT:  .LBB43_2: # %entry
 ; SPE-NEXT:    li 3, 0
 ; SPE-NEXT:    blr
 ;
 ; EFPU2-LABEL: test_dcmpne:
 ; EFPU2:       # %bb.0: # %entry
 ; EFPU2-NEXT:    mflr 0
 ; EFPU2-NEXT:    stw 0, 4(1)
-; EFPU2-NEXT:    stwu 1, -96(1)
+; EFPU2-NEXT:    stwu 1, -80(1)
 ; EFPU2-NEXT:    mfcr 12
-; EFPU2-NEXT:    stw 27, 76(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 28, 80(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 29, 84(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 30, 88(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 12, 72(1)
+; EFPU2-NEXT:    stw 12, 76(1)
 ; EFPU2-NEXT:    evstdd 27, 24(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    mr 27, 3
 ; EFPU2-NEXT:    evstdd 28, 32(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    mr 28, 4
 ; EFPU2-NEXT:    evstdd 29, 40(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    mr 29, 5
 ; EFPU2-NEXT:    evstdd 30, 48(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    mr 30, 6
 ; EFPU2-NEXT:    bl __unorddf2
 ; EFPU2-NEXT:    cmpwi 2, 3, 0
 ; EFPU2-NEXT:    mr 3, 27
 ; EFPU2-NEXT:    mr 4, 28
 ; EFPU2-NEXT:    mr 5, 29
 ; EFPU2-NEXT:    mr 6, 30
 ; EFPU2-NEXT:    bl __eqdf2
 ; EFPU2-NEXT:    evldd 30, 48(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    cmpwi 3, 0
 ; EFPU2-NEXT:    evldd 29, 40(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    li 4, 1
 ; EFPU2-NEXT:    evldd 28, 32(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    crorc 20, 2, 10
-; EFPU2-NEXT:    lwz 12, 72(1)
+; EFPU2-NEXT:    lwz 12, 76(1)
 ; EFPU2-NEXT:    bc 12, 20, .LBB43_2
 ; EFPU2-NEXT:  # %bb.1: # %entry
 ; EFPU2-NEXT:    ori 3, 4, 0
 ; EFPU2-NEXT:    b .LBB43_3
 ; EFPU2-NEXT:  .LBB43_2: # %entry
 ; EFPU2-NEXT:    li 3, 0
 ; EFPU2-NEXT:  .LBB43_3: # %entry
 ; EFPU2-NEXT:    evldd 27, 24(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    mtcrf 32, 12 # cr2
-; EFPU2-NEXT:    lwz 30, 88(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 29, 84(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 28, 80(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 27, 76(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 0, 100(1)
-; EFPU2-NEXT:    addi 1, 1, 96
+; EFPU2-NEXT:    lwz 0, 84(1)
+; EFPU2-NEXT:    addi 1, 1, 80
 ; EFPU2-NEXT:    mtlr 0
 ; EFPU2-NEXT:    blr
   entry:
   %r = fcmp one double %a, %b
   ret i1 %r
 }
 
 define i32 @test_dcmpune(double %a, double %b) #0 {

 
 declare void @test_memset(i8* nocapture writeonly, i8, i32, i1)
 @global_var1 = global i32 0, align 4
 define double @test_spill(double %a, i32 %a1, i64 %a2, i8 * %a3, i32 *%a4, i32* %a5) #0 {
 ; SPE-LABEL: test_spill:
 ; SPE:       # %bb.0: # %entry
 ; SPE-NEXT:    mflr 0
 ; SPE-NEXT:    stw 0, 4(1)
-; SPE-NEXT:    stwu 1, -352(1)
+; SPE-NEXT:    stwu 1, -272(1)
 ; SPE-NEXT:    li 5, 256
 ; SPE-NEXT:    evstddx 30, 1, 5 # 8-byte Folded Spill
 ; SPE-NEXT:    li 5, 264
 ; SPE-NEXT:    evstddx 31, 1, 5 # 8-byte Folded Spill
 ; SPE-NEXT:    li 5, .LCPI55_0@l
 ; SPE-NEXT:    lis 6, .LCPI55_0@ha
 ; SPE-NEXT:    evlddx 5, 6, 5
-; SPE-NEXT:    stw 14, 280(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 15, 284(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 16, 288(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 17, 292(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 18, 296(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 19, 300(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 20, 304(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 21, 308(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 22, 312(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 23, 316(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 24, 320(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 25, 324(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 26, 328(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 27, 332(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 28, 336(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 29, 340(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 30, 344(1) # 4-byte Folded Spill
-; SPE-NEXT:    stw 31, 348(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:    evstdd 17, 152(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 18, 160(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 19, 168(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 20, 176(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 21, 184(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 22, 192(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 23, 200(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 24, 208(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 25, 216(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 26, 224(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 27, 232(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 28, 240(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evstdd 29, 248(1) # 8-byte Folded Spill
 ; SPE-NEXT:    evmergelo 3, 3, 4
-; SPE-NEXT:    lwz 4, 360(1)
+; SPE-NEXT:    lwz 4, 280(1)
 ; SPE-NEXT:    efdadd 3, 3, 3
 ; SPE-NEXT:    efdadd 3, 3, 5
 ; SPE-NEXT:    evstdd 3, 24(1) # 8-byte Folded Spill
 ; SPE-NEXT:    stw 4, 20(1) # 4-byte Folded Spill
 ; SPE-NEXT:    #APP
 ; SPE-NEXT:    #NO_APP
 ; SPE-NEXT:    addi 3, 1, 76
 ; SPE-NEXT:    li 4, 0

 ; SPE-NEXT:    li 5, 20
 ; SPE-NEXT:    li 6, 1
 ; SPE-NEXT:    bl test_memset
 ; SPE-NEXT:    evldd 4, 24(1) # 8-byte Folded Reload
 ; SPE-NEXT:    li 5, 264
 ; SPE-NEXT:    evmergehi 3, 4, 4
 ; SPE-NEXT:    evlddx 31, 1, 5 # 8-byte Folded Reload
 ; SPE-NEXT:    li 5, 256
-; SPE-NEXT:    evlddx 30, 1, 5 # 8-byte Folded Reload
 ; SPE-NEXT:    # kill: def $r3 killed $r3 killed $s3
 ; SPE-NEXT:    # kill: def $r4 killed $r4 killed $s4
+; SPE-NEXT:    evlddx 30, 1, 5 # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 29, 248(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 28, 240(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 27, 232(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 26, 224(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 25, 216(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 24, 208(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 23, 200(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 22, 192(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 21, 184(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 20, 176(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 19, 168(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 18, 160(1) # 8-byte Folded Reload
 ; SPE-NEXT:    evldd 17, 152(1) # 8-byte Folded Reload
 ; 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, 348(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 30, 344(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 29, 340(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 28, 336(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 27, 332(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 26, 328(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 25, 324(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 24, 320(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 23, 316(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 22, 312(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 21, 308(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 20, 304(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 19, 300(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 18, 296(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 17, 292(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 16, 288(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 15, 284(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 14, 280(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 0, 356(1)
-; SPE-NEXT:    addi 1, 1, 352
+; SPE-NEXT:    lwz 0, 276(1)
+; SPE-NEXT:    addi 1, 1, 272
 ; SPE-NEXT:    mtlr 0
 ; SPE-NEXT:    blr
 ;
 ; EFPU2-LABEL: test_spill:
 ; EFPU2:       # %bb.0: # %entry
 ; EFPU2-NEXT:    mflr 0
 ; EFPU2-NEXT:    stw 0, 4(1)
-; EFPU2-NEXT:    stwu 1, -176(1)
+; EFPU2-NEXT:    stwu 1, -144(1)
 ; EFPU2-NEXT:    mr 5, 3
 ; EFPU2-NEXT:    mr 6, 4
-; EFPU2-NEXT:    stw 27, 156(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 28, 160(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 29, 164(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 30, 168(1) # 4-byte Folded Spill
 ; 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
 ; EFPU2-NEXT:    evstdd 30, 128(1) # 8-byte Folded Spill
-; EFPU2-NEXT:    lwz 28, 184(1)
+; EFPU2-NEXT:    lwz 28, 152(1)
 ; EFPU2-NEXT:    bl __adddf3
 ; EFPU2-NEXT:    lis 5, 16393
 ; EFPU2-NEXT:    lis 6, -4069
 ; EFPU2-NEXT:    ori 5, 5, 8697
 ; EFPU2-NEXT:    ori 6, 6, 34414
 ; EFPU2-NEXT:    #APP
 ; EFPU2-NEXT:    #NO_APP
 ; EFPU2-NEXT:    bl __adddf3

 ; EFPU2-NEXT:    li 6, 1
 ; EFPU2-NEXT:    bl test_memset
 ; EFPU2-NEXT:    mr 3, 30
 ; EFPU2-NEXT:    mr 4, 29
 ; EFPU2-NEXT:    evldd 30, 128(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    evldd 29, 120(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    evldd 28, 112(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    evldd 27, 104(1) # 8-byte Folded Reload
-; EFPU2-NEXT:    lwz 30, 168(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 29, 164(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 28, 160(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 27, 156(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 0, 180(1)
-; EFPU2-NEXT:    addi 1, 1, 176
+; EFPU2-NEXT:    lwz 0, 148(1)
+; EFPU2-NEXT:    addi 1, 1, 144
 ; EFPU2-NEXT:    mtlr 0
 ; EFPU2-NEXT:    blr
 entry:
   %v1 = alloca [13 x i32], align 4
   %v2 = alloca [11 x i32], align 4
   %0 = fadd double %a, %a
   call void asm sideeffect "","~{s0},~{s3},~{s4},~{s5},~{s6},~{s7},~{s8},~{s9},~{s10},~{s11},~{s12},~{s13},~{s14},~{s15},~{s16},~{s17},~{s18},~{s19},~{s20},~{s21},~{s22},~{s23},~{s24},~{s25},~{s26},~{s27},~{s28},~{s29},~{s30},~{s31}"() nounwind
   %1 = fadd double %0, 3.14159

 
 }
 
 define dso_local float @test_fma(i32 %d) local_unnamed_addr #0 {
 ; CHECK-LABEL: test_fma:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    mflr 0
 ; CHECK-NEXT:    stw 0, 4(1)
-; CHECK-NEXT:    stwu 1, -48(1)
+; CHECK-NEXT:    stwu 1, -32(1)
 ; CHECK-NEXT:    cmpwi 3, 1
-; CHECK-NEXT:    stw 29, 36(1) # 4-byte Folded Spill
-; CHECK-NEXT:    stw 30, 40(1) # 4-byte Folded Spill
 ; CHECK-NEXT:    evstdd 29, 8(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    evstdd 30, 16(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    blt 0, .LBB56_3
 ; CHECK-NEXT:  # %bb.1: # %for.body.preheader
 ; CHECK-NEXT:    mr 30, 3
 ; CHECK-NEXT:    li 29, 0
 ; CHECK-NEXT:    # implicit-def: $r5
 ; CHECK-NEXT:  .LBB56_2: # %for.body
 ; CHECK-NEXT:    #
 ; CHECK-NEXT:    efscfsi 3, 29
 ; CHECK-NEXT:    mr 4, 3
 ; CHECK-NEXT:    bl fmaf
 ; CHECK-NEXT:    addi 29, 29, 1
 ; CHECK-NEXT:    cmplw 30, 29
 ; CHECK-NEXT:    mr 5, 3
 ; CHECK-NEXT:    bne 0, .LBB56_2
 ; CHECK-NEXT:    b .LBB56_4
 ; CHECK-NEXT:  .LBB56_3:
 ; CHECK-NEXT:    # implicit-def: $r5
 ; CHECK-NEXT:  .LBB56_4: # %for.cond.cleanup
-; CHECK-NEXT:    evldd 30, 16(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    mr 3, 5
+; CHECK-NEXT:    evldd 30, 16(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    evldd 29, 8(1) # 8-byte Folded Reload
-; CHECK-NEXT:    lwz 30, 40(1) # 4-byte Folded Reload
-; CHECK-NEXT:    lwz 29, 36(1) # 4-byte Folded Reload
-; CHECK-NEXT:    lwz 0, 52(1)
-; CHECK-NEXT:    addi 1, 1, 48
+; CHECK-NEXT:    lwz 0, 36(1)
+; CHECK-NEXT:    addi 1, 1, 32
 ; CHECK-NEXT:    mtlr 0
 ; CHECK-NEXT:    blr
 entry:
   %cmp8 = icmp sgt i32 %d, 0
   br i1 %cmp8, label %for.body, label %for.cond.cleanup
 
 for.cond.cleanup:                                 ; preds = %for.body, %entry
   %e.0.lcssa = phi float [ undef, %entry ], [ %0, %for.body ]

 
 declare i32 @foo(double)
 
 define void @d(%struct.a* %e, %struct.a* %f) #0 {
 ; SPE-LABEL: d:
 ; SPE:       # %bb.0: # %entry
 ; SPE-NEXT:    mflr 0
 ; SPE-NEXT:    stw 0, 4(1)
-; SPE-NEXT:    stwu 1, -64(1)
+; SPE-NEXT:    stwu 1, -48(1)
 ; SPE-NEXT:    lwz 4, 0(4)
 ; SPE-NEXT:    lwz 3, 0(3)
-; SPE-NEXT:    stw 29, 52(1) # 4-byte Folded Spill
 ; SPE-NEXT:    evstdd 29, 24(1) # 8-byte Folded Spill
 ; SPE-NEXT:    efdcfs 29, 4
-; SPE-NEXT:    stw 28, 48(1) # 4-byte Folded Spill
-; SPE-NEXT:    mr 4, 29
-; SPE-NEXT:    stw 30, 56(1) # 4-byte Folded Spill
 ; SPE-NEXT:    evstdd 28, 16(1) # 8-byte Folded Spill
+; SPE-NEXT:    mr 4, 29
 ; SPE-NEXT:    evstdd 30, 32(1) # 8-byte Folded Spill
 ; SPE-NEXT:    efdcfs 30, 3
 ; SPE-NEXT:    evmergehi 3, 29, 29
 ; SPE-NEXT:    # kill: def $r3 killed $r3 killed $s3
 ; SPE-NEXT:    bl foo
 ; SPE-NEXT:    mr 28, 3
 ; SPE-NEXT:    evmergehi 3, 30, 30
 ; SPE-NEXT:    mr 4, 30
 ; SPE-NEXT:    # kill: def $r3 killed $r3 killed $s3
 ; SPE-NEXT:    bl foo
 ; SPE-NEXT:    efdcfsi 3, 28
 ; SPE-NEXT:    evldd 30, 32(1) # 8-byte Folded Reload
 ; SPE-NEXT:    efdmul 3, 29, 3
 ; SPE-NEXT:    efscfd 3, 3
 ; SPE-NEXT:    evldd 29, 24(1) # 8-byte Folded Reload
 ; SPE-NEXT:    stw 3, 0(3)
 ; SPE-NEXT:    evldd 28, 16(1) # 8-byte Folded Reload
-; SPE-NEXT:    lwz 30, 56(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 29, 52(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 28, 48(1) # 4-byte Folded Reload
-; SPE-NEXT:    lwz 0, 68(1)
-; SPE-NEXT:    addi 1, 1, 64
+; SPE-NEXT:    lwz 0, 52(1)
+; SPE-NEXT:    addi 1, 1, 48
 ; SPE-NEXT:    mtlr 0
 ; SPE-NEXT:    blr
 ;
 ; EFPU2-LABEL: d:
 ; EFPU2:       # %bb.0: # %entry
 ; EFPU2-NEXT:    mflr 0
 ; EFPU2-NEXT:    stw 0, 4(1)
-; EFPU2-NEXT:    stwu 1, -96(1)
+; EFPU2-NEXT:    stwu 1, -64(1)
 ; EFPU2-NEXT:    lwz 3, 0(3)
-; EFPU2-NEXT:    stw 26, 72(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 27, 76(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 28, 80(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 29, 84(1) # 4-byte Folded Spill
-; EFPU2-NEXT:    stw 30, 88(1) # 4-byte Folded Spill
 ; EFPU2-NEXT:    evstdd 26, 16(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    evstdd 27, 24(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    evstdd 28, 32(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    evstdd 29, 40(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    evstdd 30, 48(1) # 8-byte Folded Spill
 ; EFPU2-NEXT:    mr 30, 4
 ; EFPU2-NEXT:    bl __extendsfdf2
 ; EFPU2-NEXT:    mr 28, 3

 ; EFPU2-NEXT:    bl __muldf3
 ; EFPU2-NEXT:    bl __truncdfsf2
 ; EFPU2-NEXT:    stw 3, 0(3)
 ; EFPU2-NEXT:    evldd 30, 48(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    evldd 29, 40(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    evldd 28, 32(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    evldd 27, 24(1) # 8-byte Folded Reload
 ; EFPU2-NEXT:    evldd 26, 16(1) # 8-byte Folded Reload
-; EFPU2-NEXT:    lwz 30, 88(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 29, 84(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 28, 80(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 27, 76(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 26, 72(1) # 4-byte Folded Reload
-; EFPU2-NEXT:    lwz 0, 100(1)
-; EFPU2-NEXT:    addi 1, 1, 96
+; EFPU2-NEXT:    lwz 0, 68(1)
+; EFPU2-NEXT:    addi 1, 1, 64
 ; EFPU2-NEXT:    mtlr 0
 ; EFPU2-NEXT:    blr
 entry:
   %0 = getelementptr %struct.a, %struct.a* %f, i32 0, i32 0
   %1 = load float, float* undef
   %conv = fpext float %1 to double
   %2 = load float, float* %0
   %g = fpext float %2 to double