Skip to content

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

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Merged
merged 1 commit into from
Mar 25, 2025
Merged

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

merged 1 commit into from
Mar 25, 2025

Conversation

dominik-steenken
Copy link
Contributor

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 MachineInstrs 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.

@llvmbot
Copy link
Member

llvmbot commented Mar 25, 2025

@llvm/pr-subscribers-backend-systemz

Author: Dominik Steenken (dominik-steenken)

Changes

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 MachineInstrs 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 --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@GOT
 ; CHECK-NEXT:    lgrl %r2, s@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@GOT
 ; CHECK-NEXT:    lgrl %r3, q@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@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@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@GOT
 ; CHECK-NEXT:    lgrl %r3, m@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@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@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@GOT
 ; CHECK-NEXT:    lgrl %r3, i@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@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@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@GOT
 ; CHECK-NEXT:    lgrl %r3, e@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@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@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@GOT
 ; CHECK-NEXT:    lgrl %r4, a@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@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]

@github-actions GitHub Actions
Copy link

github-actions bot commented Mar 25, 2025 •
edited
Loading

✅ With the latest revision this PR passed the C/C++ code formatter.

@dsteenken @dominik-steenken
[SystemZ] Add is[LoadFrom|StoreTo]StackSlotPostFE to SystemZBackend
0ea6058 
As part of an effort to enable instr-ref-based debug value tracking,
this commit 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 commit.
@dominik-steenken dominik-steenken force-pushed the systemz-stackslot-postfe branch from 78bdca9 to 0ea6058 Compare March 25, 2025 12:56
uweigand
uweigand approved these changes Mar 25, 2025
View reviewed changes
Copy link
Member

@uweigand uweigand left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM, thanks!

@uweigand uweigand merged commit f24cf59 into llvm:main Mar 25, 2025
11 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers

@uweigand uweigand uweigand approved these changes

Assignees
No one assigned
Labels
backend:SystemZ
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
4 participants
@dominik-steenken @llvmbot @uweigand @dsteenken