[PowerPC] Add support for ROP protection for 32 bit.

[stefanp]

Summary

Add support for Return Oriented Programming (ROP) protection for 32 bit.
This patch also adds a testing for AIX on both 64 and 32 bit.

[stefanp]

Updated spacing.

[amyk]

llvm/lib/Target/PowerPC/PPCInstrInfo.td

5548

Just wanted to double check that isCodeGenOnly is intended for these, right?
I don't have a strong opinion either way but since they're not on the 64-bit version and since hasSideEffects is documented, it may not hurt to document why isCodeGenOnly is added here.

llvm/test/CodeGen/PowerPC/ppc64-rop-protection-aix.ll

278

Would it be helpful to add a TODO to remove this comment when the next ABI revision is released?

[stefanp]

llvm/lib/Target/PowerPC/PPCInstrInfo.td

5548

Sure. I can add that.
The idea is that we don't want the llvm to get confused between HASHCHK and HASHCHK8 because they are both encoded the same way. I'll add a comment with an explanation.

llvm/test/CodeGen/PowerPC/ppc64-rop-protection-aix.ll

278

Sure. That's a good idea. I will add that.

[nemanjai]

llvm/lib/Target/PowerPC/PPCInstrInfo.td

5548

I think Amy's question is why this one parts with the convention to make the 32-bit versions the real instructions and the 64-bit version the isCodeGenOnly instruction (along with being marked with Interpretation64Bit). And I think the question is perfectly reasonable.

[stefanp]

llvm/lib/Target/PowerPC/PPCInstrInfo.td

5548

Oh I see what you mean. I'm sorry I think I misunderstood initially. There is no reason why I did it this way. I will switch the flags so that the isCodeGenOnly flag is on the 64 bit version.

[stefanp]

Added a TODO to the test file.
Moved the isCodeGenOnly to the 64 bit version.
Added the Interpretation64Bit flag to the 64 bit version.

[amyk]

Thanks for addressing the comments I had Stefan.
Overall this LGTM.

[stefanp]

Rebased the patch to get ready for commit.

[stefanp]

Rebased this patch again as it was not rebased correctly the last time.
Should be ready for commit.

llvm/lib/Target/PowerPC/P10InstrResources.td

def : InstRW<[P10W_DF_13C, P10W_DISP_ANY, P10DF_Read, P10DF_Read, P10DF_Read],
     XSRQPIX,
     XSRQPXP
 )>;
 
 // 2-way crack instructions
 // 13 Cycles Decimal Floating Point operations, and 3 Cycles Store operations, 2 input operands
 def : InstRW<[P10W_DF_13C, P10W_DISP_EVEN, P10W_ST_3C, P10W_DISP_ANY],
       (instrs
-    HASHST,
-    HASHSTP
+    HASHST, HASHST8,
+    HASHSTP, HASHSTP8
 )>;
 
 // 24 Cycles Decimal Floating Point operations, 1 input operands
 def : InstRW<[P10W_DF_24C, P10W_DISP_ANY, P10DF_Read],
       (instrs
     BCDCTSQ_rec
 )>;
 
def : InstRW<[P10W_LD_6C, P10W_DISP_ANY, P10LD_Read, P10LD_Read],
     LXVL,
     LXVLL
 )>;
 
 // 2-way crack instructions
 // 6 Cycles Load operations, and 13 Cycles Decimal Floating Point operations, 2 input operands
 def : InstRW<[P10W_LD_6C, P10W_DISP_EVEN, P10W_DF_13C, P10W_DISP_ANY],
       (instrs
-    HASHCHK,
-    HASHCHKP
+    HASHCHK, HASHCHK8,
+    HASHCHKP, HASHCHKP8
 )>;
 
 // Single crack instructions
 // 6 Cycles Load operations, 0 input operands
 def : InstRW<[P10W_LD_6C, P10W_DISP_EVEN, P10W_DISP_ANY],
       (instrs
     SLBIA
 )>;

llvm/lib/Target/PowerPC/P9InstrResources.td

def : InstRW<[],
   (instregex "L(W|H|B)EPX$"),
   (instregex "ST(W|H|B)EPX$"),
   (instregex "(L|ST)FDEPX$"),
   (instregex "M(T|F)SR(IN)?$"),
   (instregex "M(T|F)DCR$"),
   (instregex "NOP_GT_PWR(6|7)$"),
   (instregex "TLB(IA|IVAX|SX|SX2|SX2D|LD|LI|RE|RE2|WE|WE2)$"),
   (instregex "WRTEE(I)?$"),
-  (instregex "HASH(ST|STP|CHK|CHKP)$"),
+  (instregex "HASH(ST|STP|CHK|CHKP)(8)?$"),
   ATTN,
   CLRBHRB,
   MFBHRBE,
   MBAR,
   MSYNC,
   SLBSYNC,
   SLBFEE_rec,
   NAP,

llvm/lib/Target/PowerPC/PPCFrameLowering.cpp

void PPCFrameLowering::emitPrologue(MachineFunction &MF,
   const MCInstrDesc& SubtractCarryingInst = TII.get(isPPC64 ? PPC::SUBFC8
                                                             : PPC::SUBFC);
   const MCInstrDesc& SubtractImmCarryingInst = TII.get(isPPC64 ? PPC::SUBFIC8
                                                                : PPC::SUBFIC);
   const MCInstrDesc &MoveFromCondRegInst = TII.get(isPPC64 ? PPC::MFCR8
                                                            : PPC::MFCR);
   const MCInstrDesc &StoreWordInst = TII.get(isPPC64 ? PPC::STW8 : PPC::STW);
   const MCInstrDesc &HashST =
-      TII.get(HasPrivileged ? PPC::HASHSTP : PPC::HASHST);
+      TII.get(isPPC64 ? (HasPrivileged ? PPC::HASHSTP8 : PPC::HASHST8)
+                      : (HasPrivileged ? PPC::HASHSTP : PPC::HASHST));
 
   // Regarding this assert: Even though LR is saved in the caller's frame (i.e.,
   // LROffset is positive), that slot is callee-owned. Because PPC32 SVR4 has no
   // Red Zone, an asynchronous event (a form of "callee") could claim a frame &
   // overwrite it, so PPC32 SVR4 must claim at least a minimal frame to save LR.
   assert((isPPC64 || !isSVR4ABI || !(!FrameSize && (MustSaveLR || HasFP))) &&
          "FrameSize must be >0 to save/restore the FP or LR for 32-bit SVR4.");
 
const MCInstrDesc& AddImmInst = TII.get( isPPC64 ? PPC::ADDI8
                                                    : PPC::ADDI );
   const MCInstrDesc& AddInst = TII.get( isPPC64 ? PPC::ADD8
                                                 : PPC::ADD4 );
   const MCInstrDesc& LoadWordInst = TII.get( isPPC64 ? PPC::LWZ8
                                                      : PPC::LWZ);
   const MCInstrDesc& MoveToCRInst = TII.get( isPPC64 ? PPC::MTOCRF8
                                                      : PPC::MTOCRF);
   const MCInstrDesc &HashChk =
-      TII.get(HasPrivileged ? PPC::HASHCHKP : PPC::HASHCHK);
+      TII.get(isPPC64 ? (HasPrivileged ? PPC::HASHCHKP8 : PPC::HASHCHK8)
+                      : (HasPrivileged ? PPC::HASHCHKP : PPC::HASHCHK));
   int64_t LROffset = getReturnSaveOffset();
 
   int64_t FPOffset = 0;
 
   // Using the same bool variable as below to suppress compiler warnings.
   bool SingleScratchReg = findScratchRegister(&MBB, true, false, &ScratchReg,
                                               &TempReg);
   assert(SingleScratchReg &&

llvm/lib/Target/PowerPC/PPCInstr64Bit.td

defm FCTIDUZ : XForm_26r<63, 943, (outs f8rc:$frD), (ins f8rc:$frB),
                         [(set f64:$frD, (PPCany_fctiduz f64:$frB))]>, isPPC64;
 defm FCTIWUZ : XForm_26r<63, 143, (outs f8rc:$frD), (ins f8rc:$frB),
                         "fctiwuz", "$frD, $frB", IIC_FPGeneral,
                         [(set f64:$frD, (PPCany_fctiwuz f64:$frB))]>, isPPC64;
 }
 
 // These instructions store a hash computed from the value of the link register
 // and the value of the stack pointer.
-let mayStore = 1 in {
-def HASHST : XForm_XD6_RA5_RB5<31, 722, (outs),
+let mayStore = 1, Interpretation64Bit = 1, isCodeGenOnly = 1 in {
+def HASHST8 : XForm_XD6_RA5_RB5<31, 722, (outs),
                                 (ins g8rc:$RB, memrihash:$D_RA_XD),
                                 "hashst $RB, $D_RA_XD", IIC_IntGeneral, []>;
-def HASHSTP : XForm_XD6_RA5_RB5<31, 658, (outs),
+def HASHSTP8 : XForm_XD6_RA5_RB5<31, 658, (outs),
                                  (ins g8rc:$RB, memrihash:$D_RA_XD),
                                  "hashstp $RB, $D_RA_XD", IIC_IntGeneral, []>;
 }
 
 // These instructions check a hash computed from the value of the link register
 // and the value of the stack pointer. The hasSideEffects flag is needed as the
 // instruction may TRAP if the hash does not match the hash stored at the
 // specified address.
-let mayLoad = 1, hasSideEffects = 1 in {
-def HASHCHK : XForm_XD6_RA5_RB5<31, 754, (outs),
+let mayLoad = 1, hasSideEffects = 1,
+    Interpretation64Bit = 1, isCodeGenOnly = 1 in {
+def HASHCHK8 : XForm_XD6_RA5_RB5<31, 754, (outs),
                                  (ins g8rc:$RB, memrihash:$D_RA_XD),
                                  "hashchk $RB, $D_RA_XD", IIC_IntGeneral, []>;
-def HASHCHKP : XForm_XD6_RA5_RB5<31, 690, (outs),
+def HASHCHKP8 : XForm_XD6_RA5_RB5<31, 690, (outs),
                                   (ins g8rc:$RB, memrihash:$D_RA_XD),
                                   "hashchkp $RB, $D_RA_XD", IIC_IntGeneral, []>;
 }
 
 let Interpretation64Bit = 1, isCodeGenOnly = 1, hasSideEffects = 1 in
 def ADDEX8 : Z23Form_RTAB5_CY2<31, 170, (outs g8rc:$rT),
                               (ins g8rc:$rA, g8rc:$rB, u2imm:$CY),
                               "addex $rT, $rA, $rB, $CY", IIC_IntGeneral,
                               [(set i64:$rT, (int_ppc_addex i64:$rA, i64:$rB,
                                                             timm:$CY))]>;

llvm/lib/Target/PowerPC/PPCInstrInfo.td

 
 // B3 B2 B1 B0 in the right order
 def DWBytes3210 {
   dag Word = (RLWIMI DWBytes3212.Word, DWBytes0123.Word, 8, 24, 31);
   dag DWord =
     (i64 (INSERT_SUBREG (i64 (IMPLICIT_DEF)), Word, sub_32));
 }
 
+// These instructions store a hash computed from the value of the link register
+// and the value of the stack pointer.
+let mayStore = 1 in {
+def HASHST : XForm_XD6_RA5_RB5<31, 722, (outs),
+                               (ins gprc:$RB, memrihash:$D_RA_XD),
+                               "hashst $RB, $D_RA_XD", IIC_IntGeneral, []>;
+def HASHSTP : XForm_XD6_RA5_RB5<31, 658, (outs),
+                                (ins gprc:$RB, memrihash:$D_RA_XD),
+                                "hashstp $RB, $D_RA_XD", IIC_IntGeneral, []>;
+}
+
+// These instructions check a hash computed from the value of the link register
+// and the value of the stack pointer. The hasSideEffects flag is needed as the
+// instruction may TRAP if the hash does not match the hash stored at the
+// specified address.
+let mayLoad = 1, hasSideEffects = 1 in {
+def HASHCHK : XForm_XD6_RA5_RB5<31, 754, (outs),
+                                (ins gprc:$RB, memrihash:$D_RA_XD),
+                                "hashchk $RB, $D_RA_XD", IIC_IntGeneral, []>;
+def HASHCHKP : XForm_XD6_RA5_RB5<31, 690, (outs),
+                                 (ins gprc:$RB, memrihash:$D_RA_XD),
+                                 "hashchkp $RB, $D_RA_XD", IIC_IntGeneral, []>;
+}
+
 // Now both high word and low word are reversed, next
 // swap the high word and low word.
 def : Pat<(i64 (bitreverse i64:$A)),
   (OR8 (RLDICR DWBytes7654.DWord, 32, 31), DWBytes3210.DWord)>;
 
 def : Pat<(int_ppc_stwcx ForceXForm:$dst, gprc:$A),
           (STWCX gprc:$A, ForceXForm:$dst)>;
 def : Pat<(int_ppc_stbcx ForceXForm:$dst, gprc:$A),

llvm/test/CodeGen/PowerPC/ppc64-rop-protection-aix.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-P10
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr9 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-P9
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr8 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-P8
+; RUN: llc -verify-machineinstrs -mtriple=powerpc-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-32BIT-P10
+; RUN: llc -verify-machineinstrs -mtriple=powerpc-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr9 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-32BIT-P9
+; RUN: llc -verify-machineinstrs -mtriple=powerpc-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr8 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-32BIT-P8
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect -mattr=+privileged < %s | FileCheck %s --check-prefix BE-P10-PRIV
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr9 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect -mattr=+privileged < %s | FileCheck %s --check-prefix BE-P9-PRIV
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr8 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect -mattr=+privileged < %s | FileCheck %s --check-prefix BE-P8-PRIV
+; RUN: llc -verify-machineinstrs -mtriple=powerpc-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect -mattr=+privileged < %s | FileCheck %s --check-prefix BE-32BIT-P10-PRIV
+; RUN: llc -verify-machineinstrs -mtriple=powerpc-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr9 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect -mattr=+privileged < %s | FileCheck %s --check-prefix BE-32BIT-P9-PRIV
+; RUN: llc -verify-machineinstrs -mtriple=powerpc-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr8 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr -vec-extabi \
+; RUN:   -mattr=+rop-protect -mattr=+privileged < %s | FileCheck %s --check-prefix BE-32BIT-P8-PRIV
+
+
+
+;; This test checks that the ROP protect instructions have been correctly
+;; added when the ROP protect option has been specified. The hashst
+;; instruction should be added to the prologue and the hashchk should be added
+;; to the epilogue.
+
+define dso_local zeroext i32 @caller(i32 zeroext %in, i32 zeroext %add_after) #0 {
+; BE-P10-LABEL: caller:
+; BE-P10:       # %bb.0: # %entry
+; BE-P10-NEXT:    mflr r0
+; BE-P10-NEXT:    std r0, 16(r1)
+; BE-P10-NEXT:    hashst r0, -16(r1)
+; BE-P10-NEXT:    stdu r1, -128(r1)
+; BE-P10-NEXT:    std r31, 120(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    mr r31, r4
+; BE-P10-NEXT:    bl .callee[PR]
+; BE-P10-NEXT:    nop
+; BE-P10-NEXT:    add r3, r3, r31
+; BE-P10-NEXT:    ld r31, 120(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    clrldi r3, r3, 32
+; BE-P10-NEXT:    addi r1, r1, 128
+; BE-P10-NEXT:    ld r0, 16(r1)
+; BE-P10-NEXT:    hashchk r0, -16(r1)
+; BE-P10-NEXT:    mtlr r0
+; BE-P10-NEXT:    blr
+;
+; 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 r31, 120(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    mr r31, r4
+; BE-P9-NEXT:    bl .callee[PR]
+; BE-P9-NEXT:    nop
+; BE-P9-NEXT:    add r3, r3, r31
+; BE-P9-NEXT:    ld r31, 120(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    clrldi r3, r3, 32
+; BE-P9-NEXT:    addi r1, r1, 128
+; BE-P9-NEXT:    ld r0, 16(r1)
+; BE-P9-NEXT:    mtlr r0
+; BE-P9-NEXT:    hashchk r0, -16(r1)
+; BE-P9-NEXT:    blr
+;
+; 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 r31, 120(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    mr r31, r4
+; BE-P8-NEXT:    bl .callee[PR]
+; BE-P8-NEXT:    nop
+; BE-P8-NEXT:    add r3, r3, r31
+; BE-P8-NEXT:    ld r31, 120(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    clrldi r3, r3, 32
+; BE-P8-NEXT:    addi r1, r1, 128
+; BE-P8-NEXT:    ld r0, 16(r1)
+; BE-P8-NEXT:    hashchk r0, -16(r1)
+; BE-P8-NEXT:    mtlr r0
+; BE-P8-NEXT:    blr
+;
+; BE-32BIT-P10-LABEL: caller:
+; BE-32BIT-P10:       # %bb.0: # %entry
+; BE-32BIT-P10-NEXT:    mflr r0
+; BE-32BIT-P10-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P10-NEXT:    hashst r0, -16(r1)
+; BE-32BIT-P10-NEXT:    stwu r1, -80(r1)
+; BE-32BIT-P10-NEXT:    stw r31, 76(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    mr r31, r4
+; BE-32BIT-P10-NEXT:    bl .callee[PR]
+; BE-32BIT-P10-NEXT:    nop
+; BE-32BIT-P10-NEXT:    add r3, r3, r31
+; BE-32BIT-P10-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    addi r1, r1, 80
+; BE-32BIT-P10-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P10-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P10-NEXT:    mtlr r0
+; BE-32BIT-P10-NEXT:    blr
+;
+; 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 r31, 76(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    mr r31, r4
+; BE-32BIT-P9-NEXT:    bl .callee[PR]
+; BE-32BIT-P9-NEXT:    nop
+; BE-32BIT-P9-NEXT:    add r3, r3, r31
+; BE-32BIT-P9-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    addi r1, r1, 80
+; BE-32BIT-P9-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P9-NEXT:    mtlr r0
+; BE-32BIT-P9-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P9-NEXT:    blr
+;
+; 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 r31, 76(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    mr r31, r4
+; BE-32BIT-P8-NEXT:    bl .callee[PR]
+; BE-32BIT-P8-NEXT:    nop
+; BE-32BIT-P8-NEXT:    add r3, r3, r31
+; BE-32BIT-P8-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    addi r1, r1, 80
+; BE-32BIT-P8-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P8-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P8-NEXT:    mtlr r0
+; BE-32BIT-P8-NEXT:    blr
+;
+; BE-P10-PRIV-LABEL: caller:
+; BE-P10-PRIV:       # %bb.0: # %entry
+; BE-P10-PRIV-NEXT:    mflr r0
+; BE-P10-PRIV-NEXT:    std r0, 16(r1)
+; BE-P10-PRIV-NEXT:    hashstp r0, -16(r1)
+; BE-P10-PRIV-NEXT:    stdu r1, -128(r1)
+; BE-P10-PRIV-NEXT:    std r31, 120(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    mr r31, r4
+; BE-P10-PRIV-NEXT:    bl .callee[PR]
+; BE-P10-PRIV-NEXT:    nop
+; BE-P10-PRIV-NEXT:    add r3, r3, r31
+; BE-P10-PRIV-NEXT:    ld r31, 120(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P10-PRIV-NEXT:    addi r1, r1, 128
+; BE-P10-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P10-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-P10-PRIV-NEXT:    mtlr r0
+; BE-P10-PRIV-NEXT:    blr
+;
+; 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 r31, 120(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    mr r31, r4
+; BE-P9-PRIV-NEXT:    bl .callee[PR]
+; BE-P9-PRIV-NEXT:    nop
+; BE-P9-PRIV-NEXT:    add r3, r3, r31
+; BE-P9-PRIV-NEXT:    ld r31, 120(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P9-PRIV-NEXT:    addi r1, r1, 128
+; BE-P9-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P9-PRIV-NEXT:    mtlr r0
+; BE-P9-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-P9-PRIV-NEXT:    blr
+;
+; 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 r31, 120(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    mr r31, r4
+; BE-P8-PRIV-NEXT:    bl .callee[PR]
+; BE-P8-PRIV-NEXT:    nop
+; BE-P8-PRIV-NEXT:    add r3, r3, r31
+; BE-P8-PRIV-NEXT:    ld r31, 120(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P8-PRIV-NEXT:    addi r1, r1, 128
+; BE-P8-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P8-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-P8-PRIV-NEXT:    mtlr r0
+; BE-P8-PRIV-NEXT:    blr
+;
+; BE-32BIT-P10-PRIV-LABEL: caller:
+; BE-32BIT-P10-PRIV:       # %bb.0: # %entry
+; BE-32BIT-P10-PRIV-NEXT:    mflr r0
+; BE-32BIT-P10-PRIV-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P10-PRIV-NEXT:    hashstp r0, -16(r1)
+; BE-32BIT-P10-PRIV-NEXT:    stwu r1, -80(r1)
+; BE-32BIT-P10-PRIV-NEXT:    stw r31, 76(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    mr r31, r4
+; BE-32BIT-P10-PRIV-NEXT:    bl .callee[PR]
+; BE-32BIT-P10-PRIV-NEXT:    nop
+; BE-32BIT-P10-PRIV-NEXT:    add r3, r3, r31
+; BE-32BIT-P10-PRIV-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    addi r1, r1, 80
+; BE-32BIT-P10-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P10-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-32BIT-P10-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P10-PRIV-NEXT:    blr
+;
+; 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 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-P9-PRIV-NEXT:    nop
+; BE-32BIT-P9-PRIV-NEXT:    add r3, r3, r31
+; BE-32BIT-P9-PRIV-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    addi r1, r1, 80
+; BE-32BIT-P9-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P9-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P9-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-32BIT-P9-PRIV-NEXT:    blr
+;
+; 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 r31, 76(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    mr r31, r4
+; BE-32BIT-P8-PRIV-NEXT:    bl .callee[PR]
+; BE-32BIT-P8-PRIV-NEXT:    nop
+; BE-32BIT-P8-PRIV-NEXT:    add r3, r3, r31
+; BE-32BIT-P8-PRIV-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    addi r1, r1, 80
+; BE-32BIT-P8-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P8-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-32BIT-P8-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P8-PRIV-NEXT:    blr
+entry:
+  %call = tail call zeroext i32 @callee(i32 zeroext %in)
+  %add = add i32 %call, %add_after
+  ret i32 %add
+}
+
+;; TODO: Remove this comment once the new version of the ABI is available.
+;; NOTE: This test is technically a violation of the ABI. The hash is saved
+;; outside of the initial 288 byte volatile program storage region in the
+;; Protected Zone. However, this restriction will be removed in an upcoming
+;; revision of the ABI.
+define dso_local zeroext i32 @spill(i32* nocapture readonly %in) #0 {
+; BE-P10-LABEL: spill:
+; BE-P10:       # %bb.0: # %entry
+; BE-P10-NEXT:    mflr r0
+; BE-P10-NEXT:    mfcr r12
+; BE-P10-NEXT:    std r0, 16(r1)
+; BE-P10-NEXT:    hashst r0, -488(r1)
+; BE-P10-NEXT:    stw r12, 8(r1)
+; BE-P10-NEXT:    stdu r1, -624(r1)
+; BE-P10-NEXT:    lwz r4, 12(r3)
+; BE-P10-NEXT:    std r14, 336(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r15, 344(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r16, 352(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r17, 360(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r18, 368(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r19, 376(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r20, 384(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r21, 392(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r22, 400(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r23, 408(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r24, 416(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r25, 424(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r26, 432(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r27, 440(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r28, 448(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r29, 456(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r30, 464(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    std r31, 472(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f14, 480(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f15, 488(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f16, 496(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f17, 504(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f18, 512(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f19, 520(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f20, 528(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f21, 536(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f22, 544(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f23, 552(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f24, 560(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f25, 568(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f26, 576(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f27, 584(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f28, 592(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f29, 600(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f30, 608(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stfd f31, 616(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stxv v20, 144(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v21, 160(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v22, 176(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v23, 192(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v24, 208(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v25, 224(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v26, 240(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v27, 256(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v28, 272(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v29, 288(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v30, 304(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    stxv v31, 320(r1) # 16-byte Folded Spill
+; BE-P10-NEXT:    std r3, 120(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    stw r4, 132(r1)
+; BE-P10-NEXT:    #APP
+; BE-P10-NEXT:    nop
+; BE-P10-NEXT:    #NO_APP
+; BE-P10-NEXT:    addi r3, r1, 132
+; BE-P10-NEXT:    bl .callee2[PR]
+; BE-P10-NEXT:    nop
+; BE-P10-NEXT:    ld r4, 120(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lxv v31, 320(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v30, 304(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v29, 288(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v28, 272(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v27, 256(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v26, 240(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v25, 224(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v24, 208(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v23, 192(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v22, 176(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v21, 160(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lxv v20, 144(r1) # 16-byte Folded Reload
+; BE-P10-NEXT:    lfd f31, 616(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f30, 608(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f29, 600(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f28, 592(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f27, 584(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f26, 576(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f25, 568(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f24, 560(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f23, 552(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f22, 544(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f21, 536(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f20, 528(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f19, 520(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f18, 512(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f17, 504(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f16, 496(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f15, 488(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lfd f14, 480(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r31, 472(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r30, 464(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r29, 456(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r28, 448(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r27, 440(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r26, 432(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r25, 424(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r24, 416(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r23, 408(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r22, 400(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r21, 392(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r20, 384(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r19, 376(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r18, 368(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r17, 360(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r16, 352(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    ld r15, 344(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    lwz r4, 16(r4)
+; BE-P10-NEXT:    add r3, r4, r3
+; BE-P10-NEXT:    clrldi r3, r3, 32
+; BE-P10-NEXT:    ld r14, 336(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    addi r1, r1, 624
+; BE-P10-NEXT:    ld r0, 16(r1)
+; BE-P10-NEXT:    lwz r12, 8(r1)
+; BE-P10-NEXT:    mtlr r0
+; BE-P10-NEXT:    hashchk r0, -488(r1)
+; BE-P10-NEXT:    mtocrf 32, r12
+; BE-P10-NEXT:    mtocrf 16, r12
+; BE-P10-NEXT:    mtocrf 8, r12
+; BE-P10-NEXT:    blr
+;
+; 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:    stw r12, 8(r1)
+; BE-P9-NEXT:    stdu r1, -624(r1)
+; BE-P9-NEXT:    lwz r4, 12(r3)
+; 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:    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:    stxv v24, 208(r1) # 16-byte Folded Spill
+; BE-P9-NEXT:    std r19, 376(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stxv v25, 224(r1) # 16-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:    stxv v27, 256(r1) # 16-byte Folded Spill
+; BE-P9-NEXT:    std r23, 408(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stxv v28, 272(r1) # 16-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:    stxv v30, 304(r1) # 16-byte Folded Spill
+; BE-P9-NEXT:    std r27, 440(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stxv v31, 320(r1) # 16-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-P9-NEXT:    std r31, 472(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f14, 480(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f15, 488(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f16, 496(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f17, 504(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f18, 512(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f19, 520(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f20, 528(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f21, 536(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f22, 544(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f23, 552(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f24, 560(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f25, 568(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f26, 576(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f27, 584(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f28, 592(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f29, 600(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f30, 608(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stfd f31, 616(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    std r3, 120(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    stw r4, 132(r1)
+; BE-P9-NEXT:    #APP
+; BE-P9-NEXT:    nop
+; BE-P9-NEXT:    #NO_APP
+; BE-P9-NEXT:    addi r3, r1, 132
+; BE-P9-NEXT:    bl .callee2[PR]
+; BE-P9-NEXT:    nop
+; BE-P9-NEXT:    ld r4, 120(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lxv v31, 320(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v30, 304(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v29, 288(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v28, 272(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v27, 256(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v26, 240(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v25, 224(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v24, 208(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v23, 192(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v22, 176(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v21, 160(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lxv v20, 144(r1) # 16-byte Folded Reload
+; BE-P9-NEXT:    lfd f31, 616(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f30, 608(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f29, 600(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f28, 592(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f27, 584(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r31, 472(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r30, 464(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r29, 456(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f26, 576(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r28, 448(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r27, 440(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r26, 432(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f25, 568(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r25, 424(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r24, 416(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r23, 408(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f24, 560(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r22, 400(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r21, 392(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lwz r4, 16(r4)
+; BE-P9-NEXT:    add r3, r4, r3
+; BE-P9-NEXT:    lfd f23, 552(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f22, 544(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r20, 384(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r19, 376(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r18, 368(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r17, 360(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r16, 352(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r15, 344(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    ld r14, 336(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f21, 536(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f20, 528(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f19, 520(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f18, 512(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f17, 504(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f16, 496(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f15, 488(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    lfd f14, 480(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    clrldi r3, r3, 32
+; BE-P9-NEXT:    addi r1, r1, 624
+; BE-P9-NEXT:    ld r0, 16(r1)
+; BE-P9-NEXT:    lwz r12, 8(r1)
+; BE-P9-NEXT:    mtlr r0
+; BE-P9-NEXT:    hashchk r0, -488(r1)
+; BE-P9-NEXT:    mtocrf 32, r12
+; BE-P9-NEXT:    mtocrf 16, r12
+; BE-P9-NEXT:    mtocrf 8, r12
+; BE-P9-NEXT:    blr
+;
+; BE-P8-LABEL: 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 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 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 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 r25, 424(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    std r26, 432(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    std r27, 440(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    std r28, 448(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    std r29, 456(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    std r30, 464(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    std r31, 472(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:    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:    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:    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:    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:    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:    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:    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:    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:    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-P8-NEXT:    stfd f26, 576(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    stfd f27, 584(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    stfd f28, 592(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    stfd f29, 600(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    stfd f30, 608(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    stfd f31, 616(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    stw r4, 132(r1)
+; BE-P8-NEXT:    #APP
+; BE-P8-NEXT:    nop
+; BE-P8-NEXT:    #NO_APP
+; BE-P8-NEXT:    addi r3, r1, 132
+; BE-P8-NEXT:    bl .callee2[PR]
+; BE-P8-NEXT:    nop
+; BE-P8-NEXT:    ld r4, 120(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lfd f31, 616(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lfd f30, 608(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r31, 472(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lfd f29, 600(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lfd f28, 592(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r30, 464(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r29, 456(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lwz r4, 16(r4)
+; BE-P8-NEXT:    lfd f27, 584(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lfd f26, 576(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r28, 448(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lfd f25, 568(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lfd f24, 560(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r27, 440(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r26, 432(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    add r3, r4, r3
+; BE-P8-NEXT:    li r4, 320
+; BE-P8-NEXT:    lfd f23, 552(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lfd f22, 544(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r25, 424(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r24, 416(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lxvd2x v31, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 304
+; BE-P8-NEXT:    lfd f21, 536(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r23, 408(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r22, 400(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    clrldi r3, r3, 32
+; BE-P8-NEXT:    lxvd2x v30, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 288
+; BE-P8-NEXT:    lfd f20, 528(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r21, 392(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r20, 384(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lxvd2x v29, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 272
+; BE-P8-NEXT:    lfd f19, 520(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r19, 376(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r18, 368(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lxvd2x v28, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 256
+; BE-P8-NEXT:    lfd f18, 512(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r17, 360(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r16, 352(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lxvd2x v27, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 240
+; BE-P8-NEXT:    lfd f17, 504(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r15, 344(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    ld r14, 336(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lxvd2x v26, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 224
+; BE-P8-NEXT:    lfd f16, 496(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lxvd2x v25, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 208
+; BE-P8-NEXT:    lfd f15, 488(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lxvd2x v24, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 192
+; BE-P8-NEXT:    lfd f14, 480(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    lxvd2x v23, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 176
+; BE-P8-NEXT:    lxvd2x v22, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 160
+; BE-P8-NEXT:    lxvd2x v21, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    li r4, 144
+; BE-P8-NEXT:    lxvd2x v20, r1, r4 # 16-byte Folded Reload
+; BE-P8-NEXT:    addi r1, r1, 624
+; BE-P8-NEXT:    ld r0, 16(r1)
+; BE-P8-NEXT:    lwz r12, 8(r1)
+; BE-P8-NEXT:    mtocrf 32, r12
+; BE-P8-NEXT:    hashchk r0, -488(r1)
+; BE-P8-NEXT:    mtlr r0
+; BE-P8-NEXT:    mtocrf 16, r12
+; BE-P8-NEXT:    mtocrf 8, r12
+; BE-P8-NEXT:    blr
+;
+; BE-32BIT-P10-LABEL: spill:
+; BE-32BIT-P10:       # %bb.0: # %entry
+; BE-32BIT-P10-NEXT:    mflr r0
+; BE-32BIT-P10-NEXT:    mfcr r12
+; BE-32BIT-P10-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P10-NEXT:    hashst r0, -424(r1)
+; BE-32BIT-P10-NEXT:    stw r12, 4(r1)
+; BE-32BIT-P10-NEXT:    stwu r1, -496(r1)
+; BE-32BIT-P10-NEXT:    lwz r4, 12(r3)
+; BE-32BIT-P10-NEXT:    stw r13, 276(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r14, 280(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r15, 284(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r16, 288(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r17, 292(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r18, 296(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r19, 300(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r20, 304(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r21, 308(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r22, 312(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r23, 316(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r24, 320(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r25, 324(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r26, 328(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r27, 332(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r28, 336(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r29, 340(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r30, 344(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r31, 348(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f14, 352(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f15, 360(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f16, 368(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f17, 376(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f18, 384(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f19, 392(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f20, 400(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f21, 408(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f22, 416(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f23, 424(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f24, 432(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f25, 440(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f26, 448(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f27, 456(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f28, 464(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f29, 472(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f30, 480(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f31, 488(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v20, 80(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v21, 96(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v22, 112(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v23, 128(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v24, 144(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v25, 160(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v26, 176(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v27, 192(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v28, 208(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v29, 224(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v30, 240(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v31, 256(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r3, 64(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r4, 68(r1)
+; BE-32BIT-P10-NEXT:    #APP
+; BE-32BIT-P10-NEXT:    nop
+; BE-32BIT-P10-NEXT:    #NO_APP
+; BE-32BIT-P10-NEXT:    addi r3, r1, 68
+; BE-32BIT-P10-NEXT:    bl .callee2[PR]
+; BE-32BIT-P10-NEXT:    nop
+; BE-32BIT-P10-NEXT:    lwz r4, 64(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v31, 256(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v30, 240(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v29, 224(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v28, 208(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v27, 192(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v26, 176(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v25, 160(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v24, 144(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v23, 128(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v22, 112(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v21, 96(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v20, 80(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f31, 488(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f30, 480(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f29, 472(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f28, 464(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f27, 456(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f26, 448(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f25, 440(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f24, 432(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f23, 424(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f22, 416(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f21, 408(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f20, 400(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f19, 392(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f18, 384(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f17, 376(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f16, 368(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f15, 360(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f14, 352(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r31, 348(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r30, 344(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r29, 340(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r28, 336(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r27, 332(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r26, 328(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r25, 324(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r24, 320(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r23, 316(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r22, 312(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r21, 308(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r20, 304(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r19, 300(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r18, 296(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r17, 292(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r16, 288(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r15, 284(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r4, 16(r4)
+; BE-32BIT-P10-NEXT:    add r3, r4, r3
+; BE-32BIT-P10-NEXT:    lwz r14, 280(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r13, 276(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    addi r1, r1, 496
+; BE-32BIT-P10-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P10-NEXT:    lwz r12, 4(r1)
+; BE-32BIT-P10-NEXT:    mtlr r0
+; BE-32BIT-P10-NEXT:    hashchk r0, -424(r1)
+; BE-32BIT-P10-NEXT:    mtocrf 32, r12
+; BE-32BIT-P10-NEXT:    mtocrf 16, r12
+; BE-32BIT-P10-NEXT:    mtocrf 8, r12
+; BE-32BIT-P10-NEXT:    blr
+;
+; 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:    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 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:    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:    stxv v24, 144(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r18, 296(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v25, 160(r1) # 16-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:    stxv v27, 192(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r22, 312(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v28, 208(r1) # 16-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:    stxv v30, 240(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r26, 328(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v31, 256(r1) # 16-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-P9-NEXT:    stw r30, 344(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r31, 348(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f14, 352(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f15, 360(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f16, 368(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f17, 376(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f18, 384(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f19, 392(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f20, 400(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f21, 408(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f22, 416(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f23, 424(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f24, 432(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f25, 440(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f26, 448(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f27, 456(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f28, 464(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f29, 472(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f30, 480(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f31, 488(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r3, 64(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r4, 68(r1)
+; BE-32BIT-P9-NEXT:    #APP
+; BE-32BIT-P9-NEXT:    nop
+; BE-32BIT-P9-NEXT:    #NO_APP
+; BE-32BIT-P9-NEXT:    addi r3, r1, 68
+; BE-32BIT-P9-NEXT:    bl .callee2[PR]
+; BE-32BIT-P9-NEXT:    nop
+; BE-32BIT-P9-NEXT:    lwz r4, 64(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v31, 256(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v30, 240(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v29, 224(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v28, 208(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v27, 192(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v26, 176(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v25, 160(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v24, 144(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v23, 128(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v22, 112(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v21, 96(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v20, 80(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f31, 488(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f30, 480(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f29, 472(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f28, 464(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f27, 456(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r31, 348(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r30, 344(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r29, 340(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f26, 448(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r28, 336(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r27, 332(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r26, 328(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f25, 440(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r25, 324(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r24, 320(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r23, 316(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f24, 432(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r22, 312(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r21, 308(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r4, 16(r4)
+; BE-32BIT-P9-NEXT:    add r3, r4, r3
+; BE-32BIT-P9-NEXT:    lfd f23, 424(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f22, 416(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r20, 304(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r19, 300(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r18, 296(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r17, 292(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r16, 288(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r15, 284(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r14, 280(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r13, 276(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f21, 408(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f20, 400(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f19, 392(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f18, 384(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f17, 376(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f16, 368(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f15, 360(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f14, 352(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    addi r1, r1, 496
+; BE-32BIT-P9-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P9-NEXT:    lwz r12, 4(r1)
+; BE-32BIT-P9-NEXT:    mtlr r0
+; BE-32BIT-P9-NEXT:    hashchk r0, -424(r1)
+; BE-32BIT-P9-NEXT:    mtocrf 32, r12
+; BE-32BIT-P9-NEXT:    mtocrf 16, r12
+; BE-32BIT-P9-NEXT:    mtocrf 8, r12
+; BE-32BIT-P9-NEXT:    blr
+;
+; BE-32BIT-P8-LABEL: 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 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:    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:    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:    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:    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:    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:    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:    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:    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:    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:    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:    stxvd2x v31, r1, r4 # 16-byte Folded Spill
+; BE-32BIT-P8-NEXT:    lwz r4, 12(r3)
+; 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-32BIT-P8-NEXT:    stw r29, 340(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r30, 344(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r31, 348(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f14, 352(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f15, 360(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f16, 368(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f17, 376(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f18, 384(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f19, 392(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f20, 400(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f21, 408(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f22, 416(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f23, 424(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f24, 432(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f25, 440(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f26, 448(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f27, 456(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f28, 464(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f29, 472(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f30, 480(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f31, 488(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r3, 64(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r4, 68(r1)
+; BE-32BIT-P8-NEXT:    #APP
+; BE-32BIT-P8-NEXT:    nop
+; BE-32BIT-P8-NEXT:    #NO_APP
+; BE-32BIT-P8-NEXT:    addi r3, r1, 68
+; BE-32BIT-P8-NEXT:    bl .callee2[PR]
+; BE-32BIT-P8-NEXT:    nop
+; BE-32BIT-P8-NEXT:    lwz r4, 64(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f31, 488(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f30, 480(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r31, 348(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f29, 472(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f28, 464(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r30, 344(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r29, 340(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r4, 16(r4)
+; BE-32BIT-P8-NEXT:    lfd f27, 456(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f26, 448(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r28, 336(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f25, 440(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f24, 432(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r27, 332(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r26, 328(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    add r3, r4, r3
+; BE-32BIT-P8-NEXT:    li r4, 256
+; BE-32BIT-P8-NEXT:    lfd f23, 424(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f22, 416(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r25, 324(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r24, 320(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v31, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 240
+; BE-32BIT-P8-NEXT:    lfd f21, 408(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r23, 316(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r22, 312(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v30, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 224
+; BE-32BIT-P8-NEXT:    lfd f20, 400(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r21, 308(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r20, 304(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v29, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 208
+; BE-32BIT-P8-NEXT:    lfd f19, 392(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r19, 300(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r18, 296(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v28, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 192
+; BE-32BIT-P8-NEXT:    lfd f18, 384(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r17, 292(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r16, 288(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v27, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 176
+; BE-32BIT-P8-NEXT:    lfd f17, 376(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r15, 284(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r14, 280(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v26, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 160
+; BE-32BIT-P8-NEXT:    lfd f16, 368(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r13, 276(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v25, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 144
+; BE-32BIT-P8-NEXT:    lfd f15, 360(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v24, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 128
+; BE-32BIT-P8-NEXT:    lfd f14, 352(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v23, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 112
+; BE-32BIT-P8-NEXT:    lxvd2x v22, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 96
+; BE-32BIT-P8-NEXT:    lxvd2x v21, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 80
+; BE-32BIT-P8-NEXT:    lxvd2x v20, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    addi r1, r1, 496
+; BE-32BIT-P8-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P8-NEXT:    lwz r12, 4(r1)
+; BE-32BIT-P8-NEXT:    mtocrf 32, r12
+; BE-32BIT-P8-NEXT:    hashchk r0, -424(r1)
+; BE-32BIT-P8-NEXT:    mtlr r0
+; BE-32BIT-P8-NEXT:    mtocrf 16, r12
+; BE-32BIT-P8-NEXT:    mtocrf 8, r12
+; BE-32BIT-P8-NEXT:    blr
+;
+; BE-P10-PRIV-LABEL: spill:
+; BE-P10-PRIV:       # %bb.0: # %entry
+; BE-P10-PRIV-NEXT:    mflr r0
+; BE-P10-PRIV-NEXT:    mfcr r12
+; BE-P10-PRIV-NEXT:    std r0, 16(r1)
+; BE-P10-PRIV-NEXT:    hashstp r0, -488(r1)
+; BE-P10-PRIV-NEXT:    stw r12, 8(r1)
+; BE-P10-PRIV-NEXT:    stdu r1, -624(r1)
+; BE-P10-PRIV-NEXT:    lwz r4, 12(r3)
+; BE-P10-PRIV-NEXT:    std r14, 336(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r15, 344(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r16, 352(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r17, 360(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r18, 368(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r19, 376(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r20, 384(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r21, 392(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r22, 400(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r23, 408(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r24, 416(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r25, 424(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r26, 432(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r27, 440(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r28, 448(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r29, 456(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r30, 464(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r31, 472(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f14, 480(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f15, 488(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f16, 496(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f17, 504(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f18, 512(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f19, 520(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f20, 528(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f21, 536(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f22, 544(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f23, 552(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f24, 560(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f25, 568(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f26, 576(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f27, 584(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f28, 592(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f29, 600(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f30, 608(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stfd f31, 616(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v20, 144(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v21, 160(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v22, 176(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v23, 192(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v24, 208(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v25, 224(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v26, 240(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v27, 256(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v28, 272(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v29, 288(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v30, 304(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stxv v31, 320(r1) # 16-byte Folded Spill
+; BE-P10-PRIV-NEXT:    std r3, 120(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    stw r4, 132(r1)
+; BE-P10-PRIV-NEXT:    #APP
+; BE-P10-PRIV-NEXT:    nop
+; BE-P10-PRIV-NEXT:    #NO_APP
+; BE-P10-PRIV-NEXT:    addi r3, r1, 132
+; BE-P10-PRIV-NEXT:    bl .callee2[PR]
+; BE-P10-PRIV-NEXT:    nop
+; BE-P10-PRIV-NEXT:    ld r4, 120(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v31, 320(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v30, 304(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v29, 288(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v28, 272(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v27, 256(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v26, 240(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v25, 224(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v24, 208(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v23, 192(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v22, 176(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v21, 160(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lxv v20, 144(r1) # 16-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f31, 616(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f30, 608(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f29, 600(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f28, 592(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f27, 584(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f26, 576(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f25, 568(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f24, 560(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f23, 552(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f22, 544(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f21, 536(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f20, 528(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f19, 520(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f18, 512(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f17, 504(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f16, 496(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f15, 488(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lfd f14, 480(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r31, 472(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r30, 464(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r29, 456(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r28, 448(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r27, 440(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r26, 432(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r25, 424(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r24, 416(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r23, 408(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r22, 400(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r21, 392(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r20, 384(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r19, 376(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r18, 368(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r17, 360(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r16, 352(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    ld r15, 344(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    lwz r4, 16(r4)
+; BE-P10-PRIV-NEXT:    add r3, r4, r3
+; BE-P10-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P10-PRIV-NEXT:    ld r14, 336(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    addi r1, r1, 624
+; BE-P10-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P10-PRIV-NEXT:    lwz r12, 8(r1)
+; BE-P10-PRIV-NEXT:    mtlr r0
+; BE-P10-PRIV-NEXT:    hashchkp r0, -488(r1)
+; BE-P10-PRIV-NEXT:    mtocrf 32, r12
+; BE-P10-PRIV-NEXT:    mtocrf 16, r12
+; BE-P10-PRIV-NEXT:    mtocrf 8, r12
+; BE-P10-PRIV-NEXT:    blr
+;
+; 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:    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 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:    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:    stxv v24, 208(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT:    std r19, 376(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stxv v25, 224(r1) # 16-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:    stxv v27, 256(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT:    std r23, 408(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stxv v28, 272(r1) # 16-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:    stxv v30, 304(r1) # 16-byte Folded Spill
+; BE-P9-PRIV-NEXT:    std r27, 440(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stxv v31, 320(r1) # 16-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-P9-PRIV-NEXT:    std r31, 472(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f14, 480(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f15, 488(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f16, 496(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f17, 504(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f18, 512(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f19, 520(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f20, 528(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f21, 536(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f22, 544(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f23, 552(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f24, 560(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f25, 568(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f26, 576(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f27, 584(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f28, 592(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f29, 600(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f30, 608(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stfd f31, 616(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    std r3, 120(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    stw r4, 132(r1)
+; BE-P9-PRIV-NEXT:    #APP
+; BE-P9-PRIV-NEXT:    nop
+; BE-P9-PRIV-NEXT:    #NO_APP
+; BE-P9-PRIV-NEXT:    addi r3, r1, 132
+; BE-P9-PRIV-NEXT:    bl .callee2[PR]
+; BE-P9-PRIV-NEXT:    nop
+; BE-P9-PRIV-NEXT:    ld r4, 120(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v31, 320(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v30, 304(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v29, 288(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v28, 272(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v27, 256(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v26, 240(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v25, 224(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v24, 208(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v23, 192(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v22, 176(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v21, 160(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lxv v20, 144(r1) # 16-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f31, 616(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f30, 608(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f29, 600(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f28, 592(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f27, 584(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r31, 472(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r30, 464(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r29, 456(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f26, 576(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r28, 448(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r27, 440(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r26, 432(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f25, 568(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r25, 424(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r24, 416(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r23, 408(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f24, 560(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r22, 400(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r21, 392(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lwz r4, 16(r4)
+; BE-P9-PRIV-NEXT:    add r3, r4, r3
+; BE-P9-PRIV-NEXT:    lfd f23, 552(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f22, 544(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r20, 384(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r19, 376(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r18, 368(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r17, 360(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r16, 352(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r15, 344(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    ld r14, 336(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f21, 536(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f20, 528(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f19, 520(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f18, 512(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f17, 504(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f16, 496(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f15, 488(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    lfd f14, 480(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P9-PRIV-NEXT:    addi r1, r1, 624
+; BE-P9-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P9-PRIV-NEXT:    lwz r12, 8(r1)
+; BE-P9-PRIV-NEXT:    mtlr r0
+; BE-P9-PRIV-NEXT:    hashchkp r0, -488(r1)
+; BE-P9-PRIV-NEXT:    mtocrf 32, r12
+; BE-P9-PRIV-NEXT:    mtocrf 16, r12
+; BE-P9-PRIV-NEXT:    mtocrf 8, r12
+; BE-P9-PRIV-NEXT:    blr
+;
+; BE-P8-PRIV-LABEL: 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 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 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 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 r25, 424(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    std r26, 432(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    std r27, 440(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    std r28, 448(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    std r29, 456(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    std r30, 464(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    std r31, 472(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:    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:    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:    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:    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:    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:    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:    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:    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:    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-P8-PRIV-NEXT:    stfd f26, 576(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    stfd f27, 584(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    stfd f28, 592(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    stfd f29, 600(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    stfd f30, 608(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    stfd f31, 616(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    stw r4, 132(r1)
+; BE-P8-PRIV-NEXT:    #APP
+; BE-P8-PRIV-NEXT:    nop
+; BE-P8-PRIV-NEXT:    #NO_APP
+; BE-P8-PRIV-NEXT:    addi r3, r1, 132
+; BE-P8-PRIV-NEXT:    bl .callee2[PR]
+; BE-P8-PRIV-NEXT:    nop
+; BE-P8-PRIV-NEXT:    ld r4, 120(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lfd f31, 616(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lfd f30, 608(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r31, 472(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lfd f29, 600(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lfd f28, 592(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r30, 464(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r29, 456(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lwz r4, 16(r4)
+; BE-P8-PRIV-NEXT:    lfd f27, 584(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lfd f26, 576(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r28, 448(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lfd f25, 568(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lfd f24, 560(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r27, 440(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r26, 432(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    add r3, r4, r3
+; BE-P8-PRIV-NEXT:    li r4, 320
+; BE-P8-PRIV-NEXT:    lfd f23, 552(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lfd f22, 544(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r25, 424(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r24, 416(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lxvd2x v31, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 304
+; BE-P8-PRIV-NEXT:    lfd f21, 536(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r23, 408(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r22, 400(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P8-PRIV-NEXT:    lxvd2x v30, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 288
+; BE-P8-PRIV-NEXT:    lfd f20, 528(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r21, 392(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r20, 384(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lxvd2x v29, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 272
+; BE-P8-PRIV-NEXT:    lfd f19, 520(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r19, 376(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r18, 368(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lxvd2x v28, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 256
+; BE-P8-PRIV-NEXT:    lfd f18, 512(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r17, 360(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r16, 352(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lxvd2x v27, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 240
+; BE-P8-PRIV-NEXT:    lfd f17, 504(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r15, 344(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    ld r14, 336(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lxvd2x v26, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 224
+; BE-P8-PRIV-NEXT:    lfd f16, 496(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lxvd2x v25, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 208
+; BE-P8-PRIV-NEXT:    lfd f15, 488(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lxvd2x v24, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 192
+; BE-P8-PRIV-NEXT:    lfd f14, 480(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    lxvd2x v23, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 176
+; BE-P8-PRIV-NEXT:    lxvd2x v22, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 160
+; BE-P8-PRIV-NEXT:    lxvd2x v21, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    li r4, 144
+; BE-P8-PRIV-NEXT:    lxvd2x v20, r1, r4 # 16-byte Folded Reload
+; BE-P8-PRIV-NEXT:    addi r1, r1, 624
+; BE-P8-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P8-PRIV-NEXT:    lwz r12, 8(r1)
+; BE-P8-PRIV-NEXT:    mtocrf 32, r12
+; BE-P8-PRIV-NEXT:    hashchkp r0, -488(r1)
+; BE-P8-PRIV-NEXT:    mtlr r0
+; BE-P8-PRIV-NEXT:    mtocrf 16, r12
+; BE-P8-PRIV-NEXT:    mtocrf 8, r12
+; BE-P8-PRIV-NEXT:    blr
+;
+; BE-32BIT-P10-PRIV-LABEL: spill:
+; BE-32BIT-P10-PRIV:       # %bb.0: # %entry
+; BE-32BIT-P10-PRIV-NEXT:    mflr r0
+; BE-32BIT-P10-PRIV-NEXT:    mfcr r12
+; BE-32BIT-P10-PRIV-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P10-PRIV-NEXT:    hashstp r0, -424(r1)
+; BE-32BIT-P10-PRIV-NEXT:    stw r12, 4(r1)
+; BE-32BIT-P10-PRIV-NEXT:    stwu r1, -496(r1)
+; BE-32BIT-P10-PRIV-NEXT:    lwz r4, 12(r3)
+; BE-32BIT-P10-PRIV-NEXT:    stw r13, 276(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r14, 280(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r15, 284(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r16, 288(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r17, 292(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r18, 296(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r19, 300(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r20, 304(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r21, 308(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r22, 312(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r23, 316(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r24, 320(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r25, 324(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r26, 328(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r27, 332(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r28, 336(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r29, 340(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r30, 344(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r31, 348(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f14, 352(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f15, 360(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f16, 368(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f17, 376(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f18, 384(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f19, 392(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f20, 400(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f21, 408(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f22, 416(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f23, 424(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f24, 432(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f25, 440(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f26, 448(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f27, 456(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f28, 464(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f29, 472(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f30, 480(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stfd f31, 488(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v20, 80(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v21, 96(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v22, 112(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v23, 128(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v24, 144(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v25, 160(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v26, 176(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v27, 192(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v28, 208(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v29, 224(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v30, 240(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stxv v31, 256(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r3, 64(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    stw r4, 68(r1)
+; BE-32BIT-P10-PRIV-NEXT:    #APP
+; BE-32BIT-P10-PRIV-NEXT:    nop
+; BE-32BIT-P10-PRIV-NEXT:    #NO_APP
+; BE-32BIT-P10-PRIV-NEXT:    addi r3, r1, 68
+; BE-32BIT-P10-PRIV-NEXT:    bl .callee2[PR]
+; BE-32BIT-P10-PRIV-NEXT:    nop
+; BE-32BIT-P10-PRIV-NEXT:    lwz r4, 64(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v31, 256(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v30, 240(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v29, 224(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v28, 208(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v27, 192(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v26, 176(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v25, 160(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v24, 144(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v23, 128(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v22, 112(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v21, 96(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lxv v20, 80(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f31, 488(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f30, 480(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f29, 472(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f28, 464(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f27, 456(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f26, 448(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f25, 440(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f24, 432(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f23, 424(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f22, 416(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f21, 408(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f20, 400(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f19, 392(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f18, 384(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f17, 376(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f16, 368(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f15, 360(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lfd f14, 352(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r31, 348(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r30, 344(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r29, 340(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r28, 336(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r27, 332(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r26, 328(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r25, 324(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r24, 320(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r23, 316(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r22, 312(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r21, 308(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r20, 304(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r19, 300(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r18, 296(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r17, 292(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r16, 288(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r15, 284(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r4, 16(r4)
+; BE-32BIT-P10-PRIV-NEXT:    add r3, r4, r3
+; BE-32BIT-P10-PRIV-NEXT:    lwz r14, 280(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    lwz r13, 276(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    addi r1, r1, 496
+; BE-32BIT-P10-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P10-PRIV-NEXT:    lwz r12, 4(r1)
+; BE-32BIT-P10-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P10-PRIV-NEXT:    hashchkp r0, -424(r1)
+; BE-32BIT-P10-PRIV-NEXT:    mtocrf 32, r12
+; BE-32BIT-P10-PRIV-NEXT:    mtocrf 16, r12
+; BE-32BIT-P10-PRIV-NEXT:    mtocrf 8, r12
+; BE-32BIT-P10-PRIV-NEXT:    blr
+;
+; 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:    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 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:    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:    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:    stxv v25, 160(r1) # 16-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:    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:    stxv v28, 208(r1) # 16-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:    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:    stxv v31, 256(r1) # 16-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-P9-PRIV-NEXT:    stw r30, 344(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stw r31, 348(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f14, 352(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f15, 360(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f16, 368(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f17, 376(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f18, 384(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f19, 392(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f20, 400(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f21, 408(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f22, 416(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f23, 424(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f24, 432(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f25, 440(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f26, 448(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f27, 456(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f28, 464(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f29, 472(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f30, 480(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stfd f31, 488(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stw r3, 64(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    stw r4, 68(r1)
+; BE-32BIT-P9-PRIV-NEXT:    #APP
+; BE-32BIT-P9-PRIV-NEXT:    nop
+; BE-32BIT-P9-PRIV-NEXT:    #NO_APP
+; BE-32BIT-P9-PRIV-NEXT:    addi r3, r1, 68
+; BE-32BIT-P9-PRIV-NEXT:    bl .callee2[PR]
+; BE-32BIT-P9-PRIV-NEXT:    nop
+; BE-32BIT-P9-PRIV-NEXT:    lwz r4, 64(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v31, 256(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v30, 240(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v29, 224(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v28, 208(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v27, 192(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v26, 176(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v25, 160(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v24, 144(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v23, 128(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v22, 112(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v21, 96(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lxv v20, 80(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f31, 488(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f30, 480(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f29, 472(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f28, 464(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f27, 456(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r31, 348(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r30, 344(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r29, 340(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f26, 448(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r28, 336(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r27, 332(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r26, 328(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f25, 440(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r25, 324(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r24, 320(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r23, 316(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f24, 432(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r22, 312(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r21, 308(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r4, 16(r4)
+; BE-32BIT-P9-PRIV-NEXT:    add r3, r4, r3
+; BE-32BIT-P9-PRIV-NEXT:    lfd f23, 424(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f22, 416(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r20, 304(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r19, 300(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r18, 296(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r17, 292(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r16, 288(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r15, 284(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r14, 280(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lwz r13, 276(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f21, 408(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f20, 400(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f19, 392(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f18, 384(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f17, 376(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f16, 368(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f15, 360(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    lfd f14, 352(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    addi r1, r1, 496
+; BE-32BIT-P9-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P9-PRIV-NEXT:    lwz r12, 4(r1)
+; BE-32BIT-P9-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P9-PRIV-NEXT:    hashchkp r0, -424(r1)
+; BE-32BIT-P9-PRIV-NEXT:    mtocrf 32, r12
+; BE-32BIT-P9-PRIV-NEXT:    mtocrf 16, r12
+; BE-32BIT-P9-PRIV-NEXT:    mtocrf 8, r12
+; BE-32BIT-P9-PRIV-NEXT:    blr
+;
+; BE-32BIT-P8-PRIV-LABEL: 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 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:    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:    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:    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:    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:    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:    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:    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:    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:    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:    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:    stxvd2x v31, r1, r4 # 16-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    lwz r4, 12(r3)
+; 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-32BIT-P8-PRIV-NEXT:    stw r29, 340(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stw r30, 344(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stw r31, 348(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f14, 352(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f15, 360(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f16, 368(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f17, 376(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f18, 384(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f19, 392(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f20, 400(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f21, 408(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f22, 416(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f23, 424(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f24, 432(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f25, 440(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f26, 448(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f27, 456(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f28, 464(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f29, 472(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f30, 480(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stfd f31, 488(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stw r3, 64(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    stw r4, 68(r1)
+; BE-32BIT-P8-PRIV-NEXT:    #APP
+; BE-32BIT-P8-PRIV-NEXT:    nop
+; BE-32BIT-P8-PRIV-NEXT:    #NO_APP
+; BE-32BIT-P8-PRIV-NEXT:    addi r3, r1, 68
+; BE-32BIT-P8-PRIV-NEXT:    bl .callee2[PR]
+; BE-32BIT-P8-PRIV-NEXT:    nop
+; BE-32BIT-P8-PRIV-NEXT:    lwz r4, 64(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lfd f31, 488(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lfd f30, 480(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r31, 348(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lfd f29, 472(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lfd f28, 464(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r30, 344(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r29, 340(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r4, 16(r4)
+; BE-32BIT-P8-PRIV-NEXT:    lfd f27, 456(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lfd f26, 448(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r28, 336(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lfd f25, 440(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lfd f24, 432(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r27, 332(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r26, 328(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    add r3, r4, r3
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 256
+; BE-32BIT-P8-PRIV-NEXT:    lfd f23, 424(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lfd f22, 416(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r25, 324(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r24, 320(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v31, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 240
+; BE-32BIT-P8-PRIV-NEXT:    lfd f21, 408(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r23, 316(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r22, 312(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v30, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 224
+; BE-32BIT-P8-PRIV-NEXT:    lfd f20, 400(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r21, 308(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r20, 304(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v29, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 208
+; BE-32BIT-P8-PRIV-NEXT:    lfd f19, 392(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r19, 300(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r18, 296(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v28, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 192
+; BE-32BIT-P8-PRIV-NEXT:    lfd f18, 384(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r17, 292(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r16, 288(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v27, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 176
+; BE-32BIT-P8-PRIV-NEXT:    lfd f17, 376(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r15, 284(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r14, 280(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v26, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 160
+; BE-32BIT-P8-PRIV-NEXT:    lfd f16, 368(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lwz r13, 276(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v25, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 144
+; BE-32BIT-P8-PRIV-NEXT:    lfd f15, 360(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v24, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 128
+; BE-32BIT-P8-PRIV-NEXT:    lfd f14, 352(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v23, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 112
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v22, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 96
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v21, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    li r4, 80
+; BE-32BIT-P8-PRIV-NEXT:    lxvd2x v20, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    addi r1, r1, 496
+; BE-32BIT-P8-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P8-PRIV-NEXT:    lwz r12, 4(r1)
+; BE-32BIT-P8-PRIV-NEXT:    mtocrf 32, r12
+; BE-32BIT-P8-PRIV-NEXT:    hashchkp r0, -424(r1)
+; BE-32BIT-P8-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P8-PRIV-NEXT:    mtocrf 16, r12
+; BE-32BIT-P8-PRIV-NEXT:    mtocrf 8, r12
+; BE-32BIT-P8-PRIV-NEXT:    blr
+entry:
+  %local = alloca i32, align 4
+  %0 = bitcast i32* %local to i8*
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %0)
+  %arrayidx = getelementptr inbounds i32, i32* %in, i64 3
+  %1 = load i32, i32* %arrayidx, align 4
+  store i32 %1, i32* %local, align 4
+  tail call void asm sideeffect "nop", "~{cr2},~{cr3},~{cr4},~{r0},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{r16},~{r17},~{r18},~{r19},~{r20},~{r21},~{r22},~{r23},~{r24},~{r25},~{r26},~{r27},~{r28},~{r29},~{r30},~{r31},~{f14},~{f15},~{f16},~{f17},~{f18},~{f19},~{f20},~{f21},~{f22},~{f23},~{f24},~{f25},~{f26},~{f27},~{f28},~{f29},~{f30},~{f31},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
+  %call = call zeroext i32 @callee2(i32* nonnull %local)
+  %arrayidx1 = getelementptr inbounds i32, i32* %in, i64 4
+  %2 = load i32, i32* %arrayidx1, align 4
+  %add = add i32 %2, %call
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %0)
+  ret i32 %add
+}
+
+define dso_local zeroext i32 @shrinkwrap(i32* readonly %in) #0 {
+; BE-P10-LABEL: shrinkwrap:
+; BE-P10:       # %bb.0: # %entry
+; BE-P10-NEXT:    cmpldi r3, 0
+; BE-P10-NEXT:    beq cr0, L..BB2_2
+; BE-P10-NEXT:  # %bb.1: # %if.end
+; BE-P10-NEXT:    mflr r0
+; BE-P10-NEXT:    std r0, 16(r1)
+; BE-P10-NEXT:    hashst r0, -16(r1)
+; BE-P10-NEXT:    stdu r1, -144(r1)
+; BE-P10-NEXT:    std r31, 136(r1) # 8-byte Folded Spill
+; BE-P10-NEXT:    mr r31, r3
+; BE-P10-NEXT:    lwz r3, 12(r3)
+; BE-P10-NEXT:    stw r3, 124(r1)
+; BE-P10-NEXT:    addi r3, r1, 124
+; BE-P10-NEXT:    bl .callee2[PR]
+; BE-P10-NEXT:    nop
+; BE-P10-NEXT:    lwz r4, 16(r31)
+; BE-P10-NEXT:    ld r31, 136(r1) # 8-byte Folded Reload
+; BE-P10-NEXT:    add r3, r4, r3
+; BE-P10-NEXT:    addi r1, r1, 144
+; BE-P10-NEXT:    ld r0, 16(r1)
+; BE-P10-NEXT:    clrldi r3, r3, 32
+; BE-P10-NEXT:    hashchk r0, -16(r1)
+; BE-P10-NEXT:    mtlr r0
+; BE-P10-NEXT:    blr
+; BE-P10-NEXT:  L..BB2_2:
+; BE-P10-NEXT:    li r3, 0
+; BE-P10-NEXT:    blr
+;
+; BE-P9-LABEL: shrinkwrap:
+; BE-P9:       # %bb.0: # %entry
+; BE-P9-NEXT:    cmpldi r3, 0
+; 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 r31, 136(r1) # 8-byte Folded Spill
+; BE-P9-NEXT:    mr r31, r3
+; BE-P9-NEXT:    lwz r3, 12(r3)
+; BE-P9-NEXT:    stw r3, 124(r1)
+; BE-P9-NEXT:    addi r3, r1, 124
+; BE-P9-NEXT:    bl .callee2[PR]
+; BE-P9-NEXT:    nop
+; BE-P9-NEXT:    lwz r4, 16(r31)
+; BE-P9-NEXT:    ld r31, 136(r1) # 8-byte Folded Reload
+; BE-P9-NEXT:    add r3, r4, r3
+; BE-P9-NEXT:    addi r1, r1, 144
+; BE-P9-NEXT:    ld r0, 16(r1)
+; BE-P9-NEXT:    clrldi r3, r3, 32
+; BE-P9-NEXT:    mtlr r0
+; BE-P9-NEXT:    hashchk r0, -16(r1)
+; BE-P9-NEXT:    blr
+; BE-P9-NEXT:  L..BB2_2:
+; BE-P9-NEXT:    li r3, 0
+; BE-P9-NEXT:    blr
+;
+; BE-P8-LABEL: shrinkwrap:
+; BE-P8:       # %bb.0: # %entry
+; BE-P8-NEXT:    cmpldi r3, 0
+; 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 r31, 136(r1) # 8-byte Folded Spill
+; BE-P8-NEXT:    mr r31, r3
+; BE-P8-NEXT:    lwz r3, 12(r3)
+; BE-P8-NEXT:    stw r3, 124(r1)
+; BE-P8-NEXT:    addi r3, r1, 124
+; BE-P8-NEXT:    bl .callee2[PR]
+; BE-P8-NEXT:    nop
+; BE-P8-NEXT:    lwz r4, 16(r31)
+; BE-P8-NEXT:    ld r31, 136(r1) # 8-byte Folded Reload
+; BE-P8-NEXT:    add r3, r4, r3
+; BE-P8-NEXT:    addi r1, r1, 144
+; BE-P8-NEXT:    ld r0, 16(r1)
+; BE-P8-NEXT:    clrldi r3, r3, 32
+; BE-P8-NEXT:    hashchk r0, -16(r1)
+; BE-P8-NEXT:    mtlr r0
+; BE-P8-NEXT:    blr
+; BE-P8-NEXT:  L..BB2_2:
+; BE-P8-NEXT:    li r3, 0
+; BE-P8-NEXT:    blr
+;
+; BE-32BIT-P10-LABEL: shrinkwrap:
+; BE-32BIT-P10:       # %bb.0: # %entry
+; BE-32BIT-P10-NEXT:    cmplwi r3, 0
+; BE-32BIT-P10-NEXT:    beq cr0, L..BB2_2
+; BE-32BIT-P10-NEXT:  # %bb.1: # %if.end
+; BE-32BIT-P10-NEXT:    mflr r0
+; BE-32BIT-P10-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P10-NEXT:    hashst r0, -16(r1)
+; BE-32BIT-P10-NEXT:    stwu r1, -80(r1)
+; BE-32BIT-P10-NEXT:    stw r31, 76(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    mr r31, r3
+; BE-32BIT-P10-NEXT:    lwz r3, 12(r3)
+; BE-32BIT-P10-NEXT:    stw r3, 60(r1)
+; BE-32BIT-P10-NEXT:    addi r3, r1, 60
+; BE-32BIT-P10-NEXT:    bl .callee2[PR]
+; BE-32BIT-P10-NEXT:    nop
+; BE-32BIT-P10-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P10-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    add r3, r4, r3
+; BE-32BIT-P10-NEXT:    addi r1, r1, 80
+; BE-32BIT-P10-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P10-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P10-NEXT:    mtlr r0
+; BE-32BIT-P10-NEXT:    blr
+; BE-32BIT-P10-NEXT:  L..BB2_2:
+; BE-32BIT-P10-NEXT:    li r3, 0
+; BE-32BIT-P10-NEXT:    blr
+;
+; BE-32BIT-P9-LABEL: shrinkwrap:
+; BE-32BIT-P9:       # %bb.0: # %entry
+; BE-32BIT-P9-NEXT:    cmplwi r3, 0
+; 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 r31, 76(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    mr r31, r3
+; BE-32BIT-P9-NEXT:    lwz r3, 12(r3)
+; BE-32BIT-P9-NEXT:    stw r3, 60(r1)
+; BE-32BIT-P9-NEXT:    addi r3, r1, 60
+; BE-32BIT-P9-NEXT:    bl .callee2[PR]
+; BE-32BIT-P9-NEXT:    nop
+; BE-32BIT-P9-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P9-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    add r3, r4, r3
+; BE-32BIT-P9-NEXT:    addi r1, r1, 80
+; BE-32BIT-P9-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P9-NEXT:    mtlr r0
+; BE-32BIT-P9-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P9-NEXT:    blr
+; BE-32BIT-P9-NEXT:  L..BB2_2:
+; BE-32BIT-P9-NEXT:    li r3, 0
+; BE-32BIT-P9-NEXT:    blr
+;
+; BE-32BIT-P8-LABEL: shrinkwrap:
+; BE-32BIT-P8:       # %bb.0: # %entry
+; BE-32BIT-P8-NEXT:    cmplwi r3, 0
+; 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 r31, 76(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    mr r31, r3
+; BE-32BIT-P8-NEXT:    lwz r3, 12(r3)
+; BE-32BIT-P8-NEXT:    stw r3, 60(r1)
+; BE-32BIT-P8-NEXT:    addi r3, r1, 60
+; BE-32BIT-P8-NEXT:    bl .callee2[PR]
+; BE-32BIT-P8-NEXT:    nop
+; BE-32BIT-P8-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P8-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    add r3, r4, r3
+; BE-32BIT-P8-NEXT:    addi r1, r1, 80
+; BE-32BIT-P8-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P8-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P8-NEXT:    mtlr r0
+; BE-32BIT-P8-NEXT:    blr
+; BE-32BIT-P8-NEXT:  L..BB2_2:
+; BE-32BIT-P8-NEXT:    li r3, 0
+; BE-32BIT-P8-NEXT:    blr
+;
+; BE-P10-PRIV-LABEL: shrinkwrap:
+; BE-P10-PRIV:       # %bb.0: # %entry
+; BE-P10-PRIV-NEXT:    cmpldi r3, 0
+; BE-P10-PRIV-NEXT:    beq cr0, L..BB2_2
+; BE-P10-PRIV-NEXT:  # %bb.1: # %if.end
+; BE-P10-PRIV-NEXT:    mflr r0
+; BE-P10-PRIV-NEXT:    std r0, 16(r1)
+; BE-P10-PRIV-NEXT:    hashstp r0, -16(r1)
+; BE-P10-PRIV-NEXT:    stdu r1, -144(r1)
+; BE-P10-PRIV-NEXT:    std r31, 136(r1) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    mr r31, r3
+; BE-P10-PRIV-NEXT:    lwz r3, 12(r3)
+; BE-P10-PRIV-NEXT:    stw r3, 124(r1)
+; BE-P10-PRIV-NEXT:    addi r3, r1, 124
+; BE-P10-PRIV-NEXT:    bl .callee2[PR]
+; BE-P10-PRIV-NEXT:    nop
+; BE-P10-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-P10-PRIV-NEXT:    ld r31, 136(r1) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    add r3, r4, r3
+; BE-P10-PRIV-NEXT:    addi r1, r1, 144
+; BE-P10-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P10-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P10-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-P10-PRIV-NEXT:    mtlr r0
+; BE-P10-PRIV-NEXT:    blr
+; BE-P10-PRIV-NEXT:  L..BB2_2:
+; BE-P10-PRIV-NEXT:    li r3, 0
+; BE-P10-PRIV-NEXT:    blr
+;
+; BE-P9-PRIV-LABEL: shrinkwrap:
+; BE-P9-PRIV:       # %bb.0: # %entry
+; BE-P9-PRIV-NEXT:    cmpldi r3, 0
+; 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 r31, 136(r1) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    mr r31, r3
+; BE-P9-PRIV-NEXT:    lwz r3, 12(r3)
+; BE-P9-PRIV-NEXT:    stw r3, 124(r1)
+; BE-P9-PRIV-NEXT:    addi r3, r1, 124
+; BE-P9-PRIV-NEXT:    bl .callee2[PR]
+; BE-P9-PRIV-NEXT:    nop
+; BE-P9-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-P9-PRIV-NEXT:    ld r31, 136(r1) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    add r3, r4, r3
+; BE-P9-PRIV-NEXT:    addi r1, r1, 144
+; BE-P9-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P9-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P9-PRIV-NEXT:    mtlr r0
+; BE-P9-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-P9-PRIV-NEXT:    blr
+; BE-P9-PRIV-NEXT:  L..BB2_2:
+; BE-P9-PRIV-NEXT:    li r3, 0
+; BE-P9-PRIV-NEXT:    blr
+;
+; BE-P8-PRIV-LABEL: shrinkwrap:
+; BE-P8-PRIV:       # %bb.0: # %entry
+; BE-P8-PRIV-NEXT:    cmpldi r3, 0
+; 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 r31, 136(r1) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    mr r31, r3
+; BE-P8-PRIV-NEXT:    lwz r3, 12(r3)
+; BE-P8-PRIV-NEXT:    stw r3, 124(r1)
+; BE-P8-PRIV-NEXT:    addi r3, r1, 124
+; BE-P8-PRIV-NEXT:    bl .callee2[PR]
+; BE-P8-PRIV-NEXT:    nop
+; BE-P8-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-P8-PRIV-NEXT:    ld r31, 136(r1) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    add r3, r4, r3
+; BE-P8-PRIV-NEXT:    addi r1, r1, 144
+; BE-P8-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P8-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P8-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-P8-PRIV-NEXT:    mtlr r0
+; BE-P8-PRIV-NEXT:    blr
+; BE-P8-PRIV-NEXT:  L..BB2_2:
+; BE-P8-PRIV-NEXT:    li r3, 0
+; BE-P8-PRIV-NEXT:    blr
+;
+; BE-32BIT-P10-PRIV-LABEL: shrinkwrap:
+; BE-32BIT-P10-PRIV:       # %bb.0: # %entry
+; BE-32BIT-P10-PRIV-NEXT:    cmplwi r3, 0
+; BE-32BIT-P10-PRIV-NEXT:    beq cr0, L..BB2_2
+; BE-32BIT-P10-PRIV-NEXT:  # %bb.1: # %if.end
+; BE-32BIT-P10-PRIV-NEXT:    mflr r0
+; BE-32BIT-P10-PRIV-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P10-PRIV-NEXT:    hashstp r0, -16(r1)
+; BE-32BIT-P10-PRIV-NEXT:    stwu r1, -80(r1)
+; BE-32BIT-P10-PRIV-NEXT:    stw r31, 76(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    mr r31, r3
+; BE-32BIT-P10-PRIV-NEXT:    lwz r3, 12(r3)
+; BE-32BIT-P10-PRIV-NEXT:    stw r3, 60(r1)
+; BE-32BIT-P10-PRIV-NEXT:    addi r3, r1, 60
+; BE-32BIT-P10-PRIV-NEXT:    bl .callee2[PR]
+; BE-32BIT-P10-PRIV-NEXT:    nop
+; BE-32BIT-P10-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P10-PRIV-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    add r3, r4, r3
+; BE-32BIT-P10-PRIV-NEXT:    addi r1, r1, 80
+; BE-32BIT-P10-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P10-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-32BIT-P10-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P10-PRIV-NEXT:    blr
+; BE-32BIT-P10-PRIV-NEXT:  L..BB2_2:
+; BE-32BIT-P10-PRIV-NEXT:    li r3, 0
+; BE-32BIT-P10-PRIV-NEXT:    blr
+;
+; BE-32BIT-P9-PRIV-LABEL: shrinkwrap:
+; BE-32BIT-P9-PRIV:       # %bb.0: # %entry
+; BE-32BIT-P9-PRIV-NEXT:    cmplwi r3, 0
+; 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 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-P9-PRIV-NEXT:    stw r3, 60(r1)
+; BE-32BIT-P9-PRIV-NEXT:    addi r3, r1, 60
+; BE-32BIT-P9-PRIV-NEXT:    bl .callee2[PR]
+; BE-32BIT-P9-PRIV-NEXT:    nop
+; BE-32BIT-P9-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P9-PRIV-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    add r3, r4, r3
+; BE-32BIT-P9-PRIV-NEXT:    addi r1, r1, 80
+; BE-32BIT-P9-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P9-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P9-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-32BIT-P9-PRIV-NEXT:    blr
+; BE-32BIT-P9-PRIV-NEXT:  L..BB2_2:
+; BE-32BIT-P9-PRIV-NEXT:    li r3, 0
+; BE-32BIT-P9-PRIV-NEXT:    blr
+;
+; BE-32BIT-P8-PRIV-LABEL: shrinkwrap:
+; BE-32BIT-P8-PRIV:       # %bb.0: # %entry
+; BE-32BIT-P8-PRIV-NEXT:    cmplwi r3, 0
+; 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 r31, 76(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    mr r31, r3
+; BE-32BIT-P8-PRIV-NEXT:    lwz r3, 12(r3)
+; BE-32BIT-P8-PRIV-NEXT:    stw r3, 60(r1)
+; BE-32BIT-P8-PRIV-NEXT:    addi r3, r1, 60
+; BE-32BIT-P8-PRIV-NEXT:    bl .callee2[PR]
+; BE-32BIT-P8-PRIV-NEXT:    nop
+; BE-32BIT-P8-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P8-PRIV-NEXT:    lwz r31, 76(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    add r3, r4, r3
+; BE-32BIT-P8-PRIV-NEXT:    addi r1, r1, 80
+; BE-32BIT-P8-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P8-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-32BIT-P8-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P8-PRIV-NEXT:    blr
+; BE-32BIT-P8-PRIV-NEXT:  L..BB2_2:
+; BE-32BIT-P8-PRIV-NEXT:    li r3, 0
+; BE-32BIT-P8-PRIV-NEXT:    blr
+entry:
+  %local = alloca i32, align 4
+  %tobool.not = icmp eq i32* %in, null
+  br i1 %tobool.not, label %return, label %if.end
+
+if.end:                                           ; preds = %entry
+  %0 = bitcast i32* %local to i8*
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %0)
+  %arrayidx = getelementptr inbounds i32, i32* %in, i64 3
+  %1 = load i32, i32* %arrayidx, align 4
+  store i32 %1, i32* %local, align 4
+  %call = call zeroext i32 @callee2(i32* nonnull %local)
+  %arrayidx1 = getelementptr inbounds i32, i32* %in, i64 4
+  %2 = load i32, i32* %arrayidx1, align 4
+  %add = add i32 %2, %call
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %0)
+  br label %return
+
+return:                                           ; preds = %entry, %if.end
+  %retval.0 = phi i32 [ %add, %if.end ], [ 0, %entry ]
+  ret i32 %retval.0
+}
+
+define dso_local zeroext i32 @aligned(i32* nocapture readonly %in) #0 {
+; BE-P10-LABEL: aligned:
+; BE-P10:       # %bb.0: # %entry
+; BE-P10-NEXT:    mflr r0
+; BE-P10-NEXT:    lis r12, -1
+; BE-P10-NEXT:    std r30, -16(r1)
+; BE-P10-NEXT:    mr r30, r1
+; BE-P10-NEXT:    std r0, 16(r1)
+; BE-P10-NEXT:    hashst r0, -24(r1)
+; BE-P10-NEXT:    clrldi r0, r1, 49
+; BE-P10-NEXT:    ori r12, r12, 0
+; BE-P10-NEXT:    subc r0, r12, r0
+; BE-P10-NEXT:    stdux r1, r1, r0
+; BE-P10-NEXT:    std r31, -8(r30) # 8-byte Folded Spill
+; BE-P10-NEXT:    mr r31, r3
+; BE-P10-NEXT:    lwz r3, 4(r3)
+; BE-P10-NEXT:    lis r4, 0
+; BE-P10-NEXT:    addi r5, r1, 32764
+; BE-P10-NEXT:    ori r4, r4, 65508
+; BE-P10-NEXT:    stwx r3, r1, r4
+; BE-P10-NEXT:    lwz r3, 12(r31)
+; BE-P10-NEXT:    lis r4, 0
+; BE-P10-NEXT:    ori r4, r4, 32768
+; BE-P10-NEXT:    stwx r3, r1, r4
+; BE-P10-NEXT:    lwz r3, 20(r31)
+; BE-P10-NEXT:    lis r4, 0
+; BE-P10-NEXT:    ori r4, r4, 65508
+; BE-P10-NEXT:    add r4, r1, r4
+; BE-P10-NEXT:    stw r3, 32764(r1)
+; BE-P10-NEXT:    lis r3, 0
+; BE-P10-NEXT:    ori r3, r3, 32768
+; BE-P10-NEXT:    add r3, r1, r3
+; BE-P10-NEXT:    bl .callee3[PR]
+; BE-P10-NEXT:    nop
+; BE-P10-NEXT:    lwz r4, 16(r31)
+; BE-P10-NEXT:    ld r31, -8(r30) # 8-byte Folded Reload
+; BE-P10-NEXT:    add r3, r4, r3
+; BE-P10-NEXT:    clrldi r3, r3, 32
+; BE-P10-NEXT:    mr r1, r30
+; BE-P10-NEXT:    ld r0, 16(r1)
+; BE-P10-NEXT:    ld r30, -16(r1)
+; BE-P10-NEXT:    mtlr r0
+; BE-P10-NEXT:    hashchk r0, -24(r1)
+; BE-P10-NEXT:    blr
+;
+; BE-P9-LABEL: aligned:
+; BE-P9:       # %bb.0: # %entry
+; BE-P9-NEXT:    mflr r0
+; BE-P9-NEXT:    lis r12, -1
+; BE-P9-NEXT:    std r30, -16(r1)
+; BE-P9-NEXT:    mr r30, r1
+; BE-P9-NEXT:    ori r12, r12, 0
+; BE-P9-NEXT:    std r0, 16(r1)
+; BE-P9-NEXT:    hashst r0, -24(r1)
+; BE-P9-NEXT:    clrldi r0, r1, 49
+; BE-P9-NEXT:    subc r0, r12, r0
+; BE-P9-NEXT:    stdux r1, r1, r0
+; BE-P9-NEXT:    std r31, -8(r30) # 8-byte Folded Spill
+; BE-P9-NEXT:    mr r31, r3
+; BE-P9-NEXT:    lwz r3, 4(r3)
+; BE-P9-NEXT:    lis r4, 0
+; BE-P9-NEXT:    addi r5, r1, 32764
+; BE-P9-NEXT:    ori r4, r4, 65508
+; BE-P9-NEXT:    stwx r3, r1, r4
+; BE-P9-NEXT:    lwz r3, 12(r31)
+; BE-P9-NEXT:    lis r4, 0
+; BE-P9-NEXT:    ori r4, r4, 32768
+; BE-P9-NEXT:    stwx r3, r1, r4
+; BE-P9-NEXT:    lwz r3, 20(r31)
+; BE-P9-NEXT:    lis r4, 0
+; BE-P9-NEXT:    ori r4, r4, 65508
+; BE-P9-NEXT:    stw r3, 32764(r1)
+; BE-P9-NEXT:    lis r3, 0
+; BE-P9-NEXT:    add r4, r1, r4
+; BE-P9-NEXT:    ori r3, r3, 32768
+; BE-P9-NEXT:    add r3, r1, r3
+; BE-P9-NEXT:    bl .callee3[PR]
+; BE-P9-NEXT:    nop
+; BE-P9-NEXT:    lwz r4, 16(r31)
+; BE-P9-NEXT:    ld r31, -8(r30) # 8-byte Folded Reload
+; BE-P9-NEXT:    add r3, r4, r3
+; BE-P9-NEXT:    clrldi r3, r3, 32
+; BE-P9-NEXT:    mr r1, r30
+; BE-P9-NEXT:    ld r0, 16(r1)
+; BE-P9-NEXT:    ld r30, -16(r1)
+; BE-P9-NEXT:    mtlr r0
+; BE-P9-NEXT:    hashchk r0, -24(r1)
+; BE-P9-NEXT:    blr
+;
+; BE-P8-LABEL: aligned:
+; BE-P8:       # %bb.0: # %entry
+; BE-P8-NEXT:    mflr r0
+; BE-P8-NEXT:    lis r12, -1
+; BE-P8-NEXT:    std r30, -16(r1)
+; BE-P8-NEXT:    mr r30, r1
+; BE-P8-NEXT:    std r0, 16(r1)
+; BE-P8-NEXT:    hashst r0, -24(r1)
+; BE-P8-NEXT:    clrldi r0, r1, 49
+; BE-P8-NEXT:    ori r12, r12, 0
+; BE-P8-NEXT:    subc r0, r12, r0
+; BE-P8-NEXT:    stdux r1, r1, r0
+; BE-P8-NEXT:    std r31, -8(r30) # 8-byte Folded Spill
+; BE-P8-NEXT:    mr r31, r3
+; BE-P8-NEXT:    lwz r3, 4(r3)
+; BE-P8-NEXT:    lis r6, 0
+; BE-P8-NEXT:    ori r6, r6, 65508
+; BE-P8-NEXT:    lwz r4, 12(r31)
+; BE-P8-NEXT:    lwz r5, 20(r31)
+; BE-P8-NEXT:    stwx r3, r1, r6
+; BE-P8-NEXT:    lis r3, 0
+; BE-P8-NEXT:    ori r3, r3, 32768
+; BE-P8-NEXT:    stw r5, 32764(r1)
+; BE-P8-NEXT:    addi r5, r1, 32764
+; BE-P8-NEXT:    stwx r4, r1, r3
+; BE-P8-NEXT:    lis r3, 0
+; BE-P8-NEXT:    lis r4, 0
+; BE-P8-NEXT:    ori r3, r3, 32768
+; BE-P8-NEXT:    ori r4, r4, 65508
+; BE-P8-NEXT:    add r3, r1, r3
+; BE-P8-NEXT:    add r4, r1, r4
+; BE-P8-NEXT:    bl .callee3[PR]
+; BE-P8-NEXT:    nop
+; BE-P8-NEXT:    lwz r4, 16(r31)
+; BE-P8-NEXT:    ld r31, -8(r30) # 8-byte Folded Reload
+; BE-P8-NEXT:    add r3, r4, r3
+; BE-P8-NEXT:    clrldi r3, r3, 32
+; BE-P8-NEXT:    mr r1, r30
+; BE-P8-NEXT:    ld r0, 16(r1)
+; BE-P8-NEXT:    ld r30, -16(r1)
+; BE-P8-NEXT:    hashchk r0, -24(r1)
+; BE-P8-NEXT:    mtlr r0
+; BE-P8-NEXT:    blr
+;
+; BE-32BIT-P10-LABEL: aligned:
+; BE-32BIT-P10:       # %bb.0: # %entry
+; BE-32BIT-P10-NEXT:    mflr r0
+; BE-32BIT-P10-NEXT:    lis r12, -1
+; BE-32BIT-P10-NEXT:    stw r30, -8(r1)
+; BE-32BIT-P10-NEXT:    mr r30, r1
+; BE-32BIT-P10-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P10-NEXT:    hashst r0, -16(r1)
+; BE-32BIT-P10-NEXT:    clrlwi r0, r1, 17
+; BE-32BIT-P10-NEXT:    ori r12, r12, 0
+; BE-32BIT-P10-NEXT:    subc r0, r12, r0
+; BE-32BIT-P10-NEXT:    stwux r1, r1, r0
+; BE-32BIT-P10-NEXT:    stw r31, -4(r30) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    mr r31, r3
+; BE-32BIT-P10-NEXT:    lwz r3, 4(r3)
+; BE-32BIT-P10-NEXT:    lis r4, 0
+; BE-32BIT-P10-NEXT:    addi r5, r1, 32764
+; BE-32BIT-P10-NEXT:    ori r4, r4, 65516
+; BE-32BIT-P10-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P10-NEXT:    lwz r3, 12(r31)
+; BE-32BIT-P10-NEXT:    lis r4, 0
+; BE-32BIT-P10-NEXT:    ori r4, r4, 32768
+; BE-32BIT-P10-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P10-NEXT:    lwz r3, 20(r31)
+; BE-32BIT-P10-NEXT:    lis r4, 0
+; BE-32BIT-P10-NEXT:    ori r4, r4, 65516
+; BE-32BIT-P10-NEXT:    add r4, r1, r4
+; BE-32BIT-P10-NEXT:    stw r3, 32764(r1)
+; BE-32BIT-P10-NEXT:    lis r3, 0
+; BE-32BIT-P10-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P10-NEXT:    add r3, r1, r3
+; BE-32BIT-P10-NEXT:    bl .callee3[PR]
+; BE-32BIT-P10-NEXT:    nop
+; BE-32BIT-P10-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P10-NEXT:    lwz r31, -4(r30) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    add r3, r4, r3
+; BE-32BIT-P10-NEXT:    mr r1, r30
+; BE-32BIT-P10-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P10-NEXT:    lwz r30, -8(r1)
+; BE-32BIT-P10-NEXT:    mtlr r0
+; BE-32BIT-P10-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P10-NEXT:    blr
+;
+; BE-32BIT-P9-LABEL: aligned:
+; BE-32BIT-P9:       # %bb.0: # %entry
+; BE-32BIT-P9-NEXT:    mflr r0
+; BE-32BIT-P9-NEXT:    lis r12, -1
+; BE-32BIT-P9-NEXT:    stw r30, -8(r1)
+; BE-32BIT-P9-NEXT:    mr r30, r1
+; BE-32BIT-P9-NEXT:    ori r12, r12, 0
+; BE-32BIT-P9-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P9-NEXT:    hashst r0, -16(r1)
+; BE-32BIT-P9-NEXT:    clrlwi r0, r1, 17
+; BE-32BIT-P9-NEXT:    subc r0, r12, r0
+; BE-32BIT-P9-NEXT:    stwux r1, r1, r0
+; BE-32BIT-P9-NEXT:    stw r31, -4(r30) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    mr r31, r3
+; BE-32BIT-P9-NEXT:    lwz r3, 4(r3)
+; BE-32BIT-P9-NEXT:    lis r4, 0
+; BE-32BIT-P9-NEXT:    addi r5, r1, 32764
+; BE-32BIT-P9-NEXT:    ori r4, r4, 65516
+; BE-32BIT-P9-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P9-NEXT:    lwz r3, 12(r31)
+; BE-32BIT-P9-NEXT:    lis r4, 0
+; BE-32BIT-P9-NEXT:    ori r4, r4, 32768
+; BE-32BIT-P9-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P9-NEXT:    lwz r3, 20(r31)
+; BE-32BIT-P9-NEXT:    lis r4, 0
+; BE-32BIT-P9-NEXT:    ori r4, r4, 65516
+; BE-32BIT-P9-NEXT:    stw r3, 32764(r1)
+; BE-32BIT-P9-NEXT:    lis r3, 0
+; BE-32BIT-P9-NEXT:    add r4, r1, r4
+; BE-32BIT-P9-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P9-NEXT:    add r3, r1, r3
+; BE-32BIT-P9-NEXT:    bl .callee3[PR]
+; BE-32BIT-P9-NEXT:    nop
+; BE-32BIT-P9-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P9-NEXT:    lwz r31, -4(r30) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    add r3, r4, r3
+; BE-32BIT-P9-NEXT:    mr r1, r30
+; BE-32BIT-P9-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P9-NEXT:    lwz r30, -8(r1)
+; BE-32BIT-P9-NEXT:    mtlr r0
+; BE-32BIT-P9-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P9-NEXT:    blr
+;
+; BE-32BIT-P8-LABEL: aligned:
+; BE-32BIT-P8:       # %bb.0: # %entry
+; BE-32BIT-P8-NEXT:    mflr r0
+; BE-32BIT-P8-NEXT:    lis r12, -1
+; BE-32BIT-P8-NEXT:    stw r30, -8(r1)
+; BE-32BIT-P8-NEXT:    mr r30, r1
+; BE-32BIT-P8-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P8-NEXT:    hashst r0, -16(r1)
+; BE-32BIT-P8-NEXT:    clrlwi r0, r1, 17
+; BE-32BIT-P8-NEXT:    ori r12, r12, 0
+; BE-32BIT-P8-NEXT:    subc r0, r12, r0
+; BE-32BIT-P8-NEXT:    stwux r1, r1, r0
+; BE-32BIT-P8-NEXT:    stw r31, -4(r30) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    mr r31, r3
+; BE-32BIT-P8-NEXT:    lwz r3, 4(r3)
+; BE-32BIT-P8-NEXT:    lis r6, 0
+; BE-32BIT-P8-NEXT:    ori r6, r6, 65516
+; BE-32BIT-P8-NEXT:    lwz r4, 12(r31)
+; BE-32BIT-P8-NEXT:    lwz r5, 20(r31)
+; BE-32BIT-P8-NEXT:    stwx r3, r1, r6
+; BE-32BIT-P8-NEXT:    lis r3, 0
+; BE-32BIT-P8-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P8-NEXT:    stw r5, 32764(r1)
+; BE-32BIT-P8-NEXT:    addi r5, r1, 32764
+; BE-32BIT-P8-NEXT:    stwx r4, r1, r3
+; BE-32BIT-P8-NEXT:    lis r3, 0
+; BE-32BIT-P8-NEXT:    lis r4, 0
+; BE-32BIT-P8-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P8-NEXT:    ori r4, r4, 65516
+; BE-32BIT-P8-NEXT:    add r3, r1, r3
+; BE-32BIT-P8-NEXT:    add r4, r1, r4
+; BE-32BIT-P8-NEXT:    bl .callee3[PR]
+; BE-32BIT-P8-NEXT:    nop
+; BE-32BIT-P8-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P8-NEXT:    lwz r31, -4(r30) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    add r3, r4, r3
+; BE-32BIT-P8-NEXT:    mr r1, r30
+; BE-32BIT-P8-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P8-NEXT:    lwz r30, -8(r1)
+; BE-32BIT-P8-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P8-NEXT:    mtlr r0
+; BE-32BIT-P8-NEXT:    blr
+;
+; BE-P10-PRIV-LABEL: aligned:
+; BE-P10-PRIV:       # %bb.0: # %entry
+; BE-P10-PRIV-NEXT:    mflr r0
+; BE-P10-PRIV-NEXT:    lis r12, -1
+; BE-P10-PRIV-NEXT:    std r30, -16(r1)
+; BE-P10-PRIV-NEXT:    mr r30, r1
+; BE-P10-PRIV-NEXT:    std r0, 16(r1)
+; BE-P10-PRIV-NEXT:    hashstp r0, -24(r1)
+; BE-P10-PRIV-NEXT:    clrldi r0, r1, 49
+; BE-P10-PRIV-NEXT:    ori r12, r12, 0
+; BE-P10-PRIV-NEXT:    subc r0, r12, r0
+; BE-P10-PRIV-NEXT:    stdux r1, r1, r0
+; BE-P10-PRIV-NEXT:    std r31, -8(r30) # 8-byte Folded Spill
+; BE-P10-PRIV-NEXT:    mr r31, r3
+; BE-P10-PRIV-NEXT:    lwz r3, 4(r3)
+; BE-P10-PRIV-NEXT:    lis r4, 0
+; BE-P10-PRIV-NEXT:    addi r5, r1, 32764
+; BE-P10-PRIV-NEXT:    ori r4, r4, 65508
+; BE-P10-PRIV-NEXT:    stwx r3, r1, r4
+; BE-P10-PRIV-NEXT:    lwz r3, 12(r31)
+; BE-P10-PRIV-NEXT:    lis r4, 0
+; BE-P10-PRIV-NEXT:    ori r4, r4, 32768
+; BE-P10-PRIV-NEXT:    stwx r3, r1, r4
+; BE-P10-PRIV-NEXT:    lwz r3, 20(r31)
+; BE-P10-PRIV-NEXT:    lis r4, 0
+; BE-P10-PRIV-NEXT:    ori r4, r4, 65508
+; BE-P10-PRIV-NEXT:    add r4, r1, r4
+; BE-P10-PRIV-NEXT:    stw r3, 32764(r1)
+; BE-P10-PRIV-NEXT:    lis r3, 0
+; BE-P10-PRIV-NEXT:    ori r3, r3, 32768
+; BE-P10-PRIV-NEXT:    add r3, r1, r3
+; BE-P10-PRIV-NEXT:    bl .callee3[PR]
+; BE-P10-PRIV-NEXT:    nop
+; BE-P10-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-P10-PRIV-NEXT:    ld r31, -8(r30) # 8-byte Folded Reload
+; BE-P10-PRIV-NEXT:    add r3, r4, r3
+; BE-P10-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P10-PRIV-NEXT:    mr r1, r30
+; BE-P10-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P10-PRIV-NEXT:    ld r30, -16(r1)
+; BE-P10-PRIV-NEXT:    mtlr r0
+; BE-P10-PRIV-NEXT:    hashchkp r0, -24(r1)
+; BE-P10-PRIV-NEXT:    blr
+;
+; BE-P9-PRIV-LABEL: aligned:
+; BE-P9-PRIV:       # %bb.0: # %entry
+; BE-P9-PRIV-NEXT:    mflr r0
+; BE-P9-PRIV-NEXT:    lis r12, -1
+; BE-P9-PRIV-NEXT:    std r30, -16(r1)
+; BE-P9-PRIV-NEXT:    mr r30, r1
+; BE-P9-PRIV-NEXT:    ori r12, r12, 0
+; BE-P9-PRIV-NEXT:    std r0, 16(r1)
+; BE-P9-PRIV-NEXT:    hashstp r0, -24(r1)
+; BE-P9-PRIV-NEXT:    clrldi r0, r1, 49
+; BE-P9-PRIV-NEXT:    subc r0, r12, r0
+; BE-P9-PRIV-NEXT:    stdux r1, r1, r0
+; BE-P9-PRIV-NEXT:    std r31, -8(r30) # 8-byte Folded Spill
+; BE-P9-PRIV-NEXT:    mr r31, r3
+; BE-P9-PRIV-NEXT:    lwz r3, 4(r3)
+; BE-P9-PRIV-NEXT:    lis r4, 0
+; BE-P9-PRIV-NEXT:    addi r5, r1, 32764
+; BE-P9-PRIV-NEXT:    ori r4, r4, 65508
+; BE-P9-PRIV-NEXT:    stwx r3, r1, r4
+; BE-P9-PRIV-NEXT:    lwz r3, 12(r31)
+; BE-P9-PRIV-NEXT:    lis r4, 0
+; BE-P9-PRIV-NEXT:    ori r4, r4, 32768
+; BE-P9-PRIV-NEXT:    stwx r3, r1, r4
+; BE-P9-PRIV-NEXT:    lwz r3, 20(r31)
+; BE-P9-PRIV-NEXT:    lis r4, 0
+; BE-P9-PRIV-NEXT:    ori r4, r4, 65508
+; BE-P9-PRIV-NEXT:    stw r3, 32764(r1)
+; BE-P9-PRIV-NEXT:    lis r3, 0
+; BE-P9-PRIV-NEXT:    add r4, r1, r4
+; BE-P9-PRIV-NEXT:    ori r3, r3, 32768
+; BE-P9-PRIV-NEXT:    add r3, r1, r3
+; BE-P9-PRIV-NEXT:    bl .callee3[PR]
+; BE-P9-PRIV-NEXT:    nop
+; BE-P9-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-P9-PRIV-NEXT:    ld r31, -8(r30) # 8-byte Folded Reload
+; BE-P9-PRIV-NEXT:    add r3, r4, r3
+; BE-P9-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P9-PRIV-NEXT:    mr r1, r30
+; BE-P9-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P9-PRIV-NEXT:    ld r30, -16(r1)
+; BE-P9-PRIV-NEXT:    mtlr r0
+; BE-P9-PRIV-NEXT:    hashchkp r0, -24(r1)
+; BE-P9-PRIV-NEXT:    blr
+;
+; BE-P8-PRIV-LABEL: aligned:
+; BE-P8-PRIV:       # %bb.0: # %entry
+; BE-P8-PRIV-NEXT:    mflr r0
+; BE-P8-PRIV-NEXT:    lis r12, -1
+; BE-P8-PRIV-NEXT:    std r30, -16(r1)
+; BE-P8-PRIV-NEXT:    mr r30, r1
+; BE-P8-PRIV-NEXT:    std r0, 16(r1)
+; BE-P8-PRIV-NEXT:    hashstp r0, -24(r1)
+; BE-P8-PRIV-NEXT:    clrldi r0, r1, 49
+; BE-P8-PRIV-NEXT:    ori r12, r12, 0
+; BE-P8-PRIV-NEXT:    subc r0, r12, r0
+; BE-P8-PRIV-NEXT:    stdux r1, r1, r0
+; BE-P8-PRIV-NEXT:    std r31, -8(r30) # 8-byte Folded Spill
+; BE-P8-PRIV-NEXT:    mr r31, r3
+; BE-P8-PRIV-NEXT:    lwz r3, 4(r3)
+; BE-P8-PRIV-NEXT:    lis r6, 0
+; BE-P8-PRIV-NEXT:    ori r6, r6, 65508
+; BE-P8-PRIV-NEXT:    lwz r4, 12(r31)
+; BE-P8-PRIV-NEXT:    lwz r5, 20(r31)
+; BE-P8-PRIV-NEXT:    stwx r3, r1, r6
+; BE-P8-PRIV-NEXT:    lis r3, 0
+; BE-P8-PRIV-NEXT:    ori r3, r3, 32768
+; BE-P8-PRIV-NEXT:    stw r5, 32764(r1)
+; BE-P8-PRIV-NEXT:    addi r5, r1, 32764
+; BE-P8-PRIV-NEXT:    stwx r4, r1, r3
+; BE-P8-PRIV-NEXT:    lis r3, 0
+; BE-P8-PRIV-NEXT:    lis r4, 0
+; BE-P8-PRIV-NEXT:    ori r3, r3, 32768
+; BE-P8-PRIV-NEXT:    ori r4, r4, 65508
+; BE-P8-PRIV-NEXT:    add r3, r1, r3
+; BE-P8-PRIV-NEXT:    add r4, r1, r4
+; BE-P8-PRIV-NEXT:    bl .callee3[PR]
+; BE-P8-PRIV-NEXT:    nop
+; BE-P8-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-P8-PRIV-NEXT:    ld r31, -8(r30) # 8-byte Folded Reload
+; BE-P8-PRIV-NEXT:    add r3, r4, r3
+; BE-P8-PRIV-NEXT:    clrldi r3, r3, 32
+; BE-P8-PRIV-NEXT:    mr r1, r30
+; BE-P8-PRIV-NEXT:    ld r0, 16(r1)
+; BE-P8-PRIV-NEXT:    ld r30, -16(r1)
+; BE-P8-PRIV-NEXT:    hashchkp r0, -24(r1)
+; BE-P8-PRIV-NEXT:    mtlr r0
+; BE-P8-PRIV-NEXT:    blr
+;
+; BE-32BIT-P10-PRIV-LABEL: aligned:
+; BE-32BIT-P10-PRIV:       # %bb.0: # %entry
+; BE-32BIT-P10-PRIV-NEXT:    mflr r0
+; BE-32BIT-P10-PRIV-NEXT:    lis r12, -1
+; BE-32BIT-P10-PRIV-NEXT:    stw r30, -8(r1)
+; BE-32BIT-P10-PRIV-NEXT:    mr r30, r1
+; BE-32BIT-P10-PRIV-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P10-PRIV-NEXT:    hashstp r0, -16(r1)
+; BE-32BIT-P10-PRIV-NEXT:    clrlwi r0, r1, 17
+; BE-32BIT-P10-PRIV-NEXT:    ori r12, r12, 0
+; BE-32BIT-P10-PRIV-NEXT:    subc r0, r12, r0
+; BE-32BIT-P10-PRIV-NEXT:    stwux r1, r1, r0
+; BE-32BIT-P10-PRIV-NEXT:    stw r31, -4(r30) # 4-byte Folded Spill
+; BE-32BIT-P10-PRIV-NEXT:    mr r31, r3
+; BE-32BIT-P10-PRIV-NEXT:    lwz r3, 4(r3)
+; BE-32BIT-P10-PRIV-NEXT:    lis r4, 0
+; BE-32BIT-P10-PRIV-NEXT:    addi r5, r1, 32764
+; BE-32BIT-P10-PRIV-NEXT:    ori r4, r4, 65516
+; BE-32BIT-P10-PRIV-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P10-PRIV-NEXT:    lwz r3, 12(r31)
+; BE-32BIT-P10-PRIV-NEXT:    lis r4, 0
+; BE-32BIT-P10-PRIV-NEXT:    ori r4, r4, 32768
+; BE-32BIT-P10-PRIV-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P10-PRIV-NEXT:    lwz r3, 20(r31)
+; BE-32BIT-P10-PRIV-NEXT:    lis r4, 0
+; BE-32BIT-P10-PRIV-NEXT:    ori r4, r4, 65516
+; BE-32BIT-P10-PRIV-NEXT:    add r4, r1, r4
+; BE-32BIT-P10-PRIV-NEXT:    stw r3, 32764(r1)
+; BE-32BIT-P10-PRIV-NEXT:    lis r3, 0
+; BE-32BIT-P10-PRIV-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P10-PRIV-NEXT:    add r3, r1, r3
+; BE-32BIT-P10-PRIV-NEXT:    bl .callee3[PR]
+; BE-32BIT-P10-PRIV-NEXT:    nop
+; BE-32BIT-P10-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P10-PRIV-NEXT:    lwz r31, -4(r30) # 4-byte Folded Reload
+; BE-32BIT-P10-PRIV-NEXT:    add r3, r4, r3
+; BE-32BIT-P10-PRIV-NEXT:    mr r1, r30
+; BE-32BIT-P10-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P10-PRIV-NEXT:    lwz r30, -8(r1)
+; BE-32BIT-P10-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P10-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-32BIT-P10-PRIV-NEXT:    blr
+;
+; BE-32BIT-P9-PRIV-LABEL: aligned:
+; BE-32BIT-P9-PRIV:       # %bb.0: # %entry
+; BE-32BIT-P9-PRIV-NEXT:    mflr r0
+; BE-32BIT-P9-PRIV-NEXT:    lis r12, -1
+; BE-32BIT-P9-PRIV-NEXT:    stw r30, -8(r1)
+; BE-32BIT-P9-PRIV-NEXT:    mr r30, r1
+; BE-32BIT-P9-PRIV-NEXT:    ori r12, r12, 0
+; BE-32BIT-P9-PRIV-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P9-PRIV-NEXT:    hashstp r0, -16(r1)
+; BE-32BIT-P9-PRIV-NEXT:    clrlwi r0, r1, 17
+; BE-32BIT-P9-PRIV-NEXT:    subc r0, r12, r0
+; BE-32BIT-P9-PRIV-NEXT:    stwux r1, r1, r0
+; BE-32BIT-P9-PRIV-NEXT:    stw r31, -4(r30) # 4-byte Folded Spill
+; BE-32BIT-P9-PRIV-NEXT:    mr r31, r3
+; BE-32BIT-P9-PRIV-NEXT:    lwz r3, 4(r3)
+; BE-32BIT-P9-PRIV-NEXT:    lis r4, 0
+; BE-32BIT-P9-PRIV-NEXT:    addi r5, r1, 32764
+; BE-32BIT-P9-PRIV-NEXT:    ori r4, r4, 65516
+; BE-32BIT-P9-PRIV-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P9-PRIV-NEXT:    lwz r3, 12(r31)
+; BE-32BIT-P9-PRIV-NEXT:    lis r4, 0
+; BE-32BIT-P9-PRIV-NEXT:    ori r4, r4, 32768
+; BE-32BIT-P9-PRIV-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P9-PRIV-NEXT:    lwz r3, 20(r31)
+; BE-32BIT-P9-PRIV-NEXT:    lis r4, 0
+; BE-32BIT-P9-PRIV-NEXT:    ori r4, r4, 65516
+; BE-32BIT-P9-PRIV-NEXT:    stw r3, 32764(r1)
+; BE-32BIT-P9-PRIV-NEXT:    lis r3, 0
+; BE-32BIT-P9-PRIV-NEXT:    add r4, r1, r4
+; BE-32BIT-P9-PRIV-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P9-PRIV-NEXT:    add r3, r1, r3
+; BE-32BIT-P9-PRIV-NEXT:    bl .callee3[PR]
+; BE-32BIT-P9-PRIV-NEXT:    nop
+; BE-32BIT-P9-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P9-PRIV-NEXT:    lwz r31, -4(r30) # 4-byte Folded Reload
+; BE-32BIT-P9-PRIV-NEXT:    add r3, r4, r3
+; BE-32BIT-P9-PRIV-NEXT:    mr r1, r30
+; BE-32BIT-P9-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P9-PRIV-NEXT:    lwz r30, -8(r1)
+; BE-32BIT-P9-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P9-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-32BIT-P9-PRIV-NEXT:    blr
+;
+; BE-32BIT-P8-PRIV-LABEL: aligned:
+; BE-32BIT-P8-PRIV:       # %bb.0: # %entry
+; BE-32BIT-P8-PRIV-NEXT:    mflr r0
+; BE-32BIT-P8-PRIV-NEXT:    lis r12, -1
+; BE-32BIT-P8-PRIV-NEXT:    stw r30, -8(r1)
+; BE-32BIT-P8-PRIV-NEXT:    mr r30, r1
+; BE-32BIT-P8-PRIV-NEXT:    stw r0, 8(r1)
+; BE-32BIT-P8-PRIV-NEXT:    hashstp r0, -16(r1)
+; BE-32BIT-P8-PRIV-NEXT:    clrlwi r0, r1, 17
+; BE-32BIT-P8-PRIV-NEXT:    ori r12, r12, 0
+; BE-32BIT-P8-PRIV-NEXT:    subc r0, r12, r0
+; BE-32BIT-P8-PRIV-NEXT:    stwux r1, r1, r0
+; BE-32BIT-P8-PRIV-NEXT:    stw r31, -4(r30) # 4-byte Folded Spill
+; BE-32BIT-P8-PRIV-NEXT:    mr r31, r3
+; BE-32BIT-P8-PRIV-NEXT:    lwz r3, 4(r3)
+; BE-32BIT-P8-PRIV-NEXT:    lis r6, 0
+; BE-32BIT-P8-PRIV-NEXT:    ori r6, r6, 65516
+; BE-32BIT-P8-PRIV-NEXT:    lwz r4, 12(r31)
+; BE-32BIT-P8-PRIV-NEXT:    lwz r5, 20(r31)
+; BE-32BIT-P8-PRIV-NEXT:    stwx r3, r1, r6
+; BE-32BIT-P8-PRIV-NEXT:    lis r3, 0
+; BE-32BIT-P8-PRIV-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P8-PRIV-NEXT:    stw r5, 32764(r1)
+; BE-32BIT-P8-PRIV-NEXT:    addi r5, r1, 32764
+; BE-32BIT-P8-PRIV-NEXT:    stwx r4, r1, r3
+; BE-32BIT-P8-PRIV-NEXT:    lis r3, 0
+; BE-32BIT-P8-PRIV-NEXT:    lis r4, 0
+; BE-32BIT-P8-PRIV-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P8-PRIV-NEXT:    ori r4, r4, 65516
+; BE-32BIT-P8-PRIV-NEXT:    add r3, r1, r3
+; BE-32BIT-P8-PRIV-NEXT:    add r4, r1, r4
+; BE-32BIT-P8-PRIV-NEXT:    bl .callee3[PR]
+; BE-32BIT-P8-PRIV-NEXT:    nop
+; BE-32BIT-P8-PRIV-NEXT:    lwz r4, 16(r31)
+; BE-32BIT-P8-PRIV-NEXT:    lwz r31, -4(r30) # 4-byte Folded Reload
+; BE-32BIT-P8-PRIV-NEXT:    add r3, r4, r3
+; BE-32BIT-P8-PRIV-NEXT:    mr r1, r30
+; BE-32BIT-P8-PRIV-NEXT:    lwz r0, 8(r1)
+; BE-32BIT-P8-PRIV-NEXT:    lwz r30, -8(r1)
+; BE-32BIT-P8-PRIV-NEXT:    hashchkp r0, -16(r1)
+; BE-32BIT-P8-PRIV-NEXT:    mtlr r0
+; BE-32BIT-P8-PRIV-NEXT:    blr
+entry:
+  %beforeLocal = alloca i32, align 4
+  %local = alloca i32, align 32768
+  %afterLocal = alloca i32, align 4
+  %0 = bitcast i32* %beforeLocal to i8*
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %0)
+  %arrayidx = getelementptr inbounds i32, i32* %in, i64 1
+  %1 = load i32, i32* %arrayidx, align 4
+  store i32 %1, i32* %beforeLocal, align 4
+  %2 = bitcast i32* %local to i8*
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %2)
+  %arrayidx1 = getelementptr inbounds i32, i32* %in, i64 3
+  %3 = load i32, i32* %arrayidx1, align 4
+  store i32 %3, i32* %local, align 32768
+  %4 = bitcast i32* %afterLocal to i8*
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %4)
+  %arrayidx2 = getelementptr inbounds i32, i32* %in, i64 5
+  %5 = load i32, i32* %arrayidx2, align 4
+  store i32 %5, i32* %afterLocal, align 4
+  %call = call zeroext i32 @callee3(i32* nonnull %local, i32* nonnull %beforeLocal, i32* nonnull %afterLocal)
+  %arrayidx3 = getelementptr inbounds i32, i32* %in, i64 4
+  %6 = load i32, i32* %arrayidx3, align 4
+  %add = add i32 %6, %call
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %4)
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %2)
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %0)
+  ret i32 %add
+}
+
+declare zeroext i32 @callee(i32 zeroext) local_unnamed_addr
+declare zeroext i32 @callee2(i32*) local_unnamed_addr
+declare zeroext i32 @callee3(i32*, i32*, i32*) local_unnamed_addr
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
+
+attributes #0 = { nounwind }

llvm/test/CodeGen/PowerPC/ppc64-rop-protection.ll

 ; RUN:   -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
 ; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-P10
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr9 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
 ; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-P9
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr8 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
 ; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-P8
+; RUN: llc -verify-machineinstrs -mtriple=powerpc-unknown-linux-gnu \
+; RUN:   -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
+; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-32BIT-P10
+; RUN: llc -verify-machineinstrs -mtriple=powerpc-unknown-linux-gnu \
+; RUN:   -mcpu=pwr9 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
+; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-32BIT-P9
+; RUN: llc -verify-machineinstrs -mtriple=powerpc-unknown-linux-gnu \
+; RUN:   -mcpu=pwr8 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
+; RUN:   -mattr=+rop-protect < %s | FileCheck %s --check-prefix BE-32BIT-P8
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
 ; RUN:   -mattr=+rop-protect -mattr=+privileged < %s | FileCheck %s --check-prefix LE-P10-PRIV
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr9 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
 ; RUN:   -mattr=+rop-protect -mattr=+privileged < %s | FileCheck %s --check-prefix LE-P9-PRIV
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr8 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \

 ; BE-P8-NEXT:    ld r30, 128(r1) # 8-byte Folded Reload
 ; BE-P8-NEXT:    clrldi r3, r3, 32
 ; BE-P8-NEXT:    addi r1, r1, 144
 ; BE-P8-NEXT:    ld r0, 16(r1)
 ; BE-P8-NEXT:    hashchk r0, -24(r1)
 ; BE-P8-NEXT:    mtlr r0
 ; BE-P8-NEXT:    blr
 ;
+; BE-32BIT-P10-LABEL: caller:
+; BE-32BIT-P10:       # %bb.0: # %entry
+; BE-32BIT-P10-NEXT:    mflr r0
+; BE-32BIT-P10-NEXT:    stw r0, 4(r1)
+; BE-32BIT-P10-NEXT:    hashst r0, -16(r1)
+; BE-32BIT-P10-NEXT:    stwu r1, -32(r1)
+; BE-32BIT-P10-NEXT:    stw r30, 24(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    mr r30, r4
+; BE-32BIT-P10-NEXT:    bl callee
+; BE-32BIT-P10-NEXT:    add r3, r3, r30
+; BE-32BIT-P10-NEXT:    lwz r30, 24(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r0, 36(r1)
+; BE-32BIT-P10-NEXT:    addi r1, r1, 32
+; BE-32BIT-P10-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P10-NEXT:    mtlr r0
+; BE-32BIT-P10-NEXT:    blr
+;
+; 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 r30, 24(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    mr r30, r4
+; BE-32BIT-P9-NEXT:    bl callee
+; BE-32BIT-P9-NEXT:    add r3, r3, r30
+; BE-32BIT-P9-NEXT:    lwz r30, 24(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r0, 36(r1)
+; BE-32BIT-P9-NEXT:    addi r1, r1, 32
+; BE-32BIT-P9-NEXT:    mtlr r0
+; BE-32BIT-P9-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P9-NEXT:    blr
+;
+; 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 r30, 24(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    mr r30, r4
+; BE-32BIT-P8-NEXT:    bl callee
+; BE-32BIT-P8-NEXT:    add r3, r3, r30
+; BE-32BIT-P8-NEXT:    lwz r30, 24(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r0, 36(r1)
+; BE-32BIT-P8-NEXT:    addi r1, r1, 32
+; BE-32BIT-P8-NEXT:    mtlr r0
+; BE-32BIT-P8-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P8-NEXT:    blr
+;
 ; LE-P10-PRIV-LABEL: caller:
 ; LE-P10-PRIV:       # %bb.0: # %entry
 ; LE-P10-PRIV-NEXT:    mflr r0
 ; LE-P10-PRIV-NEXT:    std r30, -16(r1) # 8-byte Folded Spill
 ; LE-P10-PRIV-NEXT:    std r0, 16(r1)
 ; LE-P10-PRIV-NEXT:    hashstp r0, -24(r1)
 ; LE-P10-PRIV-NEXT:    stdu r1, -64(r1)
 ; LE-P10-PRIV-NEXT:    mr r30, r4

 ; BE-P8-NEXT:    lwz r12, 8(r1)
 ; BE-P8-NEXT:    mtocrf 32, r12
 ; BE-P8-NEXT:    hashchk r0, -488(r1)
 ; BE-P8-NEXT:    mtlr r0
 ; BE-P8-NEXT:    mtocrf 16, r12
 ; BE-P8-NEXT:    mtocrf 8, r12
 ; BE-P8-NEXT:    blr
 ;
+; BE-32BIT-P10-LABEL: spill:
+; BE-32BIT-P10:       # %bb.0: # %entry
+; BE-32BIT-P10-NEXT:    mflr r0
+; BE-32BIT-P10-NEXT:    stw r0, 4(r1)
+; BE-32BIT-P10-NEXT:    hashst r0, -424(r1)
+; BE-32BIT-P10-NEXT:    stwu r1, -448(r1)
+; BE-32BIT-P10-NEXT:    mfcr r12
+; BE-32BIT-P10-NEXT:    stw r14, 232(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r15, 236(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r16, 240(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r17, 244(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r18, 248(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r19, 252(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r20, 256(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r21, 260(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r22, 264(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r23, 268(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r24, 272(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r25, 276(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r26, 280(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r27, 284(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r28, 288(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r29, 292(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r30, 296(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r31, 300(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r12, 228(r1)
+; BE-32BIT-P10-NEXT:    lwz r4, 12(r3)
+; BE-32BIT-P10-NEXT:    stfd f14, 304(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f15, 312(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f16, 320(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f17, 328(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f18, 336(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f19, 344(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f20, 352(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f21, 360(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f22, 368(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f23, 376(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f24, 384(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f25, 392(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f26, 400(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f27, 408(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f28, 416(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f29, 424(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f30, 432(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stfd f31, 440(r1) # 8-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v20, 32(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v21, 48(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v22, 64(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v23, 80(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v24, 96(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v25, 112(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v26, 128(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v27, 144(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v28, 160(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v29, 176(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v30, 192(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stxv v31, 208(r1) # 16-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r3, 16(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    stw r4, 20(r1)
+; BE-32BIT-P10-NEXT:    #APP
+; BE-32BIT-P10-NEXT:    nop
+; BE-32BIT-P10-NEXT:    #NO_APP
+; BE-32BIT-P10-NEXT:    addi r3, r1, 20
+; BE-32BIT-P10-NEXT:    bl callee2
+; BE-32BIT-P10-NEXT:    lwz r4, 16(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v31, 208(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v30, 192(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v29, 176(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v28, 160(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v27, 144(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v26, 128(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v25, 112(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v24, 96(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v23, 80(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v22, 64(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v21, 48(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lxv v20, 32(r1) # 16-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f31, 440(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f30, 432(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f29, 424(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f28, 416(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f27, 408(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f26, 400(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f25, 392(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f24, 384(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f23, 376(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f22, 368(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f21, 360(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f20, 352(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f19, 344(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f18, 336(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f17, 328(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f16, 320(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lfd f15, 312(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r4, 16(r4)
+; BE-32BIT-P10-NEXT:    add r3, r4, r3
+; BE-32BIT-P10-NEXT:    lwz r12, 228(r1)
+; BE-32BIT-P10-NEXT:    mtocrf 32, r12
+; BE-32BIT-P10-NEXT:    mtocrf 16, r12
+; BE-32BIT-P10-NEXT:    mtocrf 8, r12
+; BE-32BIT-P10-NEXT:    lfd f14, 304(r1) # 8-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r31, 300(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r30, 296(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r29, 292(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r28, 288(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r27, 284(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r26, 280(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r25, 276(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r24, 272(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r23, 268(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r22, 264(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r21, 260(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r20, 256(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r19, 252(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r18, 248(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r17, 244(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r16, 240(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r15, 236(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r14, 232(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r0, 452(r1)
+; BE-32BIT-P10-NEXT:    addi r1, r1, 448
+; BE-32BIT-P10-NEXT:    hashchk r0, -424(r1)
+; BE-32BIT-P10-NEXT:    mtlr r0
+; BE-32BIT-P10-NEXT:    blr
+;
+; 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 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-P9-NEXT:    stw r17, 244(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r18, 248(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r19, 252(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r20, 256(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r21, 260(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r22, 264(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r23, 268(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r24, 272(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r25, 276(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r26, 280(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r27, 284(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r28, 288(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r29, 292(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r30, 296(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r31, 300(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r12, 228(r1)
+; BE-32BIT-P9-NEXT:    stxv v20, 32(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v21, 48(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v22, 64(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v23, 80(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v24, 96(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v25, 112(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v26, 128(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v27, 144(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v28, 160(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v29, 176(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v30, 192(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stxv v31, 208(r1) # 16-byte Folded Spill
+; BE-32BIT-P9-NEXT:    lwz r4, 12(r3)
+; BE-32BIT-P9-NEXT:    stfd f14, 304(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f15, 312(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f16, 320(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f17, 328(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f18, 336(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f19, 344(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f20, 352(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f21, 360(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f22, 368(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f23, 376(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f24, 384(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f25, 392(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f26, 400(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f27, 408(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f28, 416(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f29, 424(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f30, 432(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stfd f31, 440(r1) # 8-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r3, 16(r1) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    stw r4, 20(r1)
+; BE-32BIT-P9-NEXT:    #APP
+; BE-32BIT-P9-NEXT:    nop
+; BE-32BIT-P9-NEXT:    #NO_APP
+; BE-32BIT-P9-NEXT:    addi r3, r1, 20
+; BE-32BIT-P9-NEXT:    bl callee2
+; BE-32BIT-P9-NEXT:    lwz r4, 16(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v31, 208(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v30, 192(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v29, 176(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v28, 160(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v27, 144(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v26, 128(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v25, 112(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v24, 96(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v23, 80(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v22, 64(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v21, 48(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lxv v20, 32(r1) # 16-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f31, 440(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f30, 432(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f29, 424(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f28, 416(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f27, 408(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r4, 16(r4)
+; BE-32BIT-P9-NEXT:    lfd f26, 400(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    add r3, r4, r3
+; BE-32BIT-P9-NEXT:    lfd f25, 392(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f24, 384(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f23, 376(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f22, 368(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f21, 360(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f20, 352(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f19, 344(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f18, 336(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f17, 328(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f16, 320(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f15, 312(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r12, 228(r1)
+; BE-32BIT-P9-NEXT:    lwz r31, 300(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r30, 296(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r29, 292(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r28, 288(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r27, 284(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r26, 280(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r25, 276(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r24, 272(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r23, 268(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r22, 264(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r21, 260(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r20, 256(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r19, 252(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r18, 248(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r17, 244(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r16, 240(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r15, 236(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r14, 232(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lfd f14, 304(r1) # 8-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r0, 452(r1)
+; BE-32BIT-P9-NEXT:    mtocrf 32, r12
+; BE-32BIT-P9-NEXT:    mtocrf 16, r12
+; BE-32BIT-P9-NEXT:    mtocrf 8, r12
+; BE-32BIT-P9-NEXT:    addi r1, r1, 448
+; BE-32BIT-P9-NEXT:    mtlr r0
+; BE-32BIT-P9-NEXT:    hashchk r0, -424(r1)
+; BE-32BIT-P9-NEXT:    blr
+;
+; 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 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 r17, 244(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r18, 248(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r19, 252(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r20, 256(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r21, 260(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r22, 264(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r23, 268(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r24, 272(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r25, 276(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r26, 280(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r27, 284(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r28, 288(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r29, 292(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r30, 296(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r31, 300(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:    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:    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:    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:    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:    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:    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:    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:    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:    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:    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:    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
+; BE-32BIT-P8-NEXT:    stfd f28, 416(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f29, 424(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f30, 432(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stfd f31, 440(r1) # 8-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r3, 16(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    stw r4, 20(r1)
+; BE-32BIT-P8-NEXT:    #APP
+; BE-32BIT-P8-NEXT:    nop
+; BE-32BIT-P8-NEXT:    #NO_APP
+; BE-32BIT-P8-NEXT:    addi r3, r1, 20
+; BE-32BIT-P8-NEXT:    bl callee2
+; BE-32BIT-P8-NEXT:    lwz r4, 16(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f31, 440(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f30, 432(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f29, 424(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f28, 416(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r4, 16(r4)
+; BE-32BIT-P8-NEXT:    lfd f27, 408(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f26, 400(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f25, 392(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f24, 384(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    add r3, r4, r3
+; BE-32BIT-P8-NEXT:    li r4, 208
+; BE-32BIT-P8-NEXT:    lfd f23, 376(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lfd f22, 368(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v31, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 192
+; BE-32BIT-P8-NEXT:    lfd f21, 360(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v30, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 176
+; BE-32BIT-P8-NEXT:    lfd f20, 352(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v29, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 160
+; BE-32BIT-P8-NEXT:    lfd f19, 344(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v28, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 144
+; BE-32BIT-P8-NEXT:    lfd f18, 336(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v27, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 128
+; BE-32BIT-P8-NEXT:    lfd f17, 328(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v26, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 112
+; BE-32BIT-P8-NEXT:    lfd f16, 320(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v25, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 96
+; BE-32BIT-P8-NEXT:    lfd f15, 312(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lxvd2x v24, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 80
+; BE-32BIT-P8-NEXT:    lxvd2x v23, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 64
+; BE-32BIT-P8-NEXT:    lxvd2x v22, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 48
+; BE-32BIT-P8-NEXT:    lxvd2x v21, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    li r4, 32
+; BE-32BIT-P8-NEXT:    lxvd2x v20, r1, r4 # 16-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r12, 228(r1)
+; BE-32BIT-P8-NEXT:    lfd f14, 304(r1) # 8-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r31, 300(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r30, 296(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r29, 292(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r28, 288(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r27, 284(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r26, 280(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r25, 276(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r24, 272(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r23, 268(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    mtocrf 32, r12
+; BE-32BIT-P8-NEXT:    lwz r22, 264(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r21, 260(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r20, 256(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r19, 252(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    mtocrf 16, r12
+; BE-32BIT-P8-NEXT:    lwz r18, 248(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r17, 244(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r16, 240(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r15, 236(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    mtocrf 8, r12
+; BE-32BIT-P8-NEXT:    lwz r14, 232(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r0, 452(r1)
+; BE-32BIT-P8-NEXT:    addi r1, r1, 448
+; BE-32BIT-P8-NEXT:    mtlr r0
+; BE-32BIT-P8-NEXT:    hashchk r0, -424(r1)
+; BE-32BIT-P8-NEXT:    blr
+;
 ; LE-P10-PRIV-LABEL: spill:
 ; LE-P10-PRIV:       # %bb.0: # %entry
 ; LE-P10-PRIV-NEXT:    mflr r0
 ; LE-P10-PRIV-NEXT:    mfcr r12
 ; LE-P10-PRIV-NEXT:    std r0, 16(r1)
 ; LE-P10-PRIV-NEXT:    hashstp r0, -488(r1)
 ; LE-P10-PRIV-NEXT:    stw r12, 8(r1)
 ; LE-P10-PRIV-NEXT:    stdu r1, -544(r1)

 ; BE-P8-NEXT:    clrldi r3, r3, 32
 ; BE-P8-NEXT:    hashchk r0, -24(r1)
 ; BE-P8-NEXT:    mtlr r0
 ; BE-P8-NEXT:    blr
 ; BE-P8-NEXT:  .LBB2_2:
 ; BE-P8-NEXT:    li r3, 0
 ; BE-P8-NEXT:    blr
 ;
+; BE-32BIT-P10-LABEL: shrinkwrap:
+; BE-32BIT-P10:       # %bb.0: # %entry
+; BE-32BIT-P10-NEXT:    mflr r0
+; BE-32BIT-P10-NEXT:    stw r0, 4(r1)
+; BE-32BIT-P10-NEXT:    hashst r0, -16(r1)
+; BE-32BIT-P10-NEXT:    stwu r1, -32(r1)
+; BE-32BIT-P10-NEXT:    cmplwi r3, 0
+; BE-32BIT-P10-NEXT:    stw r30, 24(r1) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    beq cr0, .LBB2_2
+; BE-32BIT-P10-NEXT:  # %bb.1: # %if.end
+; BE-32BIT-P10-NEXT:    mr r30, r3
+; BE-32BIT-P10-NEXT:    lwz r3, 12(r3)
+; BE-32BIT-P10-NEXT:    stw r3, 12(r1)
+; BE-32BIT-P10-NEXT:    addi r3, r1, 12
+; BE-32BIT-P10-NEXT:    bl callee2
+; BE-32BIT-P10-NEXT:    lwz r4, 16(r30)
+; BE-32BIT-P10-NEXT:    add r3, r4, r3
+; BE-32BIT-P10-NEXT:    b .LBB2_3
+; BE-32BIT-P10-NEXT:  .LBB2_2:
+; BE-32BIT-P10-NEXT:    li r3, 0
+; BE-32BIT-P10-NEXT:  .LBB2_3: # %return
+; BE-32BIT-P10-NEXT:    lwz r30, 24(r1) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    lwz r0, 36(r1)
+; BE-32BIT-P10-NEXT:    addi r1, r1, 32
+; BE-32BIT-P10-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P10-NEXT:    mtlr r0
+; BE-32BIT-P10-NEXT:    blr
+;
+; 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 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-P9-NEXT:    mr r30, r3
+; BE-32BIT-P9-NEXT:    lwz r3, 12(r3)
+; BE-32BIT-P9-NEXT:    stw r3, 12(r1)
+; BE-32BIT-P9-NEXT:    addi r3, r1, 12
+; BE-32BIT-P9-NEXT:    bl callee2
+; BE-32BIT-P9-NEXT:    lwz r4, 16(r30)
+; BE-32BIT-P9-NEXT:    add r3, r4, r3
+; BE-32BIT-P9-NEXT:    b .LBB2_3
+; BE-32BIT-P9-NEXT:  .LBB2_2:
+; BE-32BIT-P9-NEXT:    li r3, 0
+; BE-32BIT-P9-NEXT:  .LBB2_3: # %return
+; BE-32BIT-P9-NEXT:    lwz r30, 24(r1) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    lwz r0, 36(r1)
+; BE-32BIT-P9-NEXT:    addi r1, r1, 32
+; BE-32BIT-P9-NEXT:    mtlr r0
+; BE-32BIT-P9-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P9-NEXT:    blr
+;
+; 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 r30, 24(r1) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    beq cr0, .LBB2_2
+; BE-32BIT-P8-NEXT:  # %bb.1: # %if.end
+; BE-32BIT-P8-NEXT:    mr r30, r3
+; BE-32BIT-P8-NEXT:    lwz r3, 12(r3)
+; BE-32BIT-P8-NEXT:    stw r3, 12(r1)
+; BE-32BIT-P8-NEXT:    addi r3, r1, 12
+; BE-32BIT-P8-NEXT:    bl callee2
+; BE-32BIT-P8-NEXT:    lwz r4, 16(r30)
+; BE-32BIT-P8-NEXT:    add r3, r4, r3
+; BE-32BIT-P8-NEXT:    b .LBB2_3
+; BE-32BIT-P8-NEXT:  .LBB2_2:
+; BE-32BIT-P8-NEXT:    li r3, 0
+; BE-32BIT-P8-NEXT:  .LBB2_3: # %return
+; BE-32BIT-P8-NEXT:    lwz r30, 24(r1) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    lwz r0, 36(r1)
+; BE-32BIT-P8-NEXT:    addi r1, r1, 32
+; BE-32BIT-P8-NEXT:    mtlr r0
+; BE-32BIT-P8-NEXT:    hashchk r0, -16(r1)
+; BE-32BIT-P8-NEXT:    blr
+;
 ; LE-P10-PRIV-LABEL: shrinkwrap:
 ; LE-P10-PRIV:       # %bb.0: # %entry
 ; LE-P10-PRIV-NEXT:    cmpldi r3, 0
 ; LE-P10-PRIV-NEXT:    beq cr0, .LBB2_2
 ; LE-P10-PRIV-NEXT:  # %bb.1: # %if.end
 ; LE-P10-PRIV-NEXT:    mflr r0
 ; LE-P10-PRIV-NEXT:    std r30, -16(r1) # 8-byte Folded Spill
 ; LE-P10-PRIV-NEXT:    std r0, 16(r1)

 ; BE-P8-NEXT:    clrldi r3, r3, 32
 ; BE-P8-NEXT:    mr r1, r30
 ; BE-P8-NEXT:    ld r0, 16(r1)
 ; BE-P8-NEXT:    ld r30, -16(r1)
 ; BE-P8-NEXT:    hashchk r0, -32(r1)
 ; BE-P8-NEXT:    mtlr r0
 ; BE-P8-NEXT:    blr
 ;
+; BE-32BIT-P10-LABEL: aligned:
+; BE-32BIT-P10:       # %bb.0: # %entry
+; BE-32BIT-P10-NEXT:    mflr r0
+; BE-32BIT-P10-NEXT:    lis r12, -1
+; BE-32BIT-P10-NEXT:    stw r0, 4(r1)
+; BE-32BIT-P10-NEXT:    hashst r0, -24(r1)
+; BE-32BIT-P10-NEXT:    clrlwi r0, r1, 17
+; BE-32BIT-P10-NEXT:    ori r12, r12, 0
+; BE-32BIT-P10-NEXT:    subc r0, r12, r0
+; BE-32BIT-P10-NEXT:    stwux r1, r1, r0
+; BE-32BIT-P10-NEXT:    sub r0, r1, r0
+; BE-32BIT-P10-NEXT:    lis r4, 0
+; BE-32BIT-P10-NEXT:    addi r5, r1, 32764
+; BE-32BIT-P10-NEXT:    addic r0, r0, -8
+; BE-32BIT-P10-NEXT:    ori r4, r4, 65508
+; BE-32BIT-P10-NEXT:    stwx r30, 0, r0
+; BE-32BIT-P10-NEXT:    addic r30, r0, 8
+; BE-32BIT-P10-NEXT:    stw r29, -12(r30) # 4-byte Folded Spill
+; BE-32BIT-P10-NEXT:    mr r29, r3
+; BE-32BIT-P10-NEXT:    lwz r3, 4(r3)
+; BE-32BIT-P10-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P10-NEXT:    lwz r3, 12(r29)
+; BE-32BIT-P10-NEXT:    lis r4, 0
+; BE-32BIT-P10-NEXT:    ori r4, r4, 32768
+; BE-32BIT-P10-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P10-NEXT:    lwz r3, 20(r29)
+; BE-32BIT-P10-NEXT:    lis r4, 0
+; BE-32BIT-P10-NEXT:    ori r4, r4, 65508
+; BE-32BIT-P10-NEXT:    add r4, r1, r4
+; BE-32BIT-P10-NEXT:    stw r3, 32764(r1)
+; BE-32BIT-P10-NEXT:    lis r3, 0
+; BE-32BIT-P10-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P10-NEXT:    add r3, r1, r3
+; BE-32BIT-P10-NEXT:    bl callee3
+; BE-32BIT-P10-NEXT:    lwz r4, 16(r29)
+; BE-32BIT-P10-NEXT:    lwz r29, -12(r30) # 4-byte Folded Reload
+; BE-32BIT-P10-NEXT:    mr r0, r31
+; BE-32BIT-P10-NEXT:    add r3, r4, r3
+; BE-32BIT-P10-NEXT:    lwz r31, 0(r1)
+; BE-32BIT-P10-NEXT:    lwz r30, -8(r31)
+; BE-32BIT-P10-NEXT:    mr r1, r31
+; BE-32BIT-P10-NEXT:    mr r31, r0
+; BE-32BIT-P10-NEXT:    lwz r0, 4(r1)
+; BE-32BIT-P10-NEXT:    hashchk r0, -24(r1)
+; BE-32BIT-P10-NEXT:    mtlr r0
+; BE-32BIT-P10-NEXT:    blr
+;
+; BE-32BIT-P9-LABEL: aligned:
+; BE-32BIT-P9:       # %bb.0: # %entry
+; BE-32BIT-P9-NEXT:    mflr r0
+; BE-32BIT-P9-NEXT:    lis r12, -1
+; BE-32BIT-P9-NEXT:    ori r12, r12, 0
+; BE-32BIT-P9-NEXT:    stw r0, 4(r1)
+; BE-32BIT-P9-NEXT:    hashst r0, -24(r1)
+; BE-32BIT-P9-NEXT:    clrlwi r0, r1, 17
+; BE-32BIT-P9-NEXT:    subc r0, r12, r0
+; BE-32BIT-P9-NEXT:    stwux r1, r1, r0
+; BE-32BIT-P9-NEXT:    sub r0, r1, r0
+; BE-32BIT-P9-NEXT:    lis r4, 0
+; BE-32BIT-P9-NEXT:    addi r5, r1, 32764
+; BE-32BIT-P9-NEXT:    addic r0, r0, -8
+; BE-32BIT-P9-NEXT:    ori r4, r4, 65508
+; BE-32BIT-P9-NEXT:    stwx r30, 0, r0
+; BE-32BIT-P9-NEXT:    addic r30, r0, 8
+; BE-32BIT-P9-NEXT:    stw r29, -12(r30) # 4-byte Folded Spill
+; BE-32BIT-P9-NEXT:    mr r29, r3
+; BE-32BIT-P9-NEXT:    lwz r3, 4(r3)
+; BE-32BIT-P9-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P9-NEXT:    lwz r3, 12(r29)
+; BE-32BIT-P9-NEXT:    lis r4, 0
+; BE-32BIT-P9-NEXT:    ori r4, r4, 32768
+; BE-32BIT-P9-NEXT:    stwx r3, r1, r4
+; BE-32BIT-P9-NEXT:    lwz r3, 20(r29)
+; BE-32BIT-P9-NEXT:    lis r4, 0
+; BE-32BIT-P9-NEXT:    ori r4, r4, 65508
+; BE-32BIT-P9-NEXT:    stw r3, 32764(r1)
+; BE-32BIT-P9-NEXT:    lis r3, 0
+; BE-32BIT-P9-NEXT:    add r4, r1, r4
+; BE-32BIT-P9-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P9-NEXT:    add r3, r1, r3
+; BE-32BIT-P9-NEXT:    bl callee3
+; BE-32BIT-P9-NEXT:    lwz r4, 16(r29)
+; BE-32BIT-P9-NEXT:    lwz r29, -12(r30) # 4-byte Folded Reload
+; BE-32BIT-P9-NEXT:    mr r0, r31
+; BE-32BIT-P9-NEXT:    lwz r31, 0(r1)
+; BE-32BIT-P9-NEXT:    lwz r30, -8(r31)
+; BE-32BIT-P9-NEXT:    add r3, r4, r3
+; BE-32BIT-P9-NEXT:    mr r1, r31
+; BE-32BIT-P9-NEXT:    mr r31, r0
+; BE-32BIT-P9-NEXT:    lwz r0, 4(r1)
+; BE-32BIT-P9-NEXT:    mtlr r0
+; BE-32BIT-P9-NEXT:    hashchk r0, -24(r1)
+; BE-32BIT-P9-NEXT:    blr
+;
+; BE-32BIT-P8-LABEL: aligned:
+; BE-32BIT-P8:       # %bb.0: # %entry
+; BE-32BIT-P8-NEXT:    mflr r0
+; BE-32BIT-P8-NEXT:    lis r12, -1
+; BE-32BIT-P8-NEXT:    stw r0, 4(r1)
+; BE-32BIT-P8-NEXT:    hashst r0, -24(r1)
+; BE-32BIT-P8-NEXT:    clrlwi r0, r1, 17
+; BE-32BIT-P8-NEXT:    ori r12, r12, 0
+; BE-32BIT-P8-NEXT:    subc r0, r12, r0
+; BE-32BIT-P8-NEXT:    stwux r1, r1, r0
+; BE-32BIT-P8-NEXT:    sub r0, r1, r0
+; BE-32BIT-P8-NEXT:    lis r6, 0
+; BE-32BIT-P8-NEXT:    addic r0, r0, -8
+; BE-32BIT-P8-NEXT:    ori r6, r6, 65508
+; BE-32BIT-P8-NEXT:    stwx r30, 0, r0
+; BE-32BIT-P8-NEXT:    addic r30, r0, 8
+; BE-32BIT-P8-NEXT:    stw r29, -12(r30) # 4-byte Folded Spill
+; BE-32BIT-P8-NEXT:    mr r29, r3
+; BE-32BIT-P8-NEXT:    lwz r3, 4(r3)
+; BE-32BIT-P8-NEXT:    lwz r4, 12(r29)
+; BE-32BIT-P8-NEXT:    lwz r5, 20(r29)
+; BE-32BIT-P8-NEXT:    stwx r3, r1, r6
+; BE-32BIT-P8-NEXT:    lis r3, 0
+; BE-32BIT-P8-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P8-NEXT:    stw r5, 32764(r1)
+; BE-32BIT-P8-NEXT:    addi r5, r1, 32764
+; BE-32BIT-P8-NEXT:    stwx r4, r1, r3
+; BE-32BIT-P8-NEXT:    lis r3, 0
+; BE-32BIT-P8-NEXT:    lis r4, 0
+; BE-32BIT-P8-NEXT:    ori r3, r3, 32768
+; BE-32BIT-P8-NEXT:    ori r4, r4, 65508
+; BE-32BIT-P8-NEXT:    add r3, r1, r3
+; BE-32BIT-P8-NEXT:    add r4, r1, r4
+; BE-32BIT-P8-NEXT:    bl callee3
+; BE-32BIT-P8-NEXT:    lwz r4, 16(r29)
+; BE-32BIT-P8-NEXT:    lwz r29, -12(r30) # 4-byte Folded Reload
+; BE-32BIT-P8-NEXT:    mr r0, r31
+; BE-32BIT-P8-NEXT:    lwz r31, 0(r1)
+; BE-32BIT-P8-NEXT:    lwz r30, -8(r31)
+; BE-32BIT-P8-NEXT:    add r3, r4, r3
+; BE-32BIT-P8-NEXT:    mr r1, r31
+; BE-32BIT-P8-NEXT:    mr r31, r0
+; BE-32BIT-P8-NEXT:    lwz r0, 4(r1)
+; BE-32BIT-P8-NEXT:    hashchk r0, -24(r1)
+; BE-32BIT-P8-NEXT:    mtlr r0
+; BE-32BIT-P8-NEXT:    blr
+;
 ; LE-P10-PRIV-LABEL: aligned:
 ; LE-P10-PRIV:       # %bb.0: # %entry
 ; LE-P10-PRIV-NEXT:    mflr r0
 ; LE-P10-PRIV-NEXT:    lis r12, -1
 ; LE-P10-PRIV-NEXT:    std r30, -16(r1)
 ; LE-P10-PRIV-NEXT:    mr r30, r1
 ; LE-P10-PRIV-NEXT:    std r0, 16(r1)
 ; LE-P10-PRIV-NEXT:    hashstp r0, -32(r1)