[LoongArch] Optimize stack realignment using BSTRINS instruction

[wangleiat]

Summary

Prior to this change, stack realignment was achieved using the SRLI/SLLI
instructions in two steps. With this patch, stack realignment is
optimized using a single BSTRINS instruction.

[xen0n]

LGTM. Thanks!

[SixWeining]

llvm/lib/Target/LoongArch/LoongArchFrameLowering.cpp

301

How about renaming it to Align?

[wangleiat]

Address @SixWeining's comments.

llvm/lib/Target/LoongArch/LoongArchFrameLowering.cpp

if (hasFP(MF)) {
           .addCFIIndex(CFIIndex)
           .setMIFlag(MachineInstr::FrameSetup);
     }
   }
 
   if (hasFP(MF)) {
     // Realign stack.
     if (RI->hasStackRealignment(MF)) {
-      unsigned ShiftAmount = Log2(MFI.getMaxAlign());
-      Register VR =
-          MF.getRegInfo().createVirtualRegister(&LoongArch::GPRRegClass);
+      unsigned MSB = Log2(MFI.getMaxAlign());
+      assert(MSB > 0 && "The stack realignment size is invalid!");
       BuildMI(MBB, MBBI, DL,
-              TII->get(IsLA64 ? LoongArch::SRLI_D : LoongArch::SRLI_W), VR)
+              TII->get(IsLA64 ? LoongArch::BSTRINS_D : LoongArch::BSTRINS_W),
+              SPReg)
           .addReg(SPReg)
-          .addImm(ShiftAmount)
-          .setMIFlag(MachineInstr::FrameSetup);
-      BuildMI(MBB, MBBI, DL,
-              TII->get(IsLA64 ? LoongArch::SLLI_D : LoongArch::SLLI_W), SPReg)
-          .addReg(VR)
-          .addImm(ShiftAmount)
+          .addReg(LoongArch::R0)
+          .addImm(MSB - 1)
+          .addImm(0)
           .setMIFlag(MachineInstr::FrameSetup);
       // FP will be used to restore the frame in the epilogue, so we need
       // another base register BP to record SP after re-alignment. SP will
       // track the current stack after allocating variable sized objects.
       if (hasBP(MF)) {
         // move BP, $sp
         BuildMI(MBB, MBBI, DL, TII->get(LoongArch::OR),
                 LoongArchABI::getBPReg())

llvm/test/CodeGen/LoongArch/stack-realignment-with-variable-sized-objects.ll

 ; LA32-NEXT:    st.w $ra, $sp, 60 # 4-byte Folded Spill
 ; LA32-NEXT:    st.w $fp, $sp, 56 # 4-byte Folded Spill
 ; LA32-NEXT:    st.w $s8, $sp, 52 # 4-byte Folded Spill
 ; LA32-NEXT:    .cfi_offset 1, -4
 ; LA32-NEXT:    .cfi_offset 22, -8
 ; LA32-NEXT:    .cfi_offset 31, -12
 ; LA32-NEXT:    addi.w $fp, $sp, 64
 ; LA32-NEXT:    .cfi_def_cfa 22, 0
-; LA32-NEXT:    srli.w $a1, $sp, 6
-; LA32-NEXT:    slli.w $sp, $a1, 6
+; LA32-NEXT:    bstrins.w $sp, $zero, 5, 0
 ; LA32-NEXT:    move $s8, $sp
 ; LA32-NEXT:    addi.w $a0, $a0, 15
 ; LA32-NEXT:    addi.w $a1, $zero, -16
 ; LA32-NEXT:    and $a0, $a0, $a1
 ; LA32-NEXT:    sub.w $a0, $sp, $a0
 ; LA32-NEXT:    move $sp, $a0
 ; LA32-NEXT:    addi.w $a1, $s8, 0
 ; LA32-NEXT:    bl %plt(callee)

 ; LA64-NEXT:    st.d $ra, $sp, 56 # 8-byte Folded Spill
 ; LA64-NEXT:    st.d $fp, $sp, 48 # 8-byte Folded Spill
 ; LA64-NEXT:    st.d $s8, $sp, 40 # 8-byte Folded Spill
 ; LA64-NEXT:    .cfi_offset 1, -8
 ; LA64-NEXT:    .cfi_offset 22, -16
 ; LA64-NEXT:    .cfi_offset 31, -24
 ; LA64-NEXT:    addi.d $fp, $sp, 64
 ; LA64-NEXT:    .cfi_def_cfa 22, 0
-; LA64-NEXT:    srli.d $a1, $sp, 6
-; LA64-NEXT:    slli.d $sp, $a1, 6
+; LA64-NEXT:    bstrins.d $sp, $zero, 5, 0
 ; LA64-NEXT:    move $s8, $sp
 ; LA64-NEXT:    bstrpick.d $a0, $a0, 31, 0
 ; LA64-NEXT:    addi.d $a0, $a0, 15
 ; LA64-NEXT:    bstrpick.d $a0, $a0, 32, 4
 ; LA64-NEXT:    slli.d $a0, $a0, 4
 ; LA64-NEXT:    sub.d $a0, $sp, $a0
 ; LA64-NEXT:    move $sp, $a0
 ; LA64-NEXT:    addi.d $a1, $s8, 0

llvm/test/CodeGen/LoongArch/stack-realignment.ll

 ; LA32-NEXT:    addi.w $sp, $sp, -32
 ; LA32-NEXT:    .cfi_def_cfa_offset 32
 ; LA32-NEXT:    st.w $ra, $sp, 28 # 4-byte Folded Spill
 ; LA32-NEXT:    st.w $fp, $sp, 24 # 4-byte Folded Spill
 ; LA32-NEXT:    .cfi_offset 1, -4
 ; LA32-NEXT:    .cfi_offset 22, -8
 ; LA32-NEXT:    addi.w $fp, $sp, 32
 ; LA32-NEXT:    .cfi_def_cfa 22, 0
-; LA32-NEXT:    srli.w $a0, $sp, 5
-; LA32-NEXT:    slli.w $sp, $a0, 5
+; LA32-NEXT:    bstrins.w $sp, $zero, 4, 0
 ; LA32-NEXT:    addi.w $a0, $sp, 0
 ; LA32-NEXT:    bl %plt(callee)
 ; LA32-NEXT:    addi.w $sp, $fp, -32
 ; LA32-NEXT:    ld.w $fp, $sp, 24 # 4-byte Folded Reload
 ; LA32-NEXT:    ld.w $ra, $sp, 28 # 4-byte Folded Reload
 ; LA32-NEXT:    addi.w $sp, $sp, 32
 ; LA32-NEXT:    ret
 ;
 ; LA64-LABEL: caller32:
 ; LA64:       # %bb.0:
 ; LA64-NEXT:    addi.d $sp, $sp, -32
 ; LA64-NEXT:    .cfi_def_cfa_offset 32
 ; LA64-NEXT:    st.d $ra, $sp, 24 # 8-byte Folded Spill
 ; LA64-NEXT:    st.d $fp, $sp, 16 # 8-byte Folded Spill
 ; LA64-NEXT:    .cfi_offset 1, -8
 ; LA64-NEXT:    .cfi_offset 22, -16
 ; LA64-NEXT:    addi.d $fp, $sp, 32
 ; LA64-NEXT:    .cfi_def_cfa 22, 0
-; LA64-NEXT:    srli.d $a0, $sp, 5
-; LA64-NEXT:    slli.d $sp, $a0, 5
+; LA64-NEXT:    bstrins.d $sp, $zero, 4, 0
 ; LA64-NEXT:    addi.d $a0, $sp, 0
 ; LA64-NEXT:    bl %plt(callee)
 ; LA64-NEXT:    addi.d $sp, $fp, -32
 ; LA64-NEXT:    ld.d $fp, $sp, 16 # 8-byte Folded Reload
 ; LA64-NEXT:    ld.d $ra, $sp, 24 # 8-byte Folded Reload
 ; LA64-NEXT:    addi.d $sp, $sp, 32
 ; LA64-NEXT:    ret
   %1 = alloca i8, align 32

 ; LA32-NEXT:    addi.w $sp, $sp, -64
 ; LA32-NEXT:    .cfi_def_cfa_offset 64
 ; LA32-NEXT:    st.w $ra, $sp, 60 # 4-byte Folded Spill
 ; LA32-NEXT:    st.w $fp, $sp, 56 # 4-byte Folded Spill
 ; LA32-NEXT:    .cfi_offset 1, -4
 ; LA32-NEXT:    .cfi_offset 22, -8
 ; LA32-NEXT:    addi.w $fp, $sp, 64
 ; LA32-NEXT:    .cfi_def_cfa 22, 0
-; LA32-NEXT:    srli.w $a0, $sp, 6
-; LA32-NEXT:    slli.w $sp, $a0, 6
+; LA32-NEXT:    bstrins.w $sp, $zero, 5, 0
 ; LA32-NEXT:    addi.w $a0, $sp, 0
 ; LA32-NEXT:    bl %plt(callee)
 ; LA32-NEXT:    addi.w $sp, $fp, -64
 ; LA32-NEXT:    ld.w $fp, $sp, 56 # 4-byte Folded Reload
 ; LA32-NEXT:    ld.w $ra, $sp, 60 # 4-byte Folded Reload
 ; LA32-NEXT:    addi.w $sp, $sp, 64
 ; LA32-NEXT:    ret
 ;
 ; LA64-LABEL: caller64:
 ; LA64:       # %bb.0:
 ; LA64-NEXT:    addi.d $sp, $sp, -64
 ; LA64-NEXT:    .cfi_def_cfa_offset 64
 ; LA64-NEXT:    st.d $ra, $sp, 56 # 8-byte Folded Spill
 ; LA64-NEXT:    st.d $fp, $sp, 48 # 8-byte Folded Spill
 ; LA64-NEXT:    .cfi_offset 1, -8
 ; LA64-NEXT:    .cfi_offset 22, -16
 ; LA64-NEXT:    addi.d $fp, $sp, 64
 ; LA64-NEXT:    .cfi_def_cfa 22, 0
-; LA64-NEXT:    srli.d $a0, $sp, 6
-; LA64-NEXT:    slli.d $sp, $a0, 6
+; LA64-NEXT:    bstrins.d $sp, $zero, 5, 0
 ; LA64-NEXT:    addi.d $a0, $sp, 0
 ; LA64-NEXT:    bl %plt(callee)
 ; LA64-NEXT:    addi.d $sp, $fp, -64
 ; LA64-NEXT:    ld.d $fp, $sp, 48 # 8-byte Folded Reload
 ; LA64-NEXT:    ld.d $ra, $sp, 56 # 8-byte Folded Reload
 ; LA64-NEXT:    addi.d $sp, $sp, 64
 ; LA64-NEXT:    ret
   %1 = alloca i8, align 64

 ; LA32-NEXT:    addi.w $sp, $sp, -128
 ; LA32-NEXT:    .cfi_def_cfa_offset 128
 ; LA32-NEXT:    st.w $ra, $sp, 124 # 4-byte Folded Spill
 ; LA32-NEXT:    st.w $fp, $sp, 120 # 4-byte Folded Spill
 ; LA32-NEXT:    .cfi_offset 1, -4
 ; LA32-NEXT:    .cfi_offset 22, -8
 ; LA32-NEXT:    addi.w $fp, $sp, 128
 ; LA32-NEXT:    .cfi_def_cfa 22, 0
-; LA32-NEXT:    srli.w $a0, $sp, 7
-; LA32-NEXT:    slli.w $sp, $a0, 7
+; LA32-NEXT:    bstrins.w $sp, $zero, 6, 0
 ; LA32-NEXT:    addi.w $a0, $sp, 0
 ; LA32-NEXT:    bl %plt(callee)
 ; LA32-NEXT:    addi.w $sp, $fp, -128
 ; LA32-NEXT:    ld.w $fp, $sp, 120 # 4-byte Folded Reload
 ; LA32-NEXT:    ld.w $ra, $sp, 124 # 4-byte Folded Reload
 ; LA32-NEXT:    addi.w $sp, $sp, 128
 ; LA32-NEXT:    ret
 ;
 ; LA64-LABEL: caller128:
 ; LA64:       # %bb.0:
 ; LA64-NEXT:    addi.d $sp, $sp, -128
 ; LA64-NEXT:    .cfi_def_cfa_offset 128
 ; LA64-NEXT:    st.d $ra, $sp, 120 # 8-byte Folded Spill
 ; LA64-NEXT:    st.d $fp, $sp, 112 # 8-byte Folded Spill
 ; LA64-NEXT:    .cfi_offset 1, -8
 ; LA64-NEXT:    .cfi_offset 22, -16
 ; LA64-NEXT:    addi.d $fp, $sp, 128
 ; LA64-NEXT:    .cfi_def_cfa 22, 0
-; LA64-NEXT:    srli.d $a0, $sp, 7
-; LA64-NEXT:    slli.d $sp, $a0, 7
+; LA64-NEXT:    bstrins.d $sp, $zero, 6, 0
 ; LA64-NEXT:    addi.d $a0, $sp, 0
 ; LA64-NEXT:    bl %plt(callee)
 ; LA64-NEXT:    addi.d $sp, $fp, -128
 ; LA64-NEXT:    ld.d $fp, $sp, 112 # 8-byte Folded Reload
 ; LA64-NEXT:    ld.d $ra, $sp, 120 # 8-byte Folded Reload
 ; LA64-NEXT:    addi.d $sp, $sp, 128
 ; LA64-NEXT:    ret
   %1 = alloca i8, align 128

 ; LA32-NEXT:    addi.w $sp, $sp, -256
 ; LA32-NEXT:    .cfi_def_cfa_offset 256
 ; LA32-NEXT:    st.w $ra, $sp, 252 # 4-byte Folded Spill
 ; LA32-NEXT:    st.w $fp, $sp, 248 # 4-byte Folded Spill
 ; LA32-NEXT:    .cfi_offset 1, -4
 ; LA32-NEXT:    .cfi_offset 22, -8
 ; LA32-NEXT:    addi.w $fp, $sp, 256
 ; LA32-NEXT:    .cfi_def_cfa 22, 0
-; LA32-NEXT:    srli.w $a0, $sp, 8
-; LA32-NEXT:    slli.w $sp, $a0, 8
+; LA32-NEXT:    bstrins.w $sp, $zero, 7, 0
 ; LA32-NEXT:    addi.w $a0, $sp, 0
 ; LA32-NEXT:    bl %plt(callee)
 ; LA32-NEXT:    addi.w $sp, $fp, -256
 ; LA32-NEXT:    ld.w $fp, $sp, 248 # 4-byte Folded Reload
 ; LA32-NEXT:    ld.w $ra, $sp, 252 # 4-byte Folded Reload
 ; LA32-NEXT:    addi.w $sp, $sp, 256
 ; LA32-NEXT:    ret
 ;
 ; LA64-LABEL: caller256:
 ; LA64:       # %bb.0:
 ; LA64-NEXT:    addi.d $sp, $sp, -256
 ; LA64-NEXT:    .cfi_def_cfa_offset 256
 ; LA64-NEXT:    st.d $ra, $sp, 248 # 8-byte Folded Spill
 ; LA64-NEXT:    st.d $fp, $sp, 240 # 8-byte Folded Spill
 ; LA64-NEXT:    .cfi_offset 1, -8
 ; LA64-NEXT:    .cfi_offset 22, -16
 ; LA64-NEXT:    addi.d $fp, $sp, 256
 ; LA64-NEXT:    .cfi_def_cfa 22, 0
-; LA64-NEXT:    srli.d $a0, $sp, 8
-; LA64-NEXT:    slli.d $sp, $a0, 8
+; LA64-NEXT:    bstrins.d $sp, $zero, 7, 0
 ; LA64-NEXT:    addi.d $a0, $sp, 0
 ; LA64-NEXT:    bl %plt(callee)
 ; LA64-NEXT:    addi.d $sp, $fp, -256
 ; LA64-NEXT:    ld.d $fp, $sp, 240 # 8-byte Folded Reload
 ; LA64-NEXT:    ld.d $ra, $sp, 248 # 8-byte Folded Reload
 ; LA64-NEXT:    addi.d $sp, $sp, 256
 ; LA64-NEXT:    ret
   %1 = alloca i8, align 256

 ; LA32-NEXT:    addi.w $sp, $sp, -1024
 ; LA32-NEXT:    .cfi_def_cfa_offset 1024
 ; LA32-NEXT:    st.w $ra, $sp, 1020 # 4-byte Folded Spill
 ; LA32-NEXT:    st.w $fp, $sp, 1016 # 4-byte Folded Spill
 ; LA32-NEXT:    .cfi_offset 1, -4
 ; LA32-NEXT:    .cfi_offset 22, -8
 ; LA32-NEXT:    addi.w $fp, $sp, 1024
 ; LA32-NEXT:    .cfi_def_cfa 22, 0
-; LA32-NEXT:    srli.w $a0, $sp, 9
-; LA32-NEXT:    slli.w $sp, $a0, 9
+; LA32-NEXT:    bstrins.w $sp, $zero, 8, 0
 ; LA32-NEXT:    addi.w $a0, $sp, 512
 ; LA32-NEXT:    bl %plt(callee)
 ; LA32-NEXT:    addi.w $sp, $fp, -1024
 ; LA32-NEXT:    ld.w $fp, $sp, 1016 # 4-byte Folded Reload
 ; LA32-NEXT:    ld.w $ra, $sp, 1020 # 4-byte Folded Reload
 ; LA32-NEXT:    addi.w $sp, $sp, 1024
 ; LA32-NEXT:    ret
 ;
 ; LA64-LABEL: caller512:
 ; LA64:       # %bb.0:
 ; LA64-NEXT:    addi.d $sp, $sp, -1024
 ; LA64-NEXT:    .cfi_def_cfa_offset 1024
 ; LA64-NEXT:    st.d $ra, $sp, 1016 # 8-byte Folded Spill
 ; LA64-NEXT:    st.d $fp, $sp, 1008 # 8-byte Folded Spill
 ; LA64-NEXT:    .cfi_offset 1, -8
 ; LA64-NEXT:    .cfi_offset 22, -16
 ; LA64-NEXT:    addi.d $fp, $sp, 1024
 ; LA64-NEXT:    .cfi_def_cfa 22, 0
-; LA64-NEXT:    srli.d $a0, $sp, 9
-; LA64-NEXT:    slli.d $sp, $a0, 9
+; LA64-NEXT:    bstrins.d $sp, $zero, 8, 0
 ; LA64-NEXT:    addi.d $a0, $sp, 512
 ; LA64-NEXT:    bl %plt(callee)
 ; LA64-NEXT:    addi.d $sp, $fp, -1024
 ; LA64-NEXT:    ld.d $fp, $sp, 1008 # 8-byte Folded Reload
 ; LA64-NEXT:    ld.d $ra, $sp, 1016 # 8-byte Folded Reload
 ; LA64-NEXT:    addi.d $sp, $sp, 1024
 ; LA64-NEXT:    ret
   %1 = alloca i8, align 512

 ; LA32-NEXT:    .cfi_def_cfa_offset 2032
 ; LA32-NEXT:    st.w $ra, $sp, 2028 # 4-byte Folded Spill
 ; LA32-NEXT:    st.w $fp, $sp, 2024 # 4-byte Folded Spill
 ; LA32-NEXT:    .cfi_offset 1, -4
 ; LA32-NEXT:    .cfi_offset 22, -8
 ; LA32-NEXT:    addi.w $fp, $sp, 2032
 ; LA32-NEXT:    .cfi_def_cfa 22, 0
 ; LA32-NEXT:    addi.w $sp, $sp, -16
-; LA32-NEXT:    srli.w $a0, $sp, 10
-; LA32-NEXT:    slli.w $sp, $a0, 10
+; LA32-NEXT:    bstrins.w $sp, $zero, 9, 0
 ; LA32-NEXT:    addi.w $a0, $sp, 1024
 ; LA32-NEXT:    bl %plt(callee)
 ; LA32-NEXT:    addi.w $sp, $fp, -2048
 ; LA32-NEXT:    addi.w $sp, $sp, 16
 ; LA32-NEXT:    ld.w $fp, $sp, 2024 # 4-byte Folded Reload
 ; LA32-NEXT:    ld.w $ra, $sp, 2028 # 4-byte Folded Reload
 ; LA32-NEXT:    addi.w $sp, $sp, 2032
 ; LA32-NEXT:    ret
 ;
 ; LA64-LABEL: caller1024:
 ; LA64:       # %bb.0:
 ; LA64-NEXT:    addi.d $sp, $sp, -2032
 ; LA64-NEXT:    .cfi_def_cfa_offset 2032
 ; LA64-NEXT:    st.d $ra, $sp, 2024 # 8-byte Folded Spill
 ; LA64-NEXT:    st.d $fp, $sp, 2016 # 8-byte Folded Spill
 ; LA64-NEXT:    .cfi_offset 1, -8
 ; LA64-NEXT:    .cfi_offset 22, -16
 ; LA64-NEXT:    addi.d $fp, $sp, 2032
 ; LA64-NEXT:    .cfi_def_cfa 22, 0
 ; LA64-NEXT:    addi.d $sp, $sp, -16
-; LA64-NEXT:    srli.d $a0, $sp, 10
-; LA64-NEXT:    slli.d $sp, $a0, 10
+; LA64-NEXT:    bstrins.d $sp, $zero, 9, 0
 ; LA64-NEXT:    addi.d $a0, $sp, 1024
 ; LA64-NEXT:    bl %plt(callee)
 ; LA64-NEXT:    addi.d $sp, $fp, -2048
 ; LA64-NEXT:    addi.d $sp, $sp, 16
 ; LA64-NEXT:    ld.d $fp, $sp, 2016 # 8-byte Folded Reload
 ; LA64-NEXT:    ld.d $ra, $sp, 2024 # 8-byte Folded Reload
 ; LA64-NEXT:    addi.d $sp, $sp, 2032
 ; LA64-NEXT:    ret

 ; LA32-NEXT:    st.w $ra, $sp, 2028 # 4-byte Folded Spill
 ; LA32-NEXT:    st.w $fp, $sp, 2024 # 4-byte Folded Spill
 ; LA32-NEXT:    .cfi_offset 1, -4
 ; LA32-NEXT:    .cfi_offset 22, -8
 ; LA32-NEXT:    addi.w $fp, $sp, 2032
 ; LA32-NEXT:    .cfi_def_cfa 22, 0
 ; LA32-NEXT:    addi.w $sp, $sp, -2048
 ; LA32-NEXT:    addi.w $sp, $sp, -16
-; LA32-NEXT:    srli.w $a0, $sp, 11
-; LA32-NEXT:    slli.w $sp, $a0, 11
+; LA32-NEXT:    bstrins.w $sp, $zero, 10, 0
 ; LA32-NEXT:    ori $a0, $zero, 2048
 ; LA32-NEXT:    add.w $a0, $sp, $a0
 ; LA32-NEXT:    bl %plt(callee)
 ; LA32-NEXT:    lu12i.w $a0, 1
 ; LA32-NEXT:    sub.w $sp, $fp, $a0
 ; LA32-NEXT:    addi.w $sp, $sp, 2032
 ; LA32-NEXT:    addi.w $sp, $sp, 32
 ; LA32-NEXT:    ld.w $fp, $sp, 2024 # 4-byte Folded Reload
 ; LA32-NEXT:    ld.w $ra, $sp, 2028 # 4-byte Folded Reload
 ; LA32-NEXT:    addi.w $sp, $sp, 2032
 ; LA32-NEXT:    ret
 ;
 ; LA64-LABEL: caller2048:
 ; LA64:       # %bb.0:
 ; LA64-NEXT:    addi.d $sp, $sp, -2032
 ; LA64-NEXT:    .cfi_def_cfa_offset 2032
 ; LA64-NEXT:    st.d $ra, $sp, 2024 # 8-byte Folded Spill
 ; LA64-NEXT:    st.d $fp, $sp, 2016 # 8-byte Folded Spill
 ; LA64-NEXT:    .cfi_offset 1, -8
 ; LA64-NEXT:    .cfi_offset 22, -16
 ; LA64-NEXT:    addi.d $fp, $sp, 2032
 ; LA64-NEXT:    .cfi_def_cfa 22, 0
 ; LA64-NEXT:    addi.d $sp, $sp, -2048
 ; LA64-NEXT:    addi.d $sp, $sp, -16
-; LA64-NEXT:    srli.d $a0, $sp, 11
-; LA64-NEXT:    slli.d $sp, $a0, 11
+; LA64-NEXT:    bstrins.d $sp, $zero, 10, 0
 ; LA64-NEXT:    ori $a0, $zero, 2048
 ; LA64-NEXT:    add.d $a0, $sp, $a0
 ; LA64-NEXT:    bl %plt(callee)
 ; LA64-NEXT:    lu12i.w $a0, 1
 ; LA64-NEXT:    sub.d $sp, $fp, $a0
 ; LA64-NEXT:    addi.d $sp, $sp, 2032
 ; LA64-NEXT:    addi.d $sp, $sp, 32
 ; LA64-NEXT:    ld.d $fp, $sp, 2016 # 8-byte Folded Reload

 ; LA32-NEXT:    st.w $fp, $sp, 2024 # 4-byte Folded Spill
 ; LA32-NEXT:    .cfi_offset 1, -4
 ; LA32-NEXT:    .cfi_offset 22, -8
 ; LA32-NEXT:    addi.w $fp, $sp, 2032
 ; LA32-NEXT:    .cfi_def_cfa 22, 0
 ; LA32-NEXT:    lu12i.w $a0, 1
 ; LA32-NEXT:    ori $a0, $a0, 2064
 ; LA32-NEXT:    sub.w $sp, $sp, $a0
-; LA32-NEXT:    srli.w $a0, $sp, 12
-; LA32-NEXT:    slli.w $sp, $a0, 12
+; LA32-NEXT:    bstrins.w $sp, $zero, 11, 0
 ; LA32-NEXT:    lu12i.w $a0, 1
 ; LA32-NEXT:    add.w $a0, $sp, $a0
 ; LA32-NEXT:    bl %plt(callee)
 ; LA32-NEXT:    lu12i.w $a0, 2
 ; LA32-NEXT:    sub.w $sp, $fp, $a0
 ; LA32-NEXT:    lu12i.w $a0, 1
 ; LA32-NEXT:    ori $a0, $a0, 2064
 ; LA32-NEXT:    add.w $sp, $sp, $a0

 ; LA64-NEXT:    st.d $fp, $sp, 2016 # 8-byte Folded Spill
 ; LA64-NEXT:    .cfi_offset 1, -8
 ; LA64-NEXT:    .cfi_offset 22, -16
 ; LA64-NEXT:    addi.d $fp, $sp, 2032
 ; LA64-NEXT:    .cfi_def_cfa 22, 0
 ; LA64-NEXT:    lu12i.w $a0, 1
 ; LA64-NEXT:    ori $a0, $a0, 2064
 ; LA64-NEXT:    sub.d $sp, $sp, $a0
-; LA64-NEXT:    srli.d $a0, $sp, 12
-; LA64-NEXT:    slli.d $sp, $a0, 12
+; LA64-NEXT:    bstrins.d $sp, $zero, 11, 0
 ; LA64-NEXT:    lu12i.w $a0, 1
 ; LA64-NEXT:    add.d $a0, $sp, $a0
 ; LA64-NEXT:    bl %plt(callee)
 ; LA64-NEXT:    lu12i.w $a0, 2
 ; LA64-NEXT:    sub.d $sp, $fp, $a0
 ; LA64-NEXT:    lu12i.w $a0, 1
 ; LA64-NEXT:    ori $a0, $a0, 2064
 ; LA64-NEXT:    add.d $sp, $sp, $a0