[llvm-branch-commits] [llvm] [LoongArch] Enable the callee-saved register cost in the register allocator (PR #238727)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Wed Nov 4 01:44:17 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-loongarch

Author: hev (heiher)

<details>
<summary>Changes</summary>

Override getCSRFirstUseCost() and getCSRCostScale() so that the greedy register allocator accounts for the prologue/epilogue save and restore of a callee-saved register, as X86 does. Values live across a call on a cold path no longer pull CSRs into functions whose hot path makes no call, which also lets shrink-wrapping kick in.

rustc-perf on LA664 (8 shuffled layouts, paired):

```
                       cycles     instructions
  fmt-debug-derive     -9.38%     -6.84%
  fmt-write-str        -6.34%     -9.21%
```

Other runtime benchmarks (hashmap, nbody, raytracer, compression, parsing, css, svg, bufreader, arc-rc, text-search, nes) are neutral within noise, e.g. svg-parse -1.49%, pinky-nes -0.40%, nom-json +0.78% (sd 1.08%).

Assisted-By: LLM

---
Full diff: https://github.com/llvm/llvm-project/pull/238727.diff


4 Files Affected:

- (modified) llvm/lib/Target/LoongArch/LoongArchRegisterInfo.h (+9) 
- (modified) llvm/test/CodeGen/LoongArch/csr-first-use-cost.ll (+41-63) 
- (modified) llvm/test/CodeGen/LoongArch/exception-pointer-register.ll (+18-28) 
- (modified) llvm/test/CodeGen/LoongArch/sextw-removal.ll (+33-37) 


``````````diff
diff --git a/llvm/lib/Target/LoongArch/LoongArchRegisterInfo.h b/llvm/lib/Target/LoongArch/LoongArchRegisterInfo.h
index 74861e0f87d6f..2bf324720243d 100644
--- a/llvm/lib/Target/LoongArch/LoongArchRegisterInfo.h
+++ b/llvm/lib/Target/LoongArch/LoongArchRegisterInfo.h
@@ -30,6 +30,15 @@ struct LoongArchRegisterInfo : public LoongArchGenRegisterInfo {
                                        CallingConv::ID) const override;
   const uint32_t *getNoPreservedMask() const override;
 
+  unsigned getCSRFirstUseCost(const MachineFunction &MF) const override {
+    // A store in the prologue and a load in the epilogue.
+    return 2;
+  }
+
+  unsigned getCSRCostScale(const MachineFunction &MF) const override {
+    return 100;
+  }
+
   BitVector getReservedRegs(const MachineFunction &MF) const override;
 
   bool eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
diff --git a/llvm/test/CodeGen/LoongArch/csr-first-use-cost.ll b/llvm/test/CodeGen/LoongArch/csr-first-use-cost.ll
index 9339ed8ad7ff8..775c0677f0633 100644
--- a/llvm/test/CodeGen/LoongArch/csr-first-use-cost.ll
+++ b/llvm/test/CodeGen/LoongArch/csr-first-use-cost.ll
@@ -13,102 +13,80 @@ declare i1 @write_str(ptr, ptr, ptr, i64)
 define i1 @write_prefix(ptr %buf, ptr %vtable, i32 %sign, ptr %prefix, i64 %len) nounwind {
 ; LA32-LABEL: write_prefix:
 ; LA32:       # %bb.0: # %entry
-; LA32-NEXT:    addi.w $sp, $sp, -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:    st.w $s0, $sp, 20 # 4-byte Folded Spill
-; LA32-NEXT:    st.w $s1, $sp, 16 # 4-byte Folded Spill
-; LA32-NEXT:    st.w $s2, $sp, 12 # 4-byte Folded Spill
-; LA32-NEXT:    st.w $s3, $sp, 8 # 4-byte Folded Spill
 ; LA32-NEXT:    lu12i.w $a6, 272
-; LA32-NEXT:    move $fp, $a5
-; LA32-NEXT:    move $s0, $a4
-; LA32-NEXT:    move $s1, $a3
 ; LA32-NEXT:    beq $a2, $a6, .LBB0_2
 ; LA32-NEXT:  # %bb.1: # %write_sign
-; LA32-NEXT:    move $s2, $a0
-; LA32-NEXT:    move $s3, $a1
+; LA32-NEXT:    addi.w $sp, $sp, -32
+; LA32-NEXT:    st.w $ra, $sp, 28 # 4-byte Folded Spill
+; LA32-NEXT:    st.w $a0, $sp, 24 # 4-byte Folded Spill
+; LA32-NEXT:    ld.w $a0, $sp, 24 # 4-byte Folded Reload
+; LA32-NEXT:    st.w $a1, $sp, 20 # 4-byte Folded Spill
+; LA32-NEXT:    ld.w $a1, $sp, 20 # 4-byte Folded Reload
+; LA32-NEXT:    st.w $a5, $sp, 16 # 4-byte Folded Spill
+; LA32-NEXT:    st.w $a4, $sp, 8 # 4-byte Folded Spill
+; LA32-NEXT:    st.w $a3, $sp, 12 # 4-byte Folded Spill
 ; LA32-NEXT:    bl write_char
-; LA32-NEXT:    move $a1, $s3
+; LA32-NEXT:    ld.w $a1, $sp, 20 # 4-byte Folded Reload
+; LA32-NEXT:    ld.w $a3, $sp, 12 # 4-byte Folded Reload
+; LA32-NEXT:    ld.w $a4, $sp, 8 # 4-byte Folded Reload
+; LA32-NEXT:    ld.w $a5, $sp, 16 # 4-byte Folded Reload
 ; LA32-NEXT:    move $a2, $a0
-; LA32-NEXT:    move $a0, $s2
-; LA32-NEXT:    andi $a3, $a2, 1
+; LA32-NEXT:    ld.w $a0, $sp, 24 # 4-byte Folded Reload
+; LA32-NEXT:    andi $a6, $a2, 1
 ; LA32-NEXT:    ori $a2, $zero, 1
-; LA32-NEXT:    bnez $a3, .LBB0_5
-; LA32-NEXT:  .LBB0_2: # %check_prefix
-; LA32-NEXT:    beqz $s1, .LBB0_4
-; LA32-NEXT:  # %bb.3: # %write_prefix_str
-; LA32-NEXT:    move $a2, $s1
-; LA32-NEXT:    move $a3, $s0
-; LA32-NEXT:    move $a4, $fp
-; LA32-NEXT:    ld.w $s3, $sp, 8 # 4-byte Folded Reload
-; LA32-NEXT:    ld.w $s2, $sp, 12 # 4-byte Folded Reload
-; LA32-NEXT:    ld.w $s1, $sp, 16 # 4-byte Folded Reload
-; LA32-NEXT:    ld.w $s0, $sp, 20 # 4-byte Folded Reload
-; 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:    bnez $a6, .LBB0_5
+; LA32-NEXT:  .LBB0_2: # %check_prefix
+; LA32-NEXT:    beqz $a3, .LBB0_4
+; LA32-NEXT:  # %bb.3: # %write_prefix_str
+; LA32-NEXT:    move $a2, $a3
+; LA32-NEXT:    move $a3, $a4
+; LA32-NEXT:    move $a4, $a5
 ; LA32-NEXT:    b write_str
 ; LA32-NEXT:  .LBB0_4:
 ; LA32-NEXT:    move $a2, $zero
 ; LA32-NEXT:  .LBB0_5: # %ret
 ; LA32-NEXT:    move $a0, $a2
-; LA32-NEXT:    ld.w $s3, $sp, 8 # 4-byte Folded Reload
-; LA32-NEXT:    ld.w $s2, $sp, 12 # 4-byte Folded Reload
-; LA32-NEXT:    ld.w $s1, $sp, 16 # 4-byte Folded Reload
-; LA32-NEXT:    ld.w $s0, $sp, 20 # 4-byte Folded Reload
-; 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: write_prefix:
 ; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    addi.d $sp, $sp, -48
-; LA64-NEXT:    st.d $ra, $sp, 40 # 8-byte Folded Spill
-; LA64-NEXT:    st.d $fp, $sp, 32 # 8-byte Folded Spill
-; LA64-NEXT:    st.d $s0, $sp, 24 # 8-byte Folded Spill
-; LA64-NEXT:    st.d $s1, $sp, 16 # 8-byte Folded Spill
-; LA64-NEXT:    st.d $s2, $sp, 8 # 8-byte Folded Spill
 ; LA64-NEXT:    addi.w $a5, $a2, 0
 ; LA64-NEXT:    lu12i.w $a6, 272
-; LA64-NEXT:    move $fp, $a4
-; LA64-NEXT:    move $s0, $a3
 ; LA64-NEXT:    beq $a5, $a6, .LBB0_2
 ; LA64-NEXT:  # %bb.1: # %write_sign
-; LA64-NEXT:    move $s1, $a0
-; LA64-NEXT:    move $s2, $a1
+; LA64-NEXT:    addi.d $sp, $sp, -48
+; LA64-NEXT:    st.d $ra, $sp, 40 # 8-byte Folded Spill
+; LA64-NEXT:    st.d $a0, $sp, 32 # 8-byte Folded Spill
+; LA64-NEXT:    ld.d $a0, $sp, 32 # 8-byte Folded Reload
+; LA64-NEXT:    st.d $a1, $sp, 24 # 8-byte Folded Spill
+; LA64-NEXT:    ld.d $a1, $sp, 24 # 8-byte Folded Reload
+; LA64-NEXT:    st.d $a4, $sp, 16 # 8-byte Folded Spill
+; LA64-NEXT:    st.d $a3, $sp, 8 # 8-byte Folded Spill
 ; LA64-NEXT:    pcaddu18i $ra, %call36(write_char)
 ; LA64-NEXT:    jirl $ra, $ra, 0
-; LA64-NEXT:    move $a1, $s2
+; LA64-NEXT:    ld.d $a1, $sp, 24 # 8-byte Folded Reload
+; LA64-NEXT:    ld.d $a3, $sp, 8 # 8-byte Folded Reload
+; LA64-NEXT:    ld.d $a4, $sp, 16 # 8-byte Folded Reload
 ; LA64-NEXT:    move $a2, $a0
-; LA64-NEXT:    move $a0, $s1
-; LA64-NEXT:    andi $a3, $a2, 1
+; LA64-NEXT:    ld.d $a0, $sp, 32 # 8-byte Folded Reload
+; LA64-NEXT:    andi $a5, $a2, 1
 ; LA64-NEXT:    ori $a2, $zero, 1
-; LA64-NEXT:    bnez $a3, .LBB0_5
-; LA64-NEXT:  .LBB0_2: # %check_prefix
-; LA64-NEXT:    beqz $s0, .LBB0_4
-; LA64-NEXT:  # %bb.3: # %write_prefix_str
-; LA64-NEXT:    move $a2, $s0
-; LA64-NEXT:    move $a3, $fp
-; LA64-NEXT:    ld.d $s2, $sp, 8 # 8-byte Folded Reload
-; LA64-NEXT:    ld.d $s1, $sp, 16 # 8-byte Folded Reload
-; LA64-NEXT:    ld.d $s0, $sp, 24 # 8-byte Folded Reload
-; LA64-NEXT:    ld.d $fp, $sp, 32 # 8-byte Folded Reload
 ; LA64-NEXT:    ld.d $ra, $sp, 40 # 8-byte Folded Reload
 ; LA64-NEXT:    addi.d $sp, $sp, 48
+; LA64-NEXT:    bnez $a5, .LBB0_5
+; LA64-NEXT:  .LBB0_2: # %check_prefix
+; LA64-NEXT:    beqz $a3, .LBB0_4
+; LA64-NEXT:  # %bb.3: # %write_prefix_str
+; LA64-NEXT:    move $a2, $a3
+; LA64-NEXT:    move $a3, $a4
 ; LA64-NEXT:    pcaddu18i $t8, %call36(write_str)
 ; LA64-NEXT:    jr $t8
 ; LA64-NEXT:  .LBB0_4:
 ; LA64-NEXT:    move $a2, $zero
 ; LA64-NEXT:  .LBB0_5: # %ret
 ; LA64-NEXT:    move $a0, $a2
-; LA64-NEXT:    ld.d $s2, $sp, 8 # 8-byte Folded Reload
-; LA64-NEXT:    ld.d $s1, $sp, 16 # 8-byte Folded Reload
-; LA64-NEXT:    ld.d $s0, $sp, 24 # 8-byte Folded Reload
-; LA64-NEXT:    ld.d $fp, $sp, 32 # 8-byte Folded Reload
-; LA64-NEXT:    ld.d $ra, $sp, 40 # 8-byte Folded Reload
-; LA64-NEXT:    addi.d $sp, $sp, 48
 ; LA64-NEXT:    ret
 entry:
   %has_sign = icmp ne i32 %sign, 1114112
diff --git a/llvm/test/CodeGen/LoongArch/exception-pointer-register.ll b/llvm/test/CodeGen/LoongArch/exception-pointer-register.ll
index 0c8ed9e0b5a13..bb149b6d34652 100644
--- a/llvm/test/CodeGen/LoongArch/exception-pointer-register.ll
+++ b/llvm/test/CodeGen/LoongArch/exception-pointer-register.ll
@@ -19,35 +19,30 @@ define void @caller(ptr %p) personality ptr @__gxx_personality_v0 {
 ; LA32-NEXT:    .cfi_def_cfa_offset 16
 ; LA32-NEXT:    st.w $ra, $sp, 12 # 4-byte Folded Spill
 ; LA32-NEXT:    st.w $fp, $sp, 8 # 4-byte Folded Spill
-; LA32-NEXT:    st.w $s0, $sp, 4 # 4-byte Folded Spill
 ; LA32-NEXT:    .cfi_offset 1, -4
 ; LA32-NEXT:    .cfi_offset 22, -8
-; LA32-NEXT:    .cfi_offset 23, -12
-; LA32-NEXT:    move $fp, $a0
+; LA32-NEXT:    st.w $a0, $sp, 4 # 4-byte Folded Spill
 ; LA32-NEXT:    beqz $a0, .LBB0_2
 ; LA32-NEXT:  # %bb.1: # %bb2
-; LA32-NEXT:  .Ltmp0:
-; LA32-NEXT:    move $a0, $fp
+; LA32-NEXT:  .Ltmp0: # EH_LABEL
 ; LA32-NEXT:    bl bar
-; LA32-NEXT:  .Ltmp1:
+; LA32-NEXT:  .Ltmp1: # EH_LABEL
 ; LA32-NEXT:    b .LBB0_3
 ; LA32-NEXT:  .LBB0_2: # %bb1
-; LA32-NEXT:  .Ltmp2:
-; LA32-NEXT:    move $a0, $fp
+; LA32-NEXT:  .Ltmp2: # EH_LABEL
 ; LA32-NEXT:    bl foo
-; LA32-NEXT:  .Ltmp3:
+; LA32-NEXT:  .Ltmp3: # EH_LABEL
 ; LA32-NEXT:  .LBB0_3: # %end2
-; LA32-NEXT:    ld.w $s0, $sp, 4 # 4-byte Folded Reload
 ; LA32-NEXT:    ld.w $fp, $sp, 8 # 4-byte Folded Reload
 ; LA32-NEXT:    ld.w $ra, $sp, 12 # 4-byte Folded Reload
 ; LA32-NEXT:    addi.w $sp, $sp, 16
 ; LA32-NEXT:    ret
 ; LA32-NEXT:  .LBB0_4: # %lpad
-; LA32-NEXT:  .Ltmp4:
-; LA32-NEXT:    move $s0, $a0
-; LA32-NEXT:    move $a0, $fp
+; LA32-NEXT:  .Ltmp4: # EH_LABEL
+; LA32-NEXT:    move $fp, $a0
+; LA32-NEXT:    ld.w $a0, $sp, 4 # 4-byte Folded Reload
 ; LA32-NEXT:    bl callee
-; LA32-NEXT:    move $a0, $s0
+; LA32-NEXT:    move $a0, $fp
 ; LA32-NEXT:    bl _Unwind_Resume
 ;
 ; LA64-LABEL: caller:
@@ -56,38 +51,33 @@ define void @caller(ptr %p) personality ptr @__gxx_personality_v0 {
 ; 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:    st.d $s0, $sp, 8 # 8-byte Folded Spill
 ; LA64-NEXT:    .cfi_offset 1, -8
 ; LA64-NEXT:    .cfi_offset 22, -16
-; LA64-NEXT:    .cfi_offset 23, -24
-; LA64-NEXT:    move $fp, $a0
+; LA64-NEXT:    st.d $a0, $sp, 8 # 8-byte Folded Spill
 ; LA64-NEXT:    beqz $a0, .LBB0_2
 ; LA64-NEXT:  # %bb.1: # %bb2
-; LA64-NEXT:  .Ltmp0:
-; LA64-NEXT:    move $a0, $fp
+; LA64-NEXT:  .Ltmp0: # EH_LABEL
 ; LA64-NEXT:    pcaddu18i $ra, %call36(bar)
 ; LA64-NEXT:    jirl $ra, $ra, 0
-; LA64-NEXT:  .Ltmp1:
+; LA64-NEXT:  .Ltmp1: # EH_LABEL
 ; LA64-NEXT:    b .LBB0_3
 ; LA64-NEXT:  .LBB0_2: # %bb1
-; LA64-NEXT:  .Ltmp2:
-; LA64-NEXT:    move $a0, $fp
+; LA64-NEXT:  .Ltmp2: # EH_LABEL
 ; LA64-NEXT:    pcaddu18i $ra, %call36(foo)
 ; LA64-NEXT:    jirl $ra, $ra, 0
-; LA64-NEXT:  .Ltmp3:
+; LA64-NEXT:  .Ltmp3: # EH_LABEL
 ; LA64-NEXT:  .LBB0_3: # %end2
-; LA64-NEXT:    ld.d $s0, $sp, 8 # 8-byte Folded Reload
 ; 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
 ; LA64-NEXT:  .LBB0_4: # %lpad
-; LA64-NEXT:  .Ltmp4:
-; LA64-NEXT:    move $s0, $a0
-; LA64-NEXT:    move $a0, $fp
+; LA64-NEXT:  .Ltmp4: # EH_LABEL
+; LA64-NEXT:    move $fp, $a0
+; LA64-NEXT:    ld.d $a0, $sp, 8 # 8-byte Folded Reload
 ; LA64-NEXT:    pcaddu18i $ra, %call36(callee)
 ; LA64-NEXT:    jirl $ra, $ra, 0
-; LA64-NEXT:    move $a0, $s0
+; LA64-NEXT:    move $a0, $fp
 ; LA64-NEXT:    pcaddu18i $ra, %call36(_Unwind_Resume)
 ; LA64-NEXT:    jirl $ra, $ra, 0
 entry:
diff --git a/llvm/test/CodeGen/LoongArch/sextw-removal.ll b/llvm/test/CodeGen/LoongArch/sextw-removal.ll
index 232dd8d626263..97fe5a3487074 100644
--- a/llvm/test/CodeGen/LoongArch/sextw-removal.ll
+++ b/llvm/test/CodeGen/LoongArch/sextw-removal.ll
@@ -1373,38 +1373,36 @@ define fastcc ptr @test21(ptr %B, ptr %Op0, ptr %Op1, ptr %P, ptr %M, i1 zeroext
 ; CHECK-NEXT:    .cfi_offset 29, -72
 ; CHECK-NEXT:    ld.w $s6, $sp, 80
 ; CHECK-NEXT:    move $s2, $a7
-; CHECK-NEXT:    move $s4, $a5
+; CHECK-NEXT:    move $s5, $a5
 ; CHECK-NEXT:    move $s0, $a4
-; CHECK-NEXT:    move $fp, $a3
-; CHECK-NEXT:    move $s5, $a2
-; CHECK-NEXT:    move $s3, $a1
+; CHECK-NEXT:    move $s3, $a3
+; CHECK-NEXT:    move $s4, $a2
+; CHECK-NEXT:    move $fp, $a1
 ; CHECK-NEXT:    move $s1, $a0
 ; CHECK-NEXT:    move $a0, $zero
 ; CHECK-NEXT:    jirl $ra, $zero, 0
-; CHECK-NEXT:    beqz $s4, .LBB24_2
+; CHECK-NEXT:    beqz $s5, .LBB24_2
 ; CHECK-NEXT:  # %bb.1: # %if.then26
 ; CHECK-NEXT:    addi.w $s6, $s6, 1
-; CHECK-NEXT:    beqz $s4, .LBB24_3
-; CHECK-NEXT:    b .LBB24_6
-; CHECK-NEXT:  .LBB24_2:
-; CHECK-NEXT:    move $s3, $s5
-; CHECK-NEXT:    bnez $s4, .LBB24_6
-; CHECK-NEXT:  .LBB24_3: # %for.cond32.preheader.preheader
+; CHECK-NEXT:    move $s4, $fp
+; CHECK-NEXT:  .LBB24_2: # %if.end30
+; CHECK-NEXT:    bnez $s5, .LBB24_6
+; CHECK-NEXT:  # %bb.3: # %for.cond32.preheader.preheader
 ; CHECK-NEXT:    ld.d $a0, $sp, 96
-; CHECK-NEXT:    ld.d $a1, $sp, 88
-; CHECK-NEXT:    sltui $a2, $s6, 1
-; CHECK-NEXT:    masknez $a0, $a0, $a2
+; CHECK-NEXT:    ld.d $a2, $sp, 88
+; CHECK-NEXT:    sltui $a3, $s6, 1
+; CHECK-NEXT:    masknez $a0, $a0, $a3
 ; CHECK-NEXT:    vreplgr2vr.w $vr0, $s6
-; CHECK-NEXT:    andi $a1, $a1, 1
+; CHECK-NEXT:    andi $a2, $a2, 1
 ; CHECK-NEXT:    .p2align 4, , 16
 ; CHECK-NEXT:  .LBB24_4: # %for.cond32.preheader
 ; CHECK-NEXT:    # =>This Inner Loop Header: Depth=1
 ; CHECK-NEXT:    st.w $a0, $zero, 0
 ; CHECK-NEXT:    vst $vr0, $s2, 0
-; CHECK-NEXT:    bnez $a1, .LBB24_4
+; CHECK-NEXT:    bnez $a2, .LBB24_4
 ; CHECK-NEXT:  # %bb.5: # %for.cond.cleanup
 ; CHECK-NEXT:    move $a0, $zero
-; CHECK-NEXT:    move $a1, $s3
+; CHECK-NEXT:    move $a1, $s4
 ; CHECK-NEXT:    move $a2, $zero
 ; CHECK-NEXT:    move $a3, $zero
 ; CHECK-NEXT:    move $a4, $zero
@@ -1413,7 +1411,7 @@ define fastcc ptr @test21(ptr %B, ptr %Op0, ptr %Op1, ptr %P, ptr %M, i1 zeroext
 ; CHECK-NEXT:    move $a0, $s1
 ; CHECK-NEXT:    move $a1, $s0
 ; CHECK-NEXT:    move $a2, $zero
-; CHECK-NEXT:    move $a3, $fp
+; CHECK-NEXT:    move $a3, $s3
 ; CHECK-NEXT:    jirl $ra, $zero, 0
 ; CHECK-NEXT:  .LBB24_6: # %for.cond32.preheader.us.preheader
 ; CHECK-NEXT:    move $a0, $zero
@@ -1453,40 +1451,38 @@ define fastcc ptr @test21(ptr %B, ptr %Op0, ptr %Op1, ptr %P, ptr %M, i1 zeroext
 ; NORMV-NEXT:    .cfi_offset 29, -72
 ; NORMV-NEXT:    ld.d $s6, $sp, 80
 ; NORMV-NEXT:    move $s2, $a7
-; NORMV-NEXT:    move $s4, $a5
+; NORMV-NEXT:    move $s5, $a5
 ; NORMV-NEXT:    move $s0, $a4
-; NORMV-NEXT:    move $fp, $a3
-; NORMV-NEXT:    move $s5, $a2
-; NORMV-NEXT:    move $s3, $a1
+; NORMV-NEXT:    move $s3, $a3
+; NORMV-NEXT:    move $s4, $a2
+; NORMV-NEXT:    move $fp, $a1
 ; NORMV-NEXT:    move $s1, $a0
 ; NORMV-NEXT:    move $a0, $zero
 ; NORMV-NEXT:    jirl $ra, $zero, 0
-; NORMV-NEXT:    beqz $s4, .LBB24_2
+; NORMV-NEXT:    beqz $s5, .LBB24_2
 ; NORMV-NEXT:  # %bb.1: # %if.then26
 ; NORMV-NEXT:    addi.d $a0, $s6, 1
 ; NORMV-NEXT:    addi.d $s6, $a0, 0
-; NORMV-NEXT:    beqz $s4, .LBB24_3
-; NORMV-NEXT:    b .LBB24_6
-; NORMV-NEXT:  .LBB24_2:
-; NORMV-NEXT:    move $s3, $s5
-; NORMV-NEXT:    bnez $s4, .LBB24_6
-; NORMV-NEXT:  .LBB24_3: # %for.cond32.preheader.preheader
+; NORMV-NEXT:    move $s4, $fp
+; NORMV-NEXT:  .LBB24_2: # %if.end30
+; NORMV-NEXT:    bnez $s5, .LBB24_6
+; NORMV-NEXT:  # %bb.3: # %for.cond32.preheader.preheader
 ; NORMV-NEXT:    ld.d $a0, $sp, 96
-; NORMV-NEXT:    ld.d $a1, $sp, 88
-; NORMV-NEXT:    addi.w $a2, $s6, 0
-; NORMV-NEXT:    sltui $a2, $a2, 1
-; NORMV-NEXT:    masknez $a0, $a0, $a2
+; NORMV-NEXT:    ld.d $a2, $sp, 88
+; NORMV-NEXT:    addi.w $a3, $s6, 0
+; NORMV-NEXT:    sltui $a3, $a3, 1
+; NORMV-NEXT:    masknez $a0, $a0, $a3
 ; NORMV-NEXT:    vreplgr2vr.w $vr0, $s6
-; NORMV-NEXT:    andi $a1, $a1, 1
+; NORMV-NEXT:    andi $a2, $a2, 1
 ; NORMV-NEXT:    .p2align 4, , 16
 ; NORMV-NEXT:  .LBB24_4: # %for.cond32.preheader
 ; NORMV-NEXT:    # =>This Inner Loop Header: Depth=1
 ; NORMV-NEXT:    st.w $a0, $zero, 0
 ; NORMV-NEXT:    vst $vr0, $s2, 0
-; NORMV-NEXT:    bnez $a1, .LBB24_4
+; NORMV-NEXT:    bnez $a2, .LBB24_4
 ; NORMV-NEXT:  # %bb.5: # %for.cond.cleanup
 ; NORMV-NEXT:    move $a0, $zero
-; NORMV-NEXT:    move $a1, $s3
+; NORMV-NEXT:    move $a1, $s4
 ; NORMV-NEXT:    move $a2, $zero
 ; NORMV-NEXT:    move $a3, $zero
 ; NORMV-NEXT:    move $a4, $zero
@@ -1495,7 +1491,7 @@ define fastcc ptr @test21(ptr %B, ptr %Op0, ptr %Op1, ptr %P, ptr %M, i1 zeroext
 ; NORMV-NEXT:    move $a0, $s1
 ; NORMV-NEXT:    move $a1, $s0
 ; NORMV-NEXT:    move $a2, $zero
-; NORMV-NEXT:    move $a3, $fp
+; NORMV-NEXT:    move $a3, $s3
 ; NORMV-NEXT:    jirl $ra, $zero, 0
 ; NORMV-NEXT:  .LBB24_6: # %for.cond32.preheader.us.preheader
 ; NORMV-NEXT:    move $a0, $zero

``````````

</details>


https://github.com/llvm/llvm-project/pull/238727


More information about the llvm-branch-commits mailing list