[llvm] [SystemZ] Add `is(LoadFrom|StoreTo)StackSlotPostFE` to SystemZBackend (PR #132928)

via llvm-commits llvm-commits at lists.llvm.org
Tue Mar 25 05:51:20 PDT 2025


llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-systemz

Author: Dominik Steenken (dominik-steenken)

<details>
<summary>Changes</summary>

As part of an effort to enable instr-ref-based debug value tracking, this PR  implements `SystemZInstrInfo::isLoadFromStackSlotPostFE`, as well as `SystemZInstrInfo::isStoreToStackSlotPostFE`. The implementation relies upon the presence of MachineMemoryOperands on the relevant `MachineInstr`s in order to access the `FrameIndex` post frame index elimination.

Since these new functions are only meant to be called after frame-index elimination, they assert against the present of a frame index on the base register operand of the instruction.

Outside of the utility of these functions to enable instr-ref-based debug value tracking, they also changes the behavior of the AsmPrinter, since it will now be able to properly detect non-folded spills and reloads, so this changes a number of tests that were checking specifically for folded reloads.

Note that there are some tests that still check for `vst` and `vl` as folded spills/reloads even though they should be straight reloads. This will be addressed in a future PR.

---

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


16 Files Affected:

- (modified) llvm/lib/Target/SystemZ/SystemZInstrInfo.cpp (+46) 
- (modified) llvm/lib/Target/SystemZ/SystemZInstrInfo.h (+4) 
- (modified) llvm/test/CodeGen/SystemZ/builtin-setjmp-alloca.ll (+32-32) 
- (modified) llvm/test/CodeGen/SystemZ/builtin-setjmp-spills.ll (+56-56) 
- (modified) llvm/test/CodeGen/SystemZ/builtin-setjmp.ll (+32-32) 
- (modified) llvm/test/CodeGen/SystemZ/fmuladd-soft-float.ll (+7-7) 
- (modified) llvm/test/CodeGen/SystemZ/foldmemop-imm-02.mir (+2-2) 
- (modified) llvm/test/CodeGen/SystemZ/foldmemop-vec-cc.mir (+1-1) 
- (modified) llvm/test/CodeGen/SystemZ/foldmemop-vec-cmp.mir (+4-4) 
- (modified) llvm/test/CodeGen/SystemZ/foldmemop-vec-unary.mir (+4-4) 
- (modified) llvm/test/CodeGen/SystemZ/fp-move-02.ll (+51-51) 
- (modified) llvm/test/CodeGen/SystemZ/frame-22.ll (+10-10) 
- (modified) llvm/test/CodeGen/SystemZ/int-uadd-03.ll (+2-2) 
- (modified) llvm/test/CodeGen/SystemZ/int-usub-03.ll (+2-2) 
- (modified) llvm/test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll (+426-426) 
- (modified) llvm/test/CodeGen/SystemZ/zos-prologue-epilog.ll (+16-16) 


``````````diff
diff --git a/llvm/lib/Target/SystemZ/SystemZInstrInfo.cpp b/llvm/lib/Target/SystemZ/SystemZInstrInfo.cpp
index ab2e5b3c9a190..303e902bf108a 100644
--- a/llvm/lib/Target/SystemZ/SystemZInstrInfo.cpp
+++ b/llvm/lib/Target/SystemZ/SystemZInstrInfo.cpp
@@ -346,6 +346,52 @@ Register SystemZInstrInfo::isStoreToStackSlot(const MachineInstr &MI,
   return isSimpleMove(MI, FrameIndex, SystemZII::SimpleBDXStore);
 }
 
+Register SystemZInstrInfo::isLoadFromStackSlotPostFE(const MachineInstr &MI,
+                                                     int &FrameIndex) const {
+  // if this is not a simple load from memory, it's not a load from stack slot
+  // either.
+  const MCInstrDesc &MCID = MI.getDesc();
+  if (!(MCID.TSFlags & SystemZII::SimpleBDXLoad))
+    return 0;
+
+  // This version of isLoadFromStackSlot should only be used post frame-index
+  // elimination.
+  assert(!MI.getOperand(1).isFI());
+
+  // Now attempt to derive frame index from MachineMemOperands.
+  SmallVector<const MachineMemOperand *, 1> Accesses;
+  if (hasLoadFromStackSlot(MI, Accesses)) {
+    FrameIndex =
+        cast<FixedStackPseudoSourceValue>(Accesses.front()->getPseudoValue())
+            ->getFrameIndex();
+    return MI.getOperand(0).getReg();
+  }
+  return 0;
+}
+
+Register SystemZInstrInfo::isStoreToStackSlotPostFE(const MachineInstr &MI,
+                                                    int &FrameIndex) const {
+  // if this is not a simple store to memory, it's not a store to stack slot
+  // either.
+  const MCInstrDesc &MCID = MI.getDesc();
+  if (!(MCID.TSFlags & SystemZII::SimpleBDXStore))
+    return 0;
+
+  // This version of isStoreToStackSlot should only be used post frame-index
+  // elimination.
+  assert(!MI.getOperand(1).isFI());
+
+  // Now attempt to derive frame index from MachineMemOperands.
+  SmallVector<const MachineMemOperand *, 1> Accesses;
+  if (hasStoreToStackSlot(MI, Accesses)) {
+    FrameIndex =
+        cast<FixedStackPseudoSourceValue>(Accesses.front()->getPseudoValue())
+            ->getFrameIndex();
+    return MI.getOperand(0).getReg();
+  }
+  return 0;
+}
+
 bool SystemZInstrInfo::isStackSlotCopy(const MachineInstr &MI,
                                        int &DestFrameIndex,
                                        int &SrcFrameIndex) const {
diff --git a/llvm/lib/Target/SystemZ/SystemZInstrInfo.h b/llvm/lib/Target/SystemZ/SystemZInstrInfo.h
index 5f09ad508905d..510442055362a 100644
--- a/llvm/lib/Target/SystemZ/SystemZInstrInfo.h
+++ b/llvm/lib/Target/SystemZ/SystemZInstrInfo.h
@@ -232,6 +232,10 @@ class SystemZInstrInfo : public SystemZGenInstrInfo {
                                int &FrameIndex) const override;
   Register isStoreToStackSlot(const MachineInstr &MI,
                               int &FrameIndex) const override;
+  Register isLoadFromStackSlotPostFE(const MachineInstr &MI,
+                              int &FrameIndex) const override;
+  Register isStoreToStackSlotPostFE(const MachineInstr &MI,
+                              int &FrameIndex) const override;
   bool isStackSlotCopy(const MachineInstr &MI, int &DestFrameIndex,
                        int &SrcFrameIndex) const override;
   bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
diff --git a/llvm/test/CodeGen/SystemZ/builtin-setjmp-alloca.ll b/llvm/test/CodeGen/SystemZ/builtin-setjmp-alloca.ll
index f714599f9a8f2..9bd6ff8eea4c5 100644
--- a/llvm/test/CodeGen/SystemZ/builtin-setjmp-alloca.ll
+++ b/llvm/test/CodeGen/SystemZ/builtin-setjmp-alloca.ll
@@ -30,14 +30,14 @@ define signext i32 @foo() "frame-pointer"="all" {
 ; CHECK-NEXT:    .cfi_def_cfa_offset 400
 ; CHECK-NEXT:    lgr %r11, %r15
 ; CHECK-NEXT:    .cfi_def_cfa_register %r11
-; CHECK-NEXT:    std %f8, 232(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f9, 224(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f10, 216(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f11, 208(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f12, 200(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f13, 192(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f14, 184(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f15, 176(%r11) # 8-byte Folded Spill
+; CHECK-NEXT:    std %f8, 232(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f9, 224(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f10, 216(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f11, 208(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f12, 200(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f13, 192(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f14, 184(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f15, 176(%r11) # 8-byte Spill
 ; CHECK-NEXT:    .cfi_offset %f8, -168
 ; CHECK-NEXT:    .cfi_offset %f9, -176
 ; CHECK-NEXT:    .cfi_offset %f10, -184
@@ -59,14 +59,14 @@ define signext i32 @foo() "frame-pointer"="all" {
 ; CHECK-NEXT:  .LBB0_2: # %entry
 ; CHECK-NEXT:    lg %r1, 168(%r11)
 ; CHECK-NEXT:    lgf %r2, 0(%r1)
-; CHECK-NEXT:    ld %f8, 232(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f9, 224(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f10, 216(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f11, 208(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f12, 200(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f13, 192(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f14, 184(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f15, 176(%r11) # 8-byte Folded Reload
+; CHECK-NEXT:    ld %f8, 232(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f9, 224(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f10, 216(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f11, 208(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f12, 200(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f13, 192(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f14, 184(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f15, 176(%r11) # 8-byte Reload
 ; CHECK-NEXT:    lmg %r6, %r15, 288(%r11)
 ; CHECK-NEXT:    br %r14
 entry:
@@ -101,14 +101,14 @@ define signext i32 @foo1() "backchain" "frame-pointer"="all" {
 ; CHECK-NEXT:    stg %r1, 0(%r15)
 ; CHECK-NEXT:    lgr %r11, %r15
 ; CHECK-NEXT:    .cfi_def_cfa_register %r11
-; CHECK-NEXT:    std %f8, 232(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f9, 224(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f10, 216(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f11, 208(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f12, 200(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f13, 192(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f14, 184(%r11) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f15, 176(%r11) # 8-byte Folded Spill
+; CHECK-NEXT:    std %f8, 232(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f9, 224(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f10, 216(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f11, 208(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f12, 200(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f13, 192(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f14, 184(%r11) # 8-byte Spill
+; CHECK-NEXT:    std %f15, 176(%r11) # 8-byte Spill
 ; CHECK-NEXT:    .cfi_offset %f8, -168
 ; CHECK-NEXT:    .cfi_offset %f9, -176
 ; CHECK-NEXT:    .cfi_offset %f10, -184
@@ -132,14 +132,14 @@ define signext i32 @foo1() "backchain" "frame-pointer"="all" {
 ; CHECK-NEXT:  .LBB1_2: # %entry
 ; CHECK-NEXT:    lg %r1, 168(%r11)
 ; CHECK-NEXT:    lgf %r2, 0(%r1)
-; CHECK-NEXT:    ld %f8, 232(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f9, 224(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f10, 216(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f11, 208(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f12, 200(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f13, 192(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f14, 184(%r11) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f15, 176(%r11) # 8-byte Folded Reload
+; CHECK-NEXT:    ld %f8, 232(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f9, 224(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f10, 216(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f11, 208(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f12, 200(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f13, 192(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f14, 184(%r11) # 8-byte Reload
+; CHECK-NEXT:    ld %f15, 176(%r11) # 8-byte Reload
 ; CHECK-NEXT:    lmg %r6, %r15, 288(%r11)
 ; CHECK-NEXT:    br %r14
 entry:
diff --git a/llvm/test/CodeGen/SystemZ/builtin-setjmp-spills.ll b/llvm/test/CodeGen/SystemZ/builtin-setjmp-spills.ll
index 65657ec9f1826..5626f45ac8bbb 100644
--- a/llvm/test/CodeGen/SystemZ/builtin-setjmp-spills.ll
+++ b/llvm/test/CodeGen/SystemZ/builtin-setjmp-spills.ll
@@ -49,14 +49,14 @@ define signext i32 @func() {
 ; CHECK-NEXT:    .cfi_offset %r15, -40
 ; CHECK-NEXT:    aghi %r15, -384
 ; CHECK-NEXT:    .cfi_def_cfa_offset 544
-; CHECK-NEXT:    std %f8, 376(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f9, 368(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f10, 360(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f11, 352(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f12, 344(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f13, 336(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f14, 328(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f15, 320(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    std %f8, 376(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f9, 368(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f10, 360(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f11, 352(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f12, 344(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f13, 336(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f14, 328(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f15, 320(%r15) # 8-byte Spill
 ; CHECK-NEXT:    .cfi_offset %f8, -168
 ; CHECK-NEXT:    .cfi_offset %f9, -176
 ; CHECK-NEXT:    .cfi_offset %f10, -184
@@ -67,64 +67,64 @@ define signext i32 @func() {
 ; CHECK-NEXT:    .cfi_offset %f15, -224
 ; CHECK-NEXT:    lgrl %r1, t at GOT
 ; CHECK-NEXT:    lgrl %r2, s at GOT
-; CHECK-NEXT:    stg %r1, 312(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r1, 312(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r1), 1
 ; CHECK-NEXT:    lgrl %r1, r at GOT
 ; CHECK-NEXT:    lgrl %r3, q at GOT
-; CHECK-NEXT:    stg %r2, 304(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r2, 304(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r2), 1
 ; CHECK-NEXT:    lgrl %r2, p at GOT
-; CHECK-NEXT:    stg %r1, 296(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r1, 296(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r1), 1
-; CHECK-NEXT:    stg %r3, 288(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r3, 288(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r3), 1
 ; CHECK-NEXT:    lgrl %r1, o at GOT
-; CHECK-NEXT:    stg %r2, 280(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r2, 280(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r2), 1
 ; CHECK-NEXT:    lgrl %r2, n at GOT
 ; CHECK-NEXT:    lgrl %r3, m at GOT
-; CHECK-NEXT:    stg %r1, 272(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r1, 272(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r1), 1
 ; CHECK-NEXT:    lgrl %r1, l at GOT
-; CHECK-NEXT:    stg %r2, 264(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r2, 264(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r2), 1
-; CHECK-NEXT:    stg %r3, 256(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r3, 256(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r3), 1
 ; CHECK-NEXT:    lgrl %r2, k at GOT
-; CHECK-NEXT:    stg %r1, 248(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r1, 248(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r1), 1
 ; CHECK-NEXT:    lgrl %r1, j at GOT
 ; CHECK-NEXT:    lgrl %r3, i at GOT
-; CHECK-NEXT:    stg %r2, 240(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r2, 240(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r2), 1
 ; CHECK-NEXT:    lgrl %r2, h at GOT
-; CHECK-NEXT:    stg %r1, 232(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r1, 232(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r1), 1
-; CHECK-NEXT:    stg %r3, 224(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r3, 224(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r3), 1
 ; CHECK-NEXT:    lgrl %r1, g at GOT
-; CHECK-NEXT:    stg %r2, 216(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r2, 216(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r2), 1
 ; CHECK-NEXT:    lgrl %r2, f at GOT
 ; CHECK-NEXT:    lgrl %r3, e at GOT
-; CHECK-NEXT:    stg %r1, 208(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r1, 208(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r1), 1
 ; CHECK-NEXT:    lgrl %r1, d at GOT
-; CHECK-NEXT:    stg %r2, 200(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r2, 200(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r2), 1
-; CHECK-NEXT:    stg %r3, 192(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r3, 192(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r3), 1
 ; CHECK-NEXT:    lgrl %r2, c at GOT
-; CHECK-NEXT:    stg %r1, 184(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r1, 184(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r1), 1
 ; CHECK-NEXT:    lgrl %r3, b at GOT
 ; CHECK-NEXT:    lgrl %r4, a at GOT
-; CHECK-NEXT:    stg %r2, 176(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r2, 176(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r2), 1
 ; CHECK-NEXT:    lgrl %r1, buf at GOT
-; CHECK-NEXT:    stg %r3, 168(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r3, 168(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r3), 1
-; CHECK-NEXT:    stg %r4, 160(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    stg %r4, 160(%r15) # 8-byte Spill
 ; CHECK-NEXT:    mvhi 0(%r4), 1
 ; CHECK-NEXT:    larl %r0, .LBB0_2
 ; CHECK-NEXT:    stg %r0, 8(%r1)
@@ -136,55 +136,55 @@ define signext i32 @func() {
 ; CHECK-NEXT:    # %entry
 ; CHECK-NEXT:    lhi %r0, 1
 ; CHECK-NEXT:  .LBB0_3: # %entry
-; CHECK-NEXT:    lg %r1, 160(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 160(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 168(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 168(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 176(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 176(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 184(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 184(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 192(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 192(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 200(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 200(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 208(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 208(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 216(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 216(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 224(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 224(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 232(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 232(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 240(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 240(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 248(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 248(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 256(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 256(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 264(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 264(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 272(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 272(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 280(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 280(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 288(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 288(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 296(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 296(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 304(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 304(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
-; CHECK-NEXT:    lg %r1, 312(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    lg %r1, 312(%r15) # 8-byte Reload
 ; CHECK-NEXT:    a %r0, 0(%r1)
 ; CHECK-NEXT:    lgfr %r2, %r0
-; CHECK-NEXT:    ld %f8, 376(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f9, 368(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f10, 360(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f11, 352(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f12, 344(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f13, 336(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f14, 328(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f15, 320(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    ld %f8, 376(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f9, 368(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f10, 360(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f11, 352(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f12, 344(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f13, 336(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f14, 328(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f15, 320(%r15) # 8-byte Reload
 ; CHECK-NEXT:    lmg %r6, %r15, 432(%r15)
 ; CHECK-NEXT:    br %r14
 entry:
diff --git a/llvm/test/CodeGen/SystemZ/builtin-setjmp.ll b/llvm/test/CodeGen/SystemZ/builtin-setjmp.ll
index cfeba5a051ad1..37706c7bcd212 100644
--- a/llvm/test/CodeGen/SystemZ/builtin-setjmp.ll
+++ b/llvm/test/CodeGen/SystemZ/builtin-setjmp.ll
@@ -26,14 +26,14 @@ define void @foo() {
 ; CHECK-NEXT:    .cfi_offset %r15, -40
 ; CHECK-NEXT:    aghi %r15, -64
 ; CHECK-NEXT:    .cfi_def_cfa_offset 224
-; CHECK-NEXT:    std %f8, 56(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f9, 48(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f10, 40(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f11, 32(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f12, 24(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f13, 16(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f14, 8(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f15, 0(%r15) # 8-byte Folded Spill
+; CHECK-NEXT:    std %f8, 56(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f9, 48(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f10, 40(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f11, 32(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f12, 24(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f13, 16(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f14, 8(%r15) # 8-byte Spill
+; CHECK-NEXT:    std %f15, 0(%r15) # 8-byte Spill
 ; CHECK-NEXT:    .cfi_offset %f8, -168
 ; CHECK-NEXT:    .cfi_offset %f9, -176
 ; CHECK-NEXT:    .cfi_offset %f10, -184
@@ -49,14 +49,14 @@ define void @foo() {
 ; CHECK-NEXT:  .LBB0_1: # Block address taken
 ; CHECK-NEXT:    # %entry
 ; CHECK-NEXT:  .LBB0_2: # %entry
-; CHECK-NEXT:    ld %f8, 56(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f9, 48(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f10, 40(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f11, 32(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f12, 24(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f13, 16(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f14, 8(%r15) # 8-byte Folded Reload
-; CHECK-NEXT:    ld %f15, 0(%r15) # 8-byte Folded Reload
+; CHECK-NEXT:    ld %f8, 56(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f9, 48(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f10, 40(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f11, 32(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f12, 24(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f13, 16(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f14, 8(%r15) # 8-byte Reload
+; CHECK-NEXT:    ld %f15, 0(%r15) # 8-byte Reload
 ; CHECK-NEXT:    lmg %r6, %r15, 112(%r15)
 ; CHECK-NEXT:    br %r14
 entry:
@@ -82,14 +82,14 @@ define void @foo1() "backchain" {
 ; CHECK-NEXT:    aghi %r15, -64
 ; CHECK-NEXT:    .cfi_def_cfa_offset 224
 ; CHECK-NEXT:    stg %r1, 0(%r15)
-; CHECK-NEXT:    std %f8, 56(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f9, 48(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f10, 40(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f11, 32(%r15) # 8-byte Folded Spill
-; CHECK-NEXT:    std %f12, 24(%r15) # 8-byte Folded Spill
-; CHECK-...
[truncated]

``````````

</details>


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


More information about the llvm-commits mailing list