[llvm-branch-commits] [llvm] [RegAlloc] Add enableCSRFirstTimeMinCost to let RegAlloc has more choice (PR #239530)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Thu Nov 12 22:33:19 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-amdgpu

Author: Piyou Chen (BeMg)

<details>
<summary>Changes</summary>

This is patch 2 of 4. Together, they adjust `tryAssignCSRFirstTime` and the `getCSRCost` value to improve prologue/epilogue codegen in benchmarks. 

- https://github.com/llvm/llvm-project/pull/239526
- https://github.com/llvm/llvm-project/pull/239530
- https://github.com/llvm/llvm-project/pull/239532
- https://github.com/llvm/llvm-project/pull/239534

-----

This patch add the `tryAssignCSRFirstTimeMinCost` to provide more choices than `tryAssignCSRFirstTime` when Greedy RegAlloc try to assigned the unused CSR to VirtReg. 

This feature control by `enableCSRFirstTimeMinCost` target hook. 

---

Patch is 312.92 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/239530.diff


35 Files Affected:

- (modified) llvm/include/llvm/CodeGen/TargetRegisterInfo.h (+10) 
- (modified) llvm/lib/CodeGen/RegAllocGreedy.cpp (+133-12) 
- (modified) llvm/lib/CodeGen/RegAllocGreedy.h (+6) 
- (modified) llvm/lib/Target/AMDGPU/SIRegisterInfo.h (+9) 
- (modified) llvm/test/CodeGen/AArch64/call-rv-marker.ll (+27-24) 
- (modified) llvm/test/CodeGen/AArch64/sme-za-exceptions.ll (+21-26) 
- (modified) llvm/test/CodeGen/AMDGPU/bf16.ll (+148-158) 
- (modified) llvm/test/CodeGen/AMDGPU/fcopysign.bf16.ll (+181-215) 
- (modified) llvm/test/CodeGen/AMDGPU/fcopysign.f16.ll (+91-108) 
- (modified) llvm/test/CodeGen/AMDGPU/infloop-subrange-spill-inspect-subrange.mir (+18-22) 
- (modified) llvm/test/CodeGen/AMDGPU/infloop-subrange-spill.mir (+17-20) 
- (modified) llvm/test/CodeGen/AMDGPU/issue48473.mir (+1-1) 
- (modified) llvm/test/CodeGen/AMDGPU/large-avgpr-assign-last.mir (+5-5) 
- (modified) llvm/test/CodeGen/AMDGPU/maximumnum.bf16.ll (+202-202) 
- (modified) llvm/test/CodeGen/AMDGPU/maximumnum.ll (+217-230) 
- (modified) llvm/test/CodeGen/AMDGPU/minimumnum.bf16.ll (+202-202) 
- (modified) llvm/test/CodeGen/AMDGPU/minimumnum.ll (+217-230) 
- (modified) llvm/test/CodeGen/AMDGPU/select.f16.ll (+84-84) 
- (modified) llvm/test/CodeGen/RISCV/csr-first-use-cost.ll (+9-9) 
- (modified) llvm/test/CodeGen/RISCV/exception-pointer-register.ll (+14-22) 
- (modified) llvm/test/CodeGen/X86/2007-08-09-IllegalX86-64Asm.ll (+11-13) 
- (modified) llvm/test/CodeGen/X86/2007-11-30-LoadFolding-Bug.ll (+36-37) 
- (modified) llvm/test/CodeGen/X86/2008-04-16-ReMatBug.ll (+18-17) 
- (modified) llvm/test/CodeGen/X86/2008-04-17-CoalescerBug.ll (+11-19) 
- (modified) llvm/test/CodeGen/X86/apx/memfold-origVNI-crash.ll (+43-47) 
- (modified) llvm/test/CodeGen/X86/atom-fixup-lea2.ll (+2-2) 
- (modified) llvm/test/CodeGen/X86/call-rv-marker.ll (+3-6) 
- (modified) llvm/test/CodeGen/X86/csr-split.ll (+4-5) 
- (modified) llvm/test/CodeGen/X86/expand-large-fp-optnone.ll (+48-62) 
- (modified) llvm/test/CodeGen/X86/i386-shrink-wrapping.ll (+2-2) 
- (modified) llvm/test/CodeGen/X86/lrshrink-ehpad-phis.ll (+14-14) 
- (modified) llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll (+20-20) 
- (modified) llvm/test/CodeGen/X86/speculative-load-hardening.ll (+15-21) 
- (modified) llvm/test/CodeGen/X86/throws-cfi-fp.ll (+2-5) 
- (modified) llvm/test/CodeGen/X86/throws-cfi-no-fp.ll (+1-1) 


``````````diff
diff --git a/llvm/include/llvm/CodeGen/TargetRegisterInfo.h b/llvm/include/llvm/CodeGen/TargetRegisterInfo.h
index fc3b4d6dda844..880a48df56466 100644
--- a/llvm/include/llvm/CodeGen/TargetRegisterInfo.h
+++ b/llvm/include/llvm/CodeGen/TargetRegisterInfo.h
@@ -899,6 +899,16 @@ class LLVM_ABI TargetRegisterInfo : public MCRegisterInfo {
     return 30;
   }
 
+  /// Return true if the RegAlloc can spill instead of using an unused CSR,
+  /// when the spill costs less than the CSR cost. Return false if a spill
+  /// on this target is not comparable with the CSR cost, for example when
+  /// a spill does not go to the stack.
+  virtual bool
+  shouldSpillInsteadOfFirstCSRUse(const MachineFunction &MF,
+                                  const LiveInterval &VirtReg) const {
+    return true;
+  }
+
   /// Returns true if the target requires (and can make use of) the register
   /// scavenger.
   virtual bool requiresRegisterScavenging(const MachineFunction &MF) const {
diff --git a/llvm/lib/CodeGen/RegAllocGreedy.cpp b/llvm/lib/CodeGen/RegAllocGreedy.cpp
index f7655e97b9942..55c11987c0898 100644
--- a/llvm/lib/CodeGen/RegAllocGreedy.cpp
+++ b/llvm/lib/CodeGen/RegAllocGreedy.cpp
@@ -2471,6 +2471,50 @@ BlockFrequency RAGreedy::calcRematCost(const LiveInterval &VirtReg,
   return HasUse ? RematCost : BlockFrequency::max();
 }
 
+/// Return true if the spiller can rematerialize each use of LI.
+/// And it can rematerialize for only one def, which does not load.
+static bool isRematerializableFromOriginal(const LiveInterval &LI,
+                                           const LiveIntervals &LIS,
+                                           const VirtRegMap &VRM,
+                                           const MachineRegisterInfo &MRI,
+                                           const TargetInstrInfo &TII) {
+  const LiveInterval &OrigLI = LIS.getInterval(VRM.getOriginal(LI.reg()));
+  const MachineInstr *Def = nullptr;
+  for (const VNInfo *VNI : OrigLI.valnos) {
+    if (VNI->isUnused())
+      continue;
+    // The original live range must have only one def.
+    if (VNI->isPHIDef() || Def)
+      return false;
+    Def = LIS.getInstructionFromIndex(VNI->def);
+    if (!Def || !TII.isReMaterializable(*Def) || Def->mayLoad())
+      return false;
+  }
+  if (!Def)
+    return false;
+  for (const MachineInstr &MI : MRI.use_nodbg_instructions(LI.reg()))
+    if (!canGuaranteeAssignmentAfterRemat(LI.reg(), MI) ||
+        !VirtRegAuxInfo::allUsesAvailableAt(Def, LIS.getInstructionIndex(MI),
+                                            LIS, MRI, TII))
+      return false;
+  return true;
+}
+
+/// The cost of rematerializing \p LI before each of its uses.
+static BlockFrequency calcRematCostAtUses(const LiveInterval &LI,
+                                          const MachineRegisterInfo &MRI,
+                                          const SpillPlacement &SpillPlacer) {
+  uint64_t RematCost = 0;
+  SmallPtrSet<const MachineInstr *, 8> Seen;
+  for (const MachineInstr &MI : MRI.use_nodbg_instructions(LI.reg())) {
+    if (MI.isMetaInstruction() || !Seen.insert(&MI).second)
+      continue;
+    RematCost += SpillPlacer.getBlockFrequency(MI.getParent()->getNumber())
+                     .getFrequency();
+  }
+  return BlockFrequency(RematCost);
+}
+
 /// Using a CSR for the first time has a cost because it causes push|pop
 /// to be added to prologue|epilogue. Splitting a cold section of the live
 /// range can have lower cost than using the CSR for the first time;
@@ -2482,6 +2526,10 @@ MCRegister RAGreedy::tryAssignCSRFirstTime(
     uint8_t &CostPerUseLimit, SmallVectorImpl<Register> &NewVRegs) {
   LiveRangeStage Stage = ExtraInfo->getStage(VirtReg);
 
+  // For RS_Done, just use the CSR.
+  if (Stage > RS_Spill)
+    return PhysReg;
+
   if (Stage == RS_Spill && VirtReg.isSpillable()) {
     // We choose spill or rematerialize over using the CSR for the first time if
     // the spill cost is lower than CSRCost.
@@ -2496,34 +2544,107 @@ MCRegister RAGreedy::tryAssignCSRFirstTime(
     CostPerUseLimit = 1;
     return MCRegister();
   }
+
+  // The lowest cost of rematerializing or spilling VirtReg.
+  BlockFrequency SpillCost = BlockFrequency::max();
+  if (VirtReg.isSpillable()) {
+    if (isRematerializableFromOriginal(VirtReg, *LIS, *VRM, *MRI, *TII))
+      SpillCost = calcRematCostAtUses(VirtReg, *MRI, *SpillPlacer);
+    if (TRI->shouldSpillInsteadOfFirstCSRUse(*MF, VirtReg))
+      SpillCost = std::min(SpillCost, calcSpillCost(VirtReg));
+  }
+
   if (Stage < RS_Split) {
     // We choose pre-splitting over using the CSR for the first time if
-    // the cost of splitting is lower than CSRCost.
+    // the cost of splitting is lower than CSRCost and the remat/spill cost.
     SA->analyze(&VirtReg);
     unsigned NumCands = 0;
     BlockFrequency BestCost = CSRCost; // Don't modify CSRCost.
     unsigned BestCand = calculateRegionSplitCost(VirtReg, Order, BestCost,
                                                  NumCands, true /*IgnoreCSR*/);
-    if (BestCand == NoCand) {
-      if (calcRematCost(VirtReg, Order) < CSRCost) {
-        CostPerUseLimit = 1;
-        return MCRegister();
-      }
-      // Use the CSR if we can't find a region split below CSRCost.
-      return PhysReg;
+    if (BestCand != NoCand && BestCost <= SpillCost) {
+      // Perform the actual pre-splitting.
+      doRegionSplit(VirtReg, BestCand, false /*HasCompact*/, NewVRegs);
+      return MCRegister();
     }
-
-    // Perform the actual pre-splitting.
-    doRegionSplit(VirtReg, BestCand, false/*HasCompact*/, NewVRegs);
-    return MCRegister();
   }
   if (calcRematCost(VirtReg, Order) < CSRCost) {
     CostPerUseLimit = 1;
     return MCRegister();
   }
+  // Evict rematerializable live ranges from a register that is not an unused
+  // CSR, if that costs less than CSRCost and the spill cost.
+  if (MCRegister Reg = tryEvictRematForCSR(VirtReg, Order, NewVRegs,
+                                           std::min(CSRCost, SpillCost)))
+    return Reg;
+  // We choose spilling or rematerialization over using the CSR for the first
+  // time if it costs less than CSRCost.
+  if (SpillCost < CSRCost) {
+    // Set CostPerUseLimit to 1 to make sure that we will not use a
+    // callee-saved register in tryEvict.
+    ExtraInfo->setStage(VirtReg, RS_Spill);
+    CostPerUseLimit = 1;
+    return MCRegister();
+  }
+  // Use the CSR if no other choice costs less than CSRCost.
   return PhysReg;
 }
 
+/// Return the cost of evicting and rematerializing all the live ranges that
+/// interfere with VirtReg in PhysReg.
+/// Return BlockFrequency::max() when one of these live ranges
+///  1. has a Cascade that is not lower than Cascade,
+///  2. can't be spilled, or
+///  3. can't be rematerialized.
+BlockFrequency RAGreedy::calcEvictRematCost(const LiveInterval &VirtReg,
+                                            MCRegister PhysReg,
+                                            unsigned Cascade) const {
+  BlockFrequency Cost(0);
+  SmallPtrSet<const LiveInterval *, 4> Seen;
+  for (MCRegUnit Unit : TRI->regunits(PhysReg)) {
+    for (const LiveInterval *Intf :
+         Matrix->query(VirtReg, Unit).interferingVRegs()) {
+      if (!Seen.insert(Intf).second)
+        continue;
+      if (ExtraInfo->getCascade(Intf->reg()) >= Cascade ||
+          !Intf->isSpillable() ||
+          !isRematerializableFromOriginal(*Intf, *LIS, *VRM, *MRI, *TII))
+        return BlockFrequency::max();
+      Cost += calcRematCostAtUses(*Intf, *MRI, *SpillPlacer);
+    }
+  }
+  return Cost;
+}
+
+/// Before VirtReg uses a CSR for the first time, look for a register that
+/// is not an unused CSR and that only rematerializable live ranges occupy.
+/// If rematerializing them costs less than MaxCost, evict them and
+/// return the register.
+MCRegister RAGreedy::tryEvictRematForCSR(const LiveInterval &VirtReg,
+                                         AllocationOrder &Order,
+                                         SmallVectorImpl<Register> &NewVRegs,
+                                         BlockFrequency MaxCost) {
+  unsigned Cascade = ExtraInfo->getCascadeOrCurrentNext(VirtReg.reg());
+  MCRegister BestReg;
+  BlockFrequency BestCost = MaxCost;
+  for (MCRegister PhysReg : Order.getOrder()) {
+    if (EvictAdvisor->getUnusedCalleeSavedReg(VirtReg, PhysReg) ||
+        Matrix->checkInterference(VirtReg, PhysReg) !=
+            LiveRegMatrix::IK_VirtReg)
+      continue;
+    BlockFrequency Cost = calcEvictRematCost(VirtReg, PhysReg, Cascade);
+    if (Cost < BestCost) {
+      BestCost = Cost;
+      BestReg = PhysReg;
+    }
+  }
+  if (!BestReg)
+    return MCRegister();
+
+  evictInterference(VirtReg, BestReg, NewVRegs);
+  return BestReg;
+}
+
 void RAGreedy::aboutToRemoveInterval(const LiveInterval &LI) {
   // Do not keep invalid information around.
   SetOfBrokenHints.remove(&LI);
diff --git a/llvm/lib/CodeGen/RegAllocGreedy.h b/llvm/lib/CodeGen/RegAllocGreedy.h
index 138da362a1e76..16273854eaaf6 100644
--- a/llvm/lib/CodeGen/RegAllocGreedy.h
+++ b/llvm/lib/CodeGen/RegAllocGreedy.h
@@ -365,6 +365,12 @@ class LLVM_LIBRARY_VISIBILITY RAGreedy : public RegAllocBase,
   /// rematerialization is not possible.
   BlockFrequency calcRematCost(const LiveInterval &VirtReg,
                                AllocationOrder &Order) const;
+  BlockFrequency calcEvictRematCost(const LiveInterval &VirtReg,
+                                    MCRegister PhysReg, unsigned Cascade) const;
+  MCRegister tryEvictRematForCSR(const LiveInterval &VirtReg,
+                                 AllocationOrder &Order,
+                                 SmallVectorImpl<Register> &NewVRegs,
+                                 BlockFrequency MaxCost);
   BlockFrequency calcSpillCost(const LiveInterval &LI);
   void initializeCSRCost();
   MCRegister tryBlockSplit(const LiveInterval &, AllocationOrder &,
diff --git a/llvm/lib/Target/AMDGPU/SIRegisterInfo.h b/llvm/lib/Target/AMDGPU/SIRegisterInfo.h
index 4cacba0ed2592..a1362f34848e2 100644
--- a/llvm/lib/Target/AMDGPU/SIRegisterInfo.h
+++ b/llvm/lib/Target/AMDGPU/SIRegisterInfo.h
@@ -128,6 +128,15 @@ class SIRegisterInfo final : public AMDGPUGenRegisterInfo {
     return 27;
   }
 
+  bool
+  shouldSpillInsteadOfFirstCSRUse(const MachineFunction &MF,
+                                  const LiveInterval &VirtReg) const override {
+    // An SGPR spill goes to a VGPR lane, like a CSR SGPR save, but at each use,
+    // and it needs one more WWM VGPR. getCSRFirstUseCost also models occupancy,
+    // so it is not comparable with the spill cost.
+    return false;
+  }
+
   bool shouldCompactSlotIndexes(const MachineFunction &MF) const override {
     return true;
   }
diff --git a/llvm/test/CodeGen/AArch64/call-rv-marker.ll b/llvm/test/CodeGen/AArch64/call-rv-marker.ll
index a2a9138f57f9a..682f0435ab0dd 100644
--- a/llvm/test/CodeGen/AArch64/call-rv-marker.ll
+++ b/llvm/test/CodeGen/AArch64/call-rv-marker.ll
@@ -89,9 +89,10 @@ define dso_local void @rv_marker_3() personality ptr @__gxx_personality_v0 {
 ; CHECK-SD-NEXT:    .cfi_personality 155, ___gxx_personality_v0
 ; CHECK-SD-NEXT:    .cfi_lsda 16, Lexception0
 ; CHECK-SD-NEXT:  ; %bb.0: ; %entry
-; CHECK-SD-NEXT:    stp x20, x19, [sp, #-32]! ; 16-byte Folded Spill
-; CHECK-SD-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
-; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-SD-NEXT:    sub sp, sp, #48
+; CHECK-SD-NEXT:    stp x20, x19, [sp, #16] ; 16-byte Folded Spill
+; CHECK-SD-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 ; CHECK-SD-NEXT:    .cfi_offset w30, -8
 ; CHECK-SD-NEXT:    .cfi_offset w29, -16
 ; CHECK-SD-NEXT:    .cfi_offset w19, -24
@@ -104,16 +105,17 @@ define dso_local void @rv_marker_3() personality ptr @__gxx_personality_v0 {
 ; CHECK-SD-NEXT:    bl _objc_object
 ; CHECK-SD-NEXT:  Ltmp1: ; EH_LABEL
 ; CHECK-SD-NEXT:  ; %bb.1: ; %invoke.cont
-; CHECK-SD-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
 ; CHECK-SD-NEXT:    mov x0, x19
-; CHECK-SD-NEXT:    ldp x20, x19, [sp], #32 ; 16-byte Folded Reload
+; CHECK-SD-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-SD-NEXT:    ldp x20, x19, [sp, #16] ; 16-byte Folded Reload
+; CHECK-SD-NEXT:    add sp, sp, #48
 ; CHECK-SD-NEXT:    b _objc_release
 ; CHECK-SD-NEXT:  LBB3_2: ; %lpad
 ; CHECK-SD-NEXT:  Ltmp2: ; EH_LABEL
-; CHECK-SD-NEXT:    mov x20, x0
+; CHECK-SD-NEXT:    str x0, [sp, #8] ; 8-byte Spill
 ; CHECK-SD-NEXT:    mov x0, x19
 ; CHECK-SD-NEXT:    bl _objc_release
-; CHECK-SD-NEXT:    mov x0, x20
+; CHECK-SD-NEXT:    ldr x0, [sp, #8] ; 8-byte Reload
 ; CHECK-SD-NEXT:    bl __Unwind_Resume
 ; CHECK-SD-NEXT:  Lfunc_end0:
 ; CHECK-SD-NEXT:    .cfi_endproc
@@ -147,9 +149,10 @@ define dso_local void @rv_marker_3() personality ptr @__gxx_personality_v0 {
 ; CHECK-GI-NEXT:    .cfi_personality 155, ___gxx_personality_v0
 ; CHECK-GI-NEXT:    .cfi_lsda 16, Lexception0
 ; CHECK-GI-NEXT:  ; %bb.0: ; %entry
-; CHECK-GI-NEXT:    stp x20, x19, [sp, #-32]! ; 16-byte Folded Spill
-; CHECK-GI-NEXT:    stp x29, x30, [sp, #16] ; 16-byte Folded Spill
-; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-GI-NEXT:    sub sp, sp, #48
+; CHECK-GI-NEXT:    stp x20, x19, [sp, #16] ; 16-byte Folded Spill
+; CHECK-GI-NEXT:    stp x29, x30, [sp, #32] ; 16-byte Folded Spill
+; CHECK-GI-NEXT:    .cfi_def_cfa_offset 48
 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
 ; CHECK-GI-NEXT:    .cfi_offset w29, -16
 ; CHECK-GI-NEXT:    .cfi_offset w19, -24
@@ -167,19 +170,20 @@ define dso_local void @rv_marker_3() personality ptr @__gxx_personality_v0 {
 ; CHECK-GI-NEXT:    mov x0, x19
 ; CHECK-GI-NEXT:  Lloh1:
 ; CHECK-GI-NEXT:    ldr x1, [x1, _objc_release at GOTPAGEOFF]
-; CHECK-GI-NEXT:    ldp x29, x30, [sp, #16] ; 16-byte Folded Reload
-; CHECK-GI-NEXT:    ldp x20, x19, [sp], #32 ; 16-byte Folded Reload
+; CHECK-GI-NEXT:    ldp x29, x30, [sp, #32] ; 16-byte Folded Reload
+; CHECK-GI-NEXT:    ldp x20, x19, [sp, #16] ; 16-byte Folded Reload
+; CHECK-GI-NEXT:    add sp, sp, #48
 ; CHECK-GI-NEXT:    br x1
 ; CHECK-GI-NEXT:  LBB3_2: ; %lpad
 ; CHECK-GI-NEXT:  Ltmp2: ; EH_LABEL
 ; CHECK-GI-NEXT:  Lloh2:
 ; CHECK-GI-NEXT:    adrp x8, _objc_release at GOTPAGE
-; CHECK-GI-NEXT:    mov x20, x0
-; CHECK-GI-NEXT:    mov x0, x19
 ; CHECK-GI-NEXT:  Lloh3:
 ; CHECK-GI-NEXT:    ldr x8, [x8, _objc_release at GOTPAGEOFF]
+; CHECK-GI-NEXT:    str x0, [sp, #8] ; 8-byte Spill
+; CHECK-GI-NEXT:    mov x0, x19
 ; CHECK-GI-NEXT:    blr x8
-; CHECK-GI-NEXT:    mov x0, x20
+; CHECK-GI-NEXT:    ldr x0, [sp, #8] ; 8-byte Reload
 ; CHECK-GI-NEXT:    bl __Unwind_Resume
 ; CHECK-GI-NEXT:    .loh AdrpLdrGot Lloh0, Lloh1
 ; CHECK-GI-NEXT:    .loh AdrpLdrGot Lloh2, Lloh3
@@ -260,18 +264,17 @@ define dso_local void @rv_marker_4() personality ptr @__gxx_personality_v0 {
 ; CHECK-SD-NEXT:    ret
 ; CHECK-SD-NEXT:  LBB4_3: ; %lpad1
 ; CHECK-SD-NEXT:  Ltmp8: ; EH_LABEL
-; CHECK-SD-NEXT:    mov x1, x19
-; CHECK-SD-NEXT:    mov x19, x0
-; CHECK-SD-NEXT:    mov x0, x1
+; CHECK-SD-NEXT:    str x0, [sp] ; 8-byte Spill
+; CHECK-SD-NEXT:    mov x0, x19
 ; CHECK-SD-NEXT:    bl _objc_release
 ; CHECK-SD-NEXT:    b LBB4_5
 ; CHECK-SD-NEXT:  LBB4_4: ; %lpad
 ; CHECK-SD-NEXT:  Ltmp5: ; EH_LABEL
-; CHECK-SD-NEXT:    mov x19, x0
+; CHECK-SD-NEXT:    str x0, [sp] ; 8-byte Spill
 ; CHECK-SD-NEXT:  LBB4_5: ; %ehcleanup
 ; CHECK-SD-NEXT:    add x0, sp, #15
 ; CHECK-SD-NEXT:    bl __ZN1SD1Ev
-; CHECK-SD-NEXT:    mov x0, x19
+; CHECK-SD-NEXT:    ldr x0, [sp] ; 8-byte Reload
 ; CHECK-SD-NEXT:    bl __Unwind_Resume
 ; CHECK-SD-NEXT:  Lfunc_end1:
 ; CHECK-SD-NEXT:    .cfi_endproc
@@ -340,19 +343,19 @@ define dso_local void @rv_marker_4() personality ptr @__gxx_personality_v0 {
 ; CHECK-GI-NEXT:  Ltmp8: ; EH_LABEL
 ; CHECK-GI-NEXT:  Lloh6:
 ; CHECK-GI-NEXT:    adrp x8, _objc_release at GOTPAGE
-; CHECK-GI-NEXT:    mov x20, x0
-; CHECK-GI-NEXT:    mov x0, x19
 ; CHECK-GI-NEXT:  Lloh7:
 ; CHECK-GI-NEXT:    ldr x8, [x8, _objc_release at GOTPAGEOFF]
+; CHECK-GI-NEXT:    str x0, [sp] ; 8-byte Spill
+; CHECK-GI-NEXT:    mov x0, x19
 ; CHECK-GI-NEXT:    blr x8
 ; CHECK-GI-NEXT:    b LBB4_5
 ; CHECK-GI-NEXT:  LBB4_4: ; %lpad
 ; CHECK-GI-NEXT:  Ltmp5: ; EH_LABEL
-; CHECK-GI-NEXT:    mov x20, x0
+; CHECK-GI-NEXT:    str x0, [sp] ; 8-byte Spill
 ; CHECK-GI-NEXT:  LBB4_5: ; %ehcleanup
 ; CHECK-GI-NEXT:    add x0, sp, #15
 ; CHECK-GI-NEXT:    bl __ZN1SD1Ev
-; CHECK-GI-NEXT:    mov x0, x20
+; CHECK-GI-NEXT:    ldr x0, [sp] ; 8-byte Reload
 ; CHECK-GI-NEXT:    bl __Unwind_Resume
 ; CHECK-GI-NEXT:    .loh AdrpLdrGot Lloh4, Lloh5
 ; CHECK-GI-NEXT:    .loh AdrpLdrGot Lloh6, Lloh7
diff --git a/llvm/test/CodeGen/AArch64/sme-za-exceptions.ll b/llvm/test/CodeGen/AArch64/sme-za-exceptions.ll
index c353a3e6496a8..a48c3e5e9b5c2 100644
--- a/llvm/test/CodeGen/AArch64/sme-za-exceptions.ll
+++ b/llvm/test/CodeGen/AArch64/sme-za-exceptions.ll
@@ -29,14 +29,12 @@ define void @za_with_raii(i1 %fail) "aarch64_inout_za" personality ptr @__gxx_pe
 ; CHECK-NEXT:    .cfi_personality 156, DW.ref.__gxx_personality_v0
 ; CHECK-NEXT:    .cfi_lsda 28, .Lexception0
 ; CHECK-NEXT:  // %bb.0:
-; CHECK-NEXT:    stp x29, x30, [sp, #-32]! // 16-byte Folded Spill
-; CHECK-NEXT:    str x19, [sp, #16] // 8-byte Spill
+; CHECK-NEXT:    stp x29, x30, [sp, #-16]! // 16-byte Folded Spill
 ; CHECK-NEXT:    mov x29, sp
-; CHECK-NEXT:    sub sp, sp, #16
-; CHECK-NEXT:    .cfi_def_cfa w29, 32
-; CHECK-NEXT:    .cfi_offset w19, -16
-; CHECK-NEXT:    .cfi_offset w30, -24
-; CHECK-NEXT:    .cfi_offset w29, -32
+; CHECK-NEXT:    sub sp, sp, #32
+; CHECK-NEXT:    .cfi_def_cfa w29, 16
+; CHECK-NEXT:    .cfi_offset w30, -8
+; CHECK-NEXT:    .cfi_offset w29, -16
 ; CHECK-NEXT:    rdsvl x8, #1
 ; CHECK-NEXT:    mov x9, sp
 ; CHECK-NEXT:    msub x9, x8, x8, x9
@@ -45,8 +43,7 @@ define void @za_with_raii(i1 %fail) "aarch64_inout_za" personality ptr @__gxx_pe
 ; CHECK-NEXT:    tbnz w0, #0, .LBB0_2
 ; CHECK-NEXT:  // %bb.1: // %return_normally
 ; CHECK-NEXT:    mov sp, x29
-; CHECK-NEXT:    ldr x19, [sp, #16] // 8-byte Reload
-; CHECK-NEXT:    ldp x29, x30, [sp], #32 // 16-byte Folded Reload
+; CHECK-NEXT:    ldp x29, x30, [sp], #16 // 16-byte Folded Reload
 ; CHECK-NEXT:    b shared_za_call
 ; CHECK-NEXT:  .LBB0_2: // %throw_exception
 ; CHECK-NEXT:    sub x8, x29, #16
@@ -73,7 +70,7 @@ define void @za_with_raii(i1 %fail) "aarch64_inout_za" personality ptr @__gxx_pe
 ; CHECK-NEXT:  // %bb.5: // %throw_fail
 ; CHECK-NEXT:  .LBB0_6: // %unwind_dtors
 ; CHECK-NEXT:  .Ltmp2: // EH_LABEL
-; CHECK-NEXT:    mov x19, x0
+; CHECK-NEXT:    stur x0, [x29, #-24] // 8-byte Folded Spill
 ; CHECK-NEXT:    smstart za
 ; CHECK-NEXT:    mrs x8, TPIDR2_EL0
 ; CHECK-NEXT:    sub x0, x29, #16
@@ -84,8 +81,8 @@ define void @za_with_raii(i1 %fail) "aarch64_inout_za" personality ptr @__gxx_pe
 ; CHECK-NEXT:    msr TPIDR2_EL0, xzr
 ; CHECK-NEXT:    bl shared_za_call
 ; CHECK-NEXT:    sub x8, x29, #16
-; CHECK-NEXT:    mov x0, x19
 ; CHECK-NEXT:    msr TPIDR2_EL0, x8
+; CHECK-NEXT:    ldur x0, [x29, #-24] // 8-byte Folded Reload
 ; CHECK-NEXT:    bl _Unwind_Resume
   br i1 %fail, label %throw_exception, label %return_normally
 
@@ -306,13 +303,13 @@ define void @try_catch_shared_zt0_callee() "aarch64_inout_zt0" personality ptr @
 ; CHECK-NEXT:    .cfi_personality 156, DW.ref.__gxx_personality_v0
 ; CHECK-NEXT:    .cfi_lsda 28, .Lexception3
 ; CHECK-NEXT:  // %bb.0:
-; CHECK-NEXT:    sub sp, sp, #80
-; CHECK-NEXT:    stp x30, x19, [sp, #64] // 16-byte Folded Spill
-; CHECK-NEXT:    .cfi_def_cfa_offset 80
+; CHECK-NEXT:    sub sp, sp, #96
+; CHECK-NEXT:    stp x30, x19, [sp, #80] // 16-byte Folded Spill
+; CHECK-NEXT:    .cfi_def_cfa_offset 96
 ; CHECK-NEXT:    .cfi_offset w19, -8
 ; CHECK-NEXT:    .cfi_offset w30, -16
 ; CHECK-NEXT:  .Ltmp9: // EH_LABEL
-; CHECK-NEXT:    mov x19, sp
+; CHECK-NEXT:    add x19, sp, #16
 ; CHECK-NEXT:    str zt0, [x19]
 ; CHECK-NEXT:    smstop za
 ; CHECK-NEXT:    bl may_throw
@@ -320,20 +317,18 @@ define void @try_catch_shared_zt0_callee() "aarch64_inout_zt0" personality ptr @
 ; CHECK-NEXT:    smstart za
 ; CHECK-NEXT:    ldr zt0, [x19]
 ; CHECK-NEXT:  // %bb.1: // %return_normally
-; CHECK-NEXT:    ldp x30, x19, [sp, #64] // 16-byte Folded Reload
-; CHECK-NEXT:    add sp, sp, #80
+; CHECK-NEXT:    ldp x30, x19, [sp, #80] // 16-byte Folded Reload
+; CHECK-NEXT:    add sp, sp, #96
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .LBB3_2: // %unwind_dtors
 ; CHECK-NEXT:  .Ltmp11: // EH...
[truncated]

``````````

</details>


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


More information about the llvm-branch-commits mailing list