[mips] Support shrink-wrapping

[vstefanovic]

Summary

Except for -O0, it's enabled by default.

[sdardis]

test/CodeGen/Mips/shrink-wrapping.ll

2

Can you use the update_llc_checks.py script to generate the check lines? You'll need to supply a triple instead of -march=

8

Remove the dso_local, local_unamed_addr and nounwind from this.

34

Can you also provide a test case similar to gcc PR86069? For O32 this consists of a branch over a section of code to an early return and the branch has to be expanded into a long jump sequence. You can use .space to create arbitrary size chunks of nops.

35

Similarly here for the dso_local.

[vstefanovic]

Added long branch test, used update_llc_test_checks.py to create checks.

[sdardis]

test/CodeGen/Mips/shrink-wrapping.ll

4

Can you also add mips64 tests?

193–196

Can you remove this alloca, we need to expose the jump in such a way that the shrink wrapping pass tries to move the prologue past it.

[vstefanovic]

Updated the long branch test with actual shrink-wrapping.

[atanasyan]

LGTM

lib/Target/Mips/Mips16FrameLowering.cpp

 
 using namespace llvm;
 
 Mips16FrameLowering::Mips16FrameLowering(const MipsSubtarget &STI)
     : MipsFrameLowering(STI, STI.getStackAlignment()) {}
 
 void Mips16FrameLowering::emitPrologue(MachineFunction &MF,
                                        MachineBasicBlock &MBB) const {
-  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
   MachineFrameInfo &MFI = MF.getFrameInfo();
   const Mips16InstrInfo &TII =
       *static_cast<const Mips16InstrInfo *>(STI.getInstrInfo());
   MachineBasicBlock::iterator MBBI = MBB.begin();
 
   // Debug location must be unknown since the first debug location is used
   // to determine the end of the prologue.
   DebugLoc dl;
void Mips16FrameLowering::emitPrologue(MachineFunction &MF,
   }
   if (hasFP(MF))
     BuildMI(MBB, MBBI, dl, TII.get(Mips::MoveR3216), Mips::S0)
       .addReg(Mips::SP).setMIFlag(MachineInstr::FrameSetup);
 }
 
 void Mips16FrameLowering::emitEpilogue(MachineFunction &MF,
                                  MachineBasicBlock &MBB) const {
-  MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
+  MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   const Mips16InstrInfo &TII =
       *static_cast<const Mips16InstrInfo *>(STI.getInstrInfo());
-  DebugLoc dl = MBBI->getDebugLoc();
+  DebugLoc dl = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
   uint64_t StackSize = MFI.getStackSize();
 
   if (!StackSize)
     return;
 
   if (hasFP(MF))
     BuildMI(MBB, MBBI, dl, TII.get(Mips::Move32R16), Mips::SP)
       .addReg(Mips::S0);
 
   // Adjust stack.
   // assumes stacksize multiple of 8
   TII.restoreFrame(Mips::SP, StackSize, MBB, MBBI);
 }
 
 bool Mips16FrameLowering::
 spillCalleeSavedRegisters(MachineBasicBlock &MBB,
                           MachineBasicBlock::iterator MI,
                           const std::vector<CalleeSavedInfo> &CSI,
                           const TargetRegisterInfo *TRI) const {
   MachineFunction *MF = MBB.getParent();
-  MachineBasicBlock *EntryBlock = &MF->front();
 
   //
   // Registers RA, S0,S1 are the callee saved registers and they
   // will be saved with the "save" instruction
   // during emitPrologue
   //
   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
     // Add the callee-saved register as live-in. Do not add if the register is
     // RA and return address is taken, because it has already been added in
     // method MipsTargetLowering::lowerRETURNADDR.
     // It's killed at the spill, unless the register is RA and return address
     // is taken.
     unsigned Reg = CSI[i].getReg();
     bool IsRAAndRetAddrIsTaken = (Reg == Mips::RA)
       && MF->getFrameInfo().isReturnAddressTaken();
     if (!IsRAAndRetAddrIsTaken)
-      EntryBlock->addLiveIn(Reg);
+      MBB.addLiveIn(Reg);
   }
 
   return true;
 }
 
 bool Mips16FrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
                                           MachineBasicBlock::iterator MI,
                                        std::vector<CalleeSavedInfo> &CSI,

lib/Target/Mips/MipsFrameLowering.h

public:
   static const MipsFrameLowering *create(const MipsSubtarget &ST);
 
   bool hasFP(const MachineFunction &MF) const override;
 
   bool hasBP(const MachineFunction &MF) const;
 
   bool isFPCloseToIncomingSP() const override { return false; }
 
+  bool enableShrinkWrapping(const MachineFunction &MF) const override {
+    return true;
+  }
+
   MachineBasicBlock::iterator
   eliminateCallFramePseudoInstr(MachineFunction &MF,
                                 MachineBasicBlock &MBB,
                                 MachineBasicBlock::iterator I) const override;
 
 protected:
   uint64_t estimateStackSize(const MachineFunction &MF) const;
 };
 
 /// Create MipsFrameLowering objects.
 const MipsFrameLowering *createMips16FrameLowering(const MipsSubtarget &ST);
 const MipsFrameLowering *createMipsSEFrameLowering(const MipsSubtarget &ST);
 
 } // End llvm namespace
 
 #endif

lib/Target/Mips/MipsSEFrameLowering.cpp

bool ExpandPseudo::expandExtractElementF64(MachineBasicBlock &MBB,
   return false;
 }
 
 MipsSEFrameLowering::MipsSEFrameLowering(const MipsSubtarget &STI)
     : MipsFrameLowering(STI, STI.getStackAlignment()) {}
 
 void MipsSEFrameLowering::emitPrologue(MachineFunction &MF,
                                        MachineBasicBlock &MBB) const {
-  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
   MachineFrameInfo &MFI    = MF.getFrameInfo();
   MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
 
   const MipsSEInstrInfo &TII =
       *static_cast<const MipsSEInstrInfo *>(STI.getInstrInfo());
   const MipsRegisterInfo &RegInfo =
       *static_cast<const MipsRegisterInfo *>(STI.getRegisterInfo());
 
void MipsSEFrameLowering::emitInterruptPrologueStub(
   BuildMI(MBB, MBBI, DL, STI.getInstrInfo()->get(Mips::MTC0), Mips::COP012)
       .addReg(Mips::K1)
       .addImm(0)
       .setMIFlag(MachineInstr::FrameSetup);
 }
 
 void MipsSEFrameLowering::emitEpilogue(MachineFunction &MF,
                                        MachineBasicBlock &MBB) const {
-  MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
+  MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
   MachineFrameInfo &MFI            = MF.getFrameInfo();
   MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
 
   const MipsSEInstrInfo &TII =
       *static_cast<const MipsSEInstrInfo *>(STI.getInstrInfo());
   const MipsRegisterInfo &RegInfo =
       *static_cast<const MipsRegisterInfo *>(STI.getRegisterInfo());
 
-  DebugLoc DL = MBBI->getDebugLoc();
+  DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
   MipsABIInfo ABI = STI.getABI();
   unsigned SP = ABI.GetStackPtr();
   unsigned FP = ABI.GetFramePtr();
   unsigned ZERO = ABI.GetNullPtr();
   unsigned MOVE = ABI.GetGPRMoveOp();
 
   // if framepointer enabled, restore the stack pointer.
   if (hasFP(MF)) {

 }
 
 bool MipsSEFrameLowering::
 spillCalleeSavedRegisters(MachineBasicBlock &MBB,
                           MachineBasicBlock::iterator MI,
                           const std::vector<CalleeSavedInfo> &CSI,
                           const TargetRegisterInfo *TRI) const {
   MachineFunction *MF = MBB.getParent();
-  MachineBasicBlock *EntryBlock = &MF->front();
   const TargetInstrInfo &TII = *STI.getInstrInfo();
 
   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
     // Add the callee-saved register as live-in. Do not add if the register is
     // RA and return address is taken, because it has already been added in
     // method MipsTargetLowering::lowerRETURNADDR.
     // It's killed at the spill, unless the register is RA and return address
     // is taken.
     unsigned Reg = CSI[i].getReg();
     bool IsRAAndRetAddrIsTaken = (Reg == Mips::RA || Reg == Mips::RA_64)
         && MF->getFrameInfo().isReturnAddressTaken();
     if (!IsRAAndRetAddrIsTaken)
-      EntryBlock->addLiveIn(Reg);
+      MBB.addLiveIn(Reg);
 
     // ISRs require HI/LO to be spilled into kernel registers to be then
     // spilled to the stack frame.
     bool IsLOHI = (Reg == Mips::LO0 || Reg == Mips::LO0_64 ||
                    Reg == Mips::HI0 || Reg == Mips::HI0_64);
     const Function &Func = MBB.getParent()->getFunction();
     if (IsLOHI && Func.hasFnAttribute("interrupt")) {
       DebugLoc DL = MI->getDebugLoc();
 
       unsigned Op = 0;
       if (!STI.getABI().ArePtrs64bit()) {
         Op = (Reg == Mips::HI0) ? Mips::MFHI : Mips::MFLO;
         Reg = Mips::K0;
       } else {
         Op = (Reg == Mips::HI0) ? Mips::MFHI64 : Mips::MFLO64;
         Reg = Mips::K0_64;
       }
       BuildMI(MBB, MI, DL, TII.get(Op), Mips::K0)
           .setMIFlag(MachineInstr::FrameSetup);
     }
 
     // Insert the spill to the stack frame.
     bool IsKill = !IsRAAndRetAddrIsTaken;
     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
-    TII.storeRegToStackSlot(*EntryBlock, MI, Reg, IsKill,
+    TII.storeRegToStackSlot(MBB, MI, Reg, IsKill,
                             CSI[i].getFrameIdx(), RC, TRI);
   }
 
   return true;
 }
 
 bool
 MipsSEFrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {

test/CodeGen/Mips/blez_bgez.ll

-; RUN: llc -march=mipsel < %s | FileCheck %s
-; RUN: llc -march=mips64el < %s | FileCheck %s
+; RUN: llc -march=mipsel -enable-shrink-wrap=false  < %s | FileCheck %s
+; RUN: llc -march=mips64el -enable-shrink-wrap=false < %s | FileCheck %s
 
 ; CHECK-LABEL: test_blez:
 ; CHECK: blez ${{[0-9]+}}, {{\$|\.L}}BB
 
 define void @test_blez(i32 %a) {
 entry:
   %cmp = icmp sgt i32 %a, 0
   br i1 %cmp, label %if.then, label %if.end

test/CodeGen/Mips/brdelayslot.ll

 ; RUN: llc -march=mipsel -O0 < %s | FileCheck %s -check-prefix=None
 ; RUN: llc -march=mipsel     -relocation-model=pic    < %s | \
 ; RUN: FileCheck %s -check-prefix=Default
 ; RUN: llc -march=mipsel -O1 -relocation-model=static < %s | \
 ; RUN: FileCheck %s -check-prefix=STATICO1
 ; RUN: llc -march=mipsel -disable-mips-df-forward-search=false \
 ; RUN: -relocation-model=static < %s | FileCheck %s -check-prefix=FORWARD
 ; RUN: llc -march=mipsel -disable-mips-df-backward-search -relocation-model=pic \
+; RUN: -enable-shrink-wrap=false \
 ; RUN: -disable-mips-df-succbb-search=false -disable-preheader-prot=true < %s | \
 ; RUN: FileCheck %s -check-prefix=SUCCBB
 
 define void @foo1() nounwind {
 entry:
 ; Default:     jalr
 ; Default-NOT: nop
 ; Default:     jr

test/CodeGen/Mips/shrink-wrapping.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; RUN: llc -mtriple=mips-unknown-linux-gnu -enable-shrink-wrap=true \
+; RUN:   -relocation-model=static < %s | \
+; RUN:   FileCheck %s -check-prefix=SHRINK-WRAP-STATIC
+
+; RUN: llc -mtriple=mips-unknown-linux-gnu -enable-shrink-wrap=false \
+; RUN:   -relocation-model=static < %s | \
+; RUN:   FileCheck %s -check-prefix=NO-SHRINK-WRAP-STATIC
+
+; RUN: llc -mtriple=mips-unknown-linux-gnu -enable-shrink-wrap=true \
+; RUN:   -relocation-model=pic < %s | \
+; RUN:   FileCheck %s -check-prefix=SHRINK-WRAP-PIC
+
+; RUN: llc -mtriple=mips-unknown-linux-gnu -enable-shrink-wrap=false \
+; RUN:   -relocation-model=pic < %s | \
+; RUN:   FileCheck %s -check-prefix=NO-SHRINK-WRAP-PIC
+
+; RUN: llc -mtriple=mips64-unknown-linux-gnu -enable-shrink-wrap=true \
+; RUN:   -relocation-model=static < %s | \
+; RUN:   FileCheck %s -check-prefix=SHRINK-WRAP-64-STATIC
+
+; RUN: llc -mtriple=mips64-unknown-linux-gnu -enable-shrink-wrap=false \
+; RUN:   -relocation-model=static < %s | \
+; RUN:   FileCheck %s -check-prefix=NO-SHRINK-WRAP-64-STATIC
+
+; RUN: llc -mtriple=mips64-unknown-linux-gnu -enable-shrink-wrap=true \
+; RUN:   -relocation-model=pic < %s | \
+; RUN:   FileCheck %s -check-prefix=SHRINK-WRAP-64-PIC
+
+; RUN: llc -mtriple=mips64-unknown-linux-gnu -enable-shrink-wrap=false \
+; RUN:   -relocation-model=pic < %s | \
+; RUN:   FileCheck %s -check-prefix=NO-SHRINK-WRAP-64-PIC
+
+declare void @f(i32 signext)
+
+define i32 @foo(i32 signext %a) {
+; SHRINK-WRAP-STATIC-LABEL: foo:
+; SHRINK-WRAP-STATIC:       # %bb.0: # %entry
+; SHRINK-WRAP-STATIC-NEXT:    beqz $4, $BB0_2
+; SHRINK-WRAP-STATIC-NEXT:    nop
+; SHRINK-WRAP-STATIC-NEXT:  # %bb.1: # %if.end
+; SHRINK-WRAP-STATIC-NEXT:    addiu $sp, $sp, -24
+; SHRINK-WRAP-STATIC-NEXT:    .cfi_def_cfa_offset 24
+; SHRINK-WRAP-STATIC-NEXT:    sw $ra, 20($sp) # 4-byte Folded Spill
+; SHRINK-WRAP-STATIC-NEXT:    .cfi_offset 31, -4
+; SHRINK-WRAP-STATIC-NEXT:    jal f
+; SHRINK-WRAP-STATIC-NEXT:    addiu $4, $4, 1
+; SHRINK-WRAP-STATIC-NEXT:    lw $ra, 20($sp) # 4-byte Folded Reload
+; SHRINK-WRAP-STATIC-NEXT:    addiu $sp, $sp, 24
+; SHRINK-WRAP-STATIC-NEXT:  $BB0_2: # %return
+; SHRINK-WRAP-STATIC-NEXT:    jr $ra
+; SHRINK-WRAP-STATIC-NEXT:    addiu $2, $zero, 0
+;
+; NO-SHRINK-WRAP-STATIC-LABEL: foo:
+; NO-SHRINK-WRAP-STATIC:       # %bb.0: # %entry
+; NO-SHRINK-WRAP-STATIC-NEXT:    addiu $sp, $sp, -24
+; NO-SHRINK-WRAP-STATIC-NEXT:    .cfi_def_cfa_offset 24
+; NO-SHRINK-WRAP-STATIC-NEXT:    sw $ra, 20($sp) # 4-byte Folded Spill
+; NO-SHRINK-WRAP-STATIC-NEXT:    .cfi_offset 31, -4
+; NO-SHRINK-WRAP-STATIC-NEXT:    beqz $4, $BB0_2
+; NO-SHRINK-WRAP-STATIC-NEXT:    nop
+; NO-SHRINK-WRAP-STATIC-NEXT:  # %bb.1: # %if.end
+; NO-SHRINK-WRAP-STATIC-NEXT:    jal f
+; NO-SHRINK-WRAP-STATIC-NEXT:    addiu $4, $4, 1
+; NO-SHRINK-WRAP-STATIC-NEXT:  $BB0_2: # %return
+; NO-SHRINK-WRAP-STATIC-NEXT:    addiu $2, $zero, 0
+; NO-SHRINK-WRAP-STATIC-NEXT:    lw $ra, 20($sp) # 4-byte Folded Reload
+; NO-SHRINK-WRAP-STATIC-NEXT:    jr $ra
+; NO-SHRINK-WRAP-STATIC-NEXT:    addiu $sp, $sp, 24
+;
+; SHRINK-WRAP-PIC-LABEL: foo:
+; SHRINK-WRAP-PIC:       # %bb.0: # %entry
+; SHRINK-WRAP-PIC-NEXT:    lui $2, %hi(_gp_disp)
+; SHRINK-WRAP-PIC-NEXT:    addiu $2, $2, %lo(_gp_disp)
+; SHRINK-WRAP-PIC-NEXT:    beqz $4, $BB0_2
+; SHRINK-WRAP-PIC-NEXT:    addu $gp, $2, $25
+; SHRINK-WRAP-PIC-NEXT:  # %bb.1: # %if.end
+; SHRINK-WRAP-PIC-NEXT:    addiu $sp, $sp, -24
+; SHRINK-WRAP-PIC-NEXT:    .cfi_def_cfa_offset 24
+; SHRINK-WRAP-PIC-NEXT:    sw $ra, 20($sp) # 4-byte Folded Spill
+; SHRINK-WRAP-PIC-NEXT:    .cfi_offset 31, -4
+; SHRINK-WRAP-PIC-NEXT:    lw $25, %call16(f)($gp)
+; SHRINK-WRAP-PIC-NEXT:    jalr $25
+; SHRINK-WRAP-PIC-NEXT:    addiu $4, $4, 1
+; SHRINK-WRAP-PIC-NEXT:    lw $ra, 20($sp) # 4-byte Folded Reload
+; SHRINK-WRAP-PIC-NEXT:    addiu $sp, $sp, 24
+; SHRINK-WRAP-PIC-NEXT:  $BB0_2: # %return
+; SHRINK-WRAP-PIC-NEXT:    jr $ra
+; SHRINK-WRAP-PIC-NEXT:    addiu $2, $zero, 0
+;
+; NO-SHRINK-WRAP-PIC-LABEL: foo:
+; NO-SHRINK-WRAP-PIC:       # %bb.0: # %entry
+; NO-SHRINK-WRAP-PIC-NEXT:    lui $2, %hi(_gp_disp)
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $2, $2, %lo(_gp_disp)
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $sp, $sp, -24
+; NO-SHRINK-WRAP-PIC-NEXT:    .cfi_def_cfa_offset 24
+; NO-SHRINK-WRAP-PIC-NEXT:    sw $ra, 20($sp) # 4-byte Folded Spill
+; NO-SHRINK-WRAP-PIC-NEXT:    .cfi_offset 31, -4
+; NO-SHRINK-WRAP-PIC-NEXT:    beqz $4, $BB0_2
+; NO-SHRINK-WRAP-PIC-NEXT:    addu $gp, $2, $25
+; NO-SHRINK-WRAP-PIC-NEXT:  # %bb.1: # %if.end
+; NO-SHRINK-WRAP-PIC-NEXT:    lw $25, %call16(f)($gp)
+; NO-SHRINK-WRAP-PIC-NEXT:    jalr $25
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $4, $4, 1
+; NO-SHRINK-WRAP-PIC-NEXT:  $BB0_2: # %return
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $2, $zero, 0
+; NO-SHRINK-WRAP-PIC-NEXT:    lw $ra, 20($sp) # 4-byte Folded Reload
+; NO-SHRINK-WRAP-PIC-NEXT:    jr $ra
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $sp, $sp, 24
+;
+; SHRINK-WRAP-64-STATIC-LABEL: foo:
+; SHRINK-WRAP-64-STATIC:       # %bb.0: # %entry
+; SHRINK-WRAP-64-STATIC-NEXT:    beqz $4, .LBB0_2
+; SHRINK-WRAP-64-STATIC-NEXT:    nop
+; SHRINK-WRAP-64-STATIC-NEXT:  # %bb.1: # %if.end
+; SHRINK-WRAP-64-STATIC-NEXT:    daddiu $sp, $sp, -16
+; SHRINK-WRAP-64-STATIC-NEXT:    .cfi_def_cfa_offset 16
+; SHRINK-WRAP-64-STATIC-NEXT:    sd $ra, 8($sp) # 8-byte Folded Spill
+; SHRINK-WRAP-64-STATIC-NEXT:    .cfi_offset 31, -8
+; SHRINK-WRAP-64-STATIC-NEXT:    addiu $1, $4, 1
+; SHRINK-WRAP-64-STATIC-NEXT:    jal f
+; SHRINK-WRAP-64-STATIC-NEXT:    sll $4, $1, 0
+; SHRINK-WRAP-64-STATIC-NEXT:    ld $ra, 8($sp) # 8-byte Folded Reload
+; SHRINK-WRAP-64-STATIC-NEXT:    daddiu $sp, $sp, 16
+; SHRINK-WRAP-64-STATIC-NEXT:  .LBB0_2: # %return
+; SHRINK-WRAP-64-STATIC-NEXT:    jr $ra
+; SHRINK-WRAP-64-STATIC-NEXT:    addiu $2, $zero, 0
+;
+; NO-SHRINK-WRAP-64-STATIC-LABEL: foo:
+; NO-SHRINK-WRAP-64-STATIC:       # %bb.0: # %entry
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    daddiu $sp, $sp, -16
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    .cfi_def_cfa_offset 16
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    sd $ra, 8($sp) # 8-byte Folded Spill
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    .cfi_offset 31, -8
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    beqz $4, .LBB0_2
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    nop
+; NO-SHRINK-WRAP-64-STATIC-NEXT:  # %bb.1: # %if.end
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    addiu $1, $4, 1
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    jal f
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    sll $4, $1, 0
+; NO-SHRINK-WRAP-64-STATIC-NEXT:  .LBB0_2: # %return
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    addiu $2, $zero, 0
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    ld $ra, 8($sp) # 8-byte Folded Reload
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    jr $ra
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    daddiu $sp, $sp, 16
+;
+; SHRINK-WRAP-64-PIC-LABEL: foo:
+; SHRINK-WRAP-64-PIC:       # %bb.0: # %entry
+; SHRINK-WRAP-64-PIC-NEXT:    lui $1, %hi(%neg(%gp_rel(foo)))
+; SHRINK-WRAP-64-PIC-NEXT:    beqz $4, .LBB0_2
+; SHRINK-WRAP-64-PIC-NEXT:    daddu $2, $1, $25
+; SHRINK-WRAP-64-PIC-NEXT:  # %bb.1: # %if.end
+; SHRINK-WRAP-64-PIC-NEXT:    daddiu $sp, $sp, -16
+; SHRINK-WRAP-64-PIC-NEXT:    .cfi_def_cfa_offset 16
+; SHRINK-WRAP-64-PIC-NEXT:    sd $ra, 8($sp) # 8-byte Folded Spill
+; SHRINK-WRAP-64-PIC-NEXT:    sd $gp, 0($sp) # 8-byte Folded Spill
+; SHRINK-WRAP-64-PIC-NEXT:    .cfi_offset 31, -8
+; SHRINK-WRAP-64-PIC-NEXT:    .cfi_offset 28, -16
+; SHRINK-WRAP-64-PIC-NEXT:    daddiu $gp, $2, %lo(%neg(%gp_rel(foo)))
+; SHRINK-WRAP-64-PIC-NEXT:    addiu $1, $4, 1
+; SHRINK-WRAP-64-PIC-NEXT:    ld $25, %call16(f)($gp)
+; SHRINK-WRAP-64-PIC-NEXT:    jalr $25
+; SHRINK-WRAP-64-PIC-NEXT:    sll $4, $1, 0
+; SHRINK-WRAP-64-PIC-NEXT:    ld $gp, 0($sp) # 8-byte Folded Reload
+; SHRINK-WRAP-64-PIC-NEXT:    ld $ra, 8($sp) # 8-byte Folded Reload
+; SHRINK-WRAP-64-PIC-NEXT:    daddiu $sp, $sp, 16
+; SHRINK-WRAP-64-PIC-NEXT:  .LBB0_2: # %return
+; SHRINK-WRAP-64-PIC-NEXT:    jr $ra
+; SHRINK-WRAP-64-PIC-NEXT:    addiu $2, $zero, 0
+;
+; NO-SHRINK-WRAP-64-PIC-LABEL: foo:
+; NO-SHRINK-WRAP-64-PIC:       # %bb.0: # %entry
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddiu $sp, $sp, -16
+; NO-SHRINK-WRAP-64-PIC-NEXT:    .cfi_def_cfa_offset 16
+; NO-SHRINK-WRAP-64-PIC-NEXT:    sd $ra, 8($sp) # 8-byte Folded Spill
+; NO-SHRINK-WRAP-64-PIC-NEXT:    sd $gp, 0($sp) # 8-byte Folded Spill
+; NO-SHRINK-WRAP-64-PIC-NEXT:    .cfi_offset 31, -8
+; NO-SHRINK-WRAP-64-PIC-NEXT:    .cfi_offset 28, -16
+; NO-SHRINK-WRAP-64-PIC-NEXT:    lui $1, %hi(%neg(%gp_rel(foo)))
+; NO-SHRINK-WRAP-64-PIC-NEXT:    beqz $4, .LBB0_2
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddu $2, $1, $25
+; NO-SHRINK-WRAP-64-PIC-NEXT:  # %bb.1: # %if.end
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddiu $gp, $2, %lo(%neg(%gp_rel(foo)))
+; NO-SHRINK-WRAP-64-PIC-NEXT:    addiu $1, $4, 1
+; NO-SHRINK-WRAP-64-PIC-NEXT:    ld $25, %call16(f)($gp)
+; NO-SHRINK-WRAP-64-PIC-NEXT:    jalr $25
+; NO-SHRINK-WRAP-64-PIC-NEXT:    sll $4, $1, 0
+; NO-SHRINK-WRAP-64-PIC-NEXT:  .LBB0_2: # %return
+; NO-SHRINK-WRAP-64-PIC-NEXT:    addiu $2, $zero, 0
+; NO-SHRINK-WRAP-64-PIC-NEXT:    ld $gp, 0($sp) # 8-byte Folded Reload
+; NO-SHRINK-WRAP-64-PIC-NEXT:    ld $ra, 8($sp) # 8-byte Folded Reload
+; NO-SHRINK-WRAP-64-PIC-NEXT:    jr $ra
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddiu $sp, $sp, 16
+entry:
+  %cmp = icmp eq i32 %a, 0
+  br i1 %cmp, label %return, label %if.end
+
+if.end:
+  %add = add nsw i32 %a, 1
+  tail call void @f(i32 signext %add)
+  br label %return
+
+return:
+  ret i32 0
+}
+
+; Test that long branch expansion works correctly with shrink-wrapping enabled.
+define i32 @foo2(i32 signext %a) {
+; SHRINK-WRAP-STATIC-LABEL: foo2:
+; SHRINK-WRAP-STATIC:       # %bb.0:
+; SHRINK-WRAP-STATIC-NEXT:    addiu $1, $zero, 4
+; SHRINK-WRAP-STATIC-NEXT:    bne $4, $1, $BB1_2
+; SHRINK-WRAP-STATIC-NEXT:    nop
+; SHRINK-WRAP-STATIC-NEXT:  # %bb.1:
+; SHRINK-WRAP-STATIC-NEXT:    j $BB1_3
+; SHRINK-WRAP-STATIC-NEXT:    nop
+; SHRINK-WRAP-STATIC-NEXT:  $BB1_2: # %if.then
+; SHRINK-WRAP-STATIC-NEXT:    addiu $sp, $sp, -24
+; SHRINK-WRAP-STATIC-NEXT:    .cfi_def_cfa_offset 24
+; SHRINK-WRAP-STATIC-NEXT:    sw $ra, 20($sp) # 4-byte Folded Spill
+; SHRINK-WRAP-STATIC-NEXT:    .cfi_offset 31, -4
+; SHRINK-WRAP-STATIC-NEXT:    #APP
+;
+; NO-SHRINK-WRAP-STATIC-LABEL: foo2:
+; NO-SHRINK-WRAP-STATIC:       # %bb.0:
+; NO-SHRINK-WRAP-STATIC-NEXT:    addiu $sp, $sp, -24
+; NO-SHRINK-WRAP-STATIC-NEXT:    .cfi_def_cfa_offset 24
+; NO-SHRINK-WRAP-STATIC-NEXT:    sw $ra, 20($sp) # 4-byte Folded Spill
+; NO-SHRINK-WRAP-STATIC-NEXT:    .cfi_offset 31, -4
+; NO-SHRINK-WRAP-STATIC-NEXT:    addiu $1, $zero, 4
+; NO-SHRINK-WRAP-STATIC-NEXT:    bne $4, $1, $BB1_2
+; NO-SHRINK-WRAP-STATIC-NEXT:    nop
+; NO-SHRINK-WRAP-STATIC-NEXT:  # %bb.1:
+; NO-SHRINK-WRAP-STATIC-NEXT:    j $BB1_3
+; NO-SHRINK-WRAP-STATIC-NEXT:    nop
+; NO-SHRINK-WRAP-STATIC-NEXT:  $BB1_2: # %if.then
+; NO-SHRINK-WRAP-STATIC-NEXT:    #APP
+;
+; SHRINK-WRAP-PIC-LABEL: foo2:
+; SHRINK-WRAP-PIC:       # %bb.0:
+; SHRINK-WRAP-PIC-NEXT:    lui $2, %hi(_gp_disp)
+; SHRINK-WRAP-PIC-NEXT:    addiu $2, $2, %lo(_gp_disp)
+; SHRINK-WRAP-PIC-NEXT:    addiu $1, $zero, 4
+; SHRINK-WRAP-PIC-NEXT:    bne $4, $1, $BB1_3
+; SHRINK-WRAP-PIC-NEXT:    addu $gp, $2, $25
+; SHRINK-WRAP-PIC-NEXT:  # %bb.1:
+; SHRINK-WRAP-PIC-NEXT:    addiu $sp, $sp, -8
+; SHRINK-WRAP-PIC-NEXT:    sw $ra, 0($sp)
+; SHRINK-WRAP-PIC-NEXT:    lui $1, %hi(($BB1_4)-($BB1_2))
+; SHRINK-WRAP-PIC-NEXT:    bal $BB1_2
+; SHRINK-WRAP-PIC-NEXT:    addiu $1, $1, %lo(($BB1_4)-($BB1_2))
+; SHRINK-WRAP-PIC-NEXT:  $BB1_2:
+; SHRINK-WRAP-PIC-NEXT:    addu $1, $ra, $1
+; SHRINK-WRAP-PIC-NEXT:    lw $ra, 0($sp)
+; SHRINK-WRAP-PIC-NEXT:    jr $1
+; SHRINK-WRAP-PIC-NEXT:    addiu $sp, $sp, 8
+; SHRINK-WRAP-PIC-NEXT:  $BB1_3: # %if.then
+; SHRINK-WRAP-PIC-NEXT:    addiu $sp, $sp, -24
+; SHRINK-WRAP-PIC-NEXT:    .cfi_def_cfa_offset 24
+; SHRINK-WRAP-PIC-NEXT:    sw $ra, 20($sp) # 4-byte Folded Spill
+; SHRINK-WRAP-PIC-NEXT:    .cfi_offset 31, -4
+; SHRINK-WRAP-PIC-NEXT:    #APP
+;
+; NO-SHRINK-WRAP-PIC-LABEL: foo2:
+; NO-SHRINK-WRAP-PIC:       # %bb.0:
+; NO-SHRINK-WRAP-PIC-NEXT:    lui $2, %hi(_gp_disp)
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $2, $2, %lo(_gp_disp)
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $sp, $sp, -24
+; NO-SHRINK-WRAP-PIC-NEXT:    .cfi_def_cfa_offset 24
+; NO-SHRINK-WRAP-PIC-NEXT:    sw $ra, 20($sp) # 4-byte Folded Spill
+; NO-SHRINK-WRAP-PIC-NEXT:    .cfi_offset 31, -4
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $1, $zero, 4
+; NO-SHRINK-WRAP-PIC-NEXT:    bne $4, $1, $BB1_3
+; NO-SHRINK-WRAP-PIC-NEXT:    addu $gp, $2, $25
+; NO-SHRINK-WRAP-PIC-NEXT:  # %bb.1:
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $sp, $sp, -8
+; NO-SHRINK-WRAP-PIC-NEXT:    sw $ra, 0($sp)
+; NO-SHRINK-WRAP-PIC-NEXT:    lui $1, %hi(($BB1_4)-($BB1_2))
+; NO-SHRINK-WRAP-PIC-NEXT:    bal $BB1_2
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $1, $1, %lo(($BB1_4)-($BB1_2))
+; NO-SHRINK-WRAP-PIC-NEXT:  $BB1_2:
+; NO-SHRINK-WRAP-PIC-NEXT:    addu $1, $ra, $1
+; NO-SHRINK-WRAP-PIC-NEXT:    lw $ra, 0($sp)
+; NO-SHRINK-WRAP-PIC-NEXT:    jr $1
+; NO-SHRINK-WRAP-PIC-NEXT:    addiu $sp, $sp, 8
+; NO-SHRINK-WRAP-PIC-NEXT:  $BB1_3: # %if.then
+; NO-SHRINK-WRAP-PIC-NEXT:    #APP
+;
+; SHRINK-WRAP-64-STATIC-LABEL: foo2:
+; SHRINK-WRAP-64-STATIC:       # %bb.0:
+; SHRINK-WRAP-64-STATIC-NEXT:    addiu $1, $zero, 4
+; SHRINK-WRAP-64-STATIC-NEXT:    bne $4, $1, .LBB1_2
+; SHRINK-WRAP-64-STATIC-NEXT:    nop
+; SHRINK-WRAP-64-STATIC-NEXT:  # %bb.1:
+; SHRINK-WRAP-64-STATIC-NEXT:    j .LBB1_3
+; SHRINK-WRAP-64-STATIC-NEXT:    nop
+; SHRINK-WRAP-64-STATIC-NEXT:  .LBB1_2: # %if.then
+; SHRINK-WRAP-64-STATIC-NEXT:    daddiu $sp, $sp, -16
+; SHRINK-WRAP-64-STATIC-NEXT:    .cfi_def_cfa_offset 16
+; SHRINK-WRAP-64-STATIC-NEXT:    sd $ra, 8($sp) # 8-byte Folded Spill
+; SHRINK-WRAP-64-STATIC-NEXT:    .cfi_offset 31, -8
+; SHRINK-WRAP-64-STATIC-NEXT:    sll $4, $4, 0
+; SHRINK-WRAP-64-STATIC-NEXT:    #APP
+;
+; NO-SHRINK-WRAP-64-STATIC-LABEL: foo2:
+; NO-SHRINK-WRAP-64-STATIC:       # %bb.0:
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    daddiu $sp, $sp, -16
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    .cfi_def_cfa_offset 16
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    sd $ra, 8($sp) # 8-byte Folded Spill
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    .cfi_offset 31, -8
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    addiu $1, $zero, 4
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    bne $4, $1, .LBB1_2
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    nop
+; NO-SHRINK-WRAP-64-STATIC-NEXT:  # %bb.1:
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    j .LBB1_3
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    nop
+; NO-SHRINK-WRAP-64-STATIC-NEXT:  .LBB1_2: # %if.then
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    sll $4, $4, 0
+; NO-SHRINK-WRAP-64-STATIC-NEXT:    #APP
+;
+; SHRINK-WRAP-64-PIC-LABEL: foo2:
+; SHRINK-WRAP-64-PIC:       # %bb.0:
+; SHRINK-WRAP-64-PIC-NEXT:    lui $1, %hi(%neg(%gp_rel(foo2)))
+; SHRINK-WRAP-64-PIC-NEXT:    daddu $2, $1, $25
+; SHRINK-WRAP-64-PIC-NEXT:    addiu $1, $zero, 4
+; SHRINK-WRAP-64-PIC-NEXT:    bne $4, $1, .LBB1_3
+; SHRINK-WRAP-64-PIC-NEXT:    nop
+; SHRINK-WRAP-64-PIC-NEXT:  # %bb.1:
+; SHRINK-WRAP-64-PIC-NEXT:    daddiu $sp, $sp, -16
+; SHRINK-WRAP-64-PIC-NEXT:    sd $ra, 0($sp)
+; SHRINK-WRAP-64-PIC-NEXT:    daddiu $1, $zero, %hi(.LBB1_4-.LBB1_2)
+; SHRINK-WRAP-64-PIC-NEXT:    dsll $1, $1, 16
+; SHRINK-WRAP-64-PIC-NEXT:    bal .LBB1_2
+; SHRINK-WRAP-64-PIC-NEXT:    daddiu $1, $1, %lo(.LBB1_4-.LBB1_2)
+; SHRINK-WRAP-64-PIC-NEXT:  .LBB1_2:
+; SHRINK-WRAP-64-PIC-NEXT:    daddu $1, $ra, $1
+; SHRINK-WRAP-64-PIC-NEXT:    ld $ra, 0($sp)
+; SHRINK-WRAP-64-PIC-NEXT:    jr $1
+; SHRINK-WRAP-64-PIC-NEXT:    daddiu $sp, $sp, 16
+; SHRINK-WRAP-64-PIC-NEXT:  .LBB1_3: # %if.then
+; SHRINK-WRAP-64-PIC-NEXT:    daddiu $sp, $sp, -16
+; SHRINK-WRAP-64-PIC-NEXT:    .cfi_def_cfa_offset 16
+; SHRINK-WRAP-64-PIC-NEXT:    sd $ra, 8($sp) # 8-byte Folded Spill
+; SHRINK-WRAP-64-PIC-NEXT:    sd $gp, 0($sp) # 8-byte Folded Spill
+; SHRINK-WRAP-64-PIC-NEXT:    .cfi_offset 31, -8
+; SHRINK-WRAP-64-PIC-NEXT:    .cfi_offset 28, -16
+; SHRINK-WRAP-64-PIC-NEXT:    daddiu $gp, $2, %lo(%neg(%gp_rel(foo2)))
+; SHRINK-WRAP-64-PIC-NEXT:    sll $4, $4, 0
+; SHRINK-WRAP-64-PIC-NEXT:    #APP
+;
+; NO-SHRINK-WRAP-64-PIC-LABEL: foo2:
+; NO-SHRINK-WRAP-64-PIC:       # %bb.0:
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddiu $sp, $sp, -16
+; NO-SHRINK-WRAP-64-PIC-NEXT:    .cfi_def_cfa_offset 16
+; NO-SHRINK-WRAP-64-PIC-NEXT:    sd $ra, 8($sp) # 8-byte Folded Spill
+; NO-SHRINK-WRAP-64-PIC-NEXT:    sd $gp, 0($sp) # 8-byte Folded Spill
+; NO-SHRINK-WRAP-64-PIC-NEXT:    .cfi_offset 31, -8
+; NO-SHRINK-WRAP-64-PIC-NEXT:    .cfi_offset 28, -16
+; NO-SHRINK-WRAP-64-PIC-NEXT:    lui $1, %hi(%neg(%gp_rel(foo2)))
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddu $2, $1, $25
+; NO-SHRINK-WRAP-64-PIC-NEXT:    addiu $1, $zero, 4
+; NO-SHRINK-WRAP-64-PIC-NEXT:    bne $4, $1, .LBB1_3
+; NO-SHRINK-WRAP-64-PIC-NEXT:    nop
+; NO-SHRINK-WRAP-64-PIC-NEXT:  # %bb.1:
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddiu $sp, $sp, -16
+; NO-SHRINK-WRAP-64-PIC-NEXT:    sd $ra, 0($sp)
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddiu $1, $zero, %hi(.LBB1_4-.LBB1_2)
+; NO-SHRINK-WRAP-64-PIC-NEXT:    dsll $1, $1, 16
+; NO-SHRINK-WRAP-64-PIC-NEXT:    bal .LBB1_2
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddiu $1, $1, %lo(.LBB1_4-.LBB1_2)
+; NO-SHRINK-WRAP-64-PIC-NEXT:  .LBB1_2:
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddu $1, $ra, $1
+; NO-SHRINK-WRAP-64-PIC-NEXT:    ld $ra, 0($sp)
+; NO-SHRINK-WRAP-64-PIC-NEXT:    jr $1
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddiu $sp, $sp, 16
+; NO-SHRINK-WRAP-64-PIC-NEXT:  .LBB1_3: # %if.then
+; NO-SHRINK-WRAP-64-PIC-NEXT:    daddiu $gp, $2, %lo(%neg(%gp_rel(foo2)))
+; NO-SHRINK-WRAP-64-PIC-NEXT:    sll $4, $4, 0
+; NO-SHRINK-WRAP-64-PIC-NEXT:    #APP
+  %1 = icmp ne i32 %a, 4
+  br i1 %1, label %if.then, label %if.end
+
+if.then:
+  call void asm sideeffect ".space 1048576", "~{$1}"()
+  call void @f(i32 signext %a)
+  br label %if.end
+
+if.end:
+  ret i32 0
+}