https://github.com/ritter-x2a updated 
https://github.com/llvm/llvm-project/pull/231855

>From d1107bdd858db810afbb9d3982030c835347e1ed Mon Sep 17 00:00:00 2001
From: Fabian Ritter <[email protected]>
Date: Wed, 14 Oct 2026 06:40:49 -0400
Subject: [PATCH 1/2] [AMDGPU] Preserve noclobber after acquire operations from
 a different addrspace

Follow-up to #219991 to address reviewer comments:
AMDGPUAnnotateUniformValues should annotate uniform global loads as
`!amdgpu.noclobber` if the memory they are reading is never clobbered (since
kernel launch) before the load is executed.
PR #219991 strengthened the logic to consider acquire operations before the
load as clobbering (because they cause stores from other threads to be observed
by the load without a data race).

This PR weakens this criterion to ignore acquire operations that don't affect
the global address space (because they don't affect what the load in question
may or may not see). This addresses the performance-relevant case of s_barriers
with LDS-only fences.

The logic is still overly pessimistic for one-as load acquires, they could also
be ignored when looking for clobbering operations.

Disclaimer: Claude gave review comments and suggestions that I addressed during
development.

For ROCM-29879.

Assisted-by: AI
---
 llvm/lib/Target/AMDGPU/AMDGPUMemoryUtils.cpp  | 14 +++++++--
 llvm/test/CodeGen/AMDGPU/noclobber-barrier.ll | 29 ++++++++++---------
 2 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMemoryUtils.cpp 
b/llvm/lib/Target/AMDGPU/AMDGPUMemoryUtils.cpp
index a944d7ced34b6..074608c29b7ab 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMemoryUtils.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMemoryUtils.cpp
@@ -414,8 +414,17 @@ bool isReallyAClobber(const Value *Ptr, MemoryDef *Def, 
AAResults *AA) {
     return !AA->isNoAlias(I->getPointerOperand(), Ptr);
   };
 
-  if (const auto *F = dyn_cast<FenceInst>(DefInst))
-    return isAcquireOrStronger(F->getOrdering());
+  if (const auto *F = dyn_cast<FenceInst>(DefInst)) {
+    if (!isAcquireOrStronger(F->getOrdering()))
+      return false;
+    SIAtomicAddrSpace AccessedAS =
+        toSIAtomicAddrSpace(Ptr->getType()->getPointerAddressSpace());
+    std::optional<SIAtomicAddrSpace> SynchronizedAS =
+        getSynchronizeAddrSpace(*F);
+    // If SynchronizedAS is std::nullopt, it refers to all address spaces.
+    return !SynchronizedAS ||
+           (*SynchronizedAS & AccessedAS) != SIAtomicAddrSpace::NONE;
+  }
 
   if (const auto *I = dyn_cast<AtomicRMWInst>(DefInst))
     return isAcquireOrStronger(I->getOrdering()) || MayAlias(I);
@@ -423,6 +432,7 @@ bool isReallyAClobber(const Value *Ptr, MemoryDef *Def, 
AAResults *AA) {
   if (const auto *I = dyn_cast<AtomicCmpXchgInst>(DefInst))
     return isAcquireOrStronger(I->getMergedOrdering()) || MayAlias(I);
 
+  // TODO This is pessimistic for one-as load-acquires from a different AS.
   if (const auto *I = dyn_cast<LoadInst>(DefInst))
     return isAcquireOrStronger(I->getOrdering());
 
diff --git a/llvm/test/CodeGen/AMDGPU/noclobber-barrier.ll 
b/llvm/test/CodeGen/AMDGPU/noclobber-barrier.ll
index 414f825bc4310..72ca439fddf88 100644
--- a/llvm/test/CodeGen/AMDGPU/noclobber-barrier.ll
+++ b/llvm/test/CodeGen/AMDGPU/noclobber-barrier.ll
@@ -1381,7 +1381,7 @@ define amdgpu_kernel void 
@fence_acquire_one_as_different(ptr addrspace(1) noali
 ; CHECK-SAME: ptr addrspace(1) noalias [[OUT:%.*]], ptr addrspace(1) 
[[P1:%.*]], ptr addrspace(3) [[P3:%.*]]) {
 ; CHECK-NEXT:    [[ACQ:%.*]] = load atomic i32, ptr addrspace(3) [[P3]] 
monotonic, align 4
 ; CHECK-NEXT:    fence syncscope("workgroup-one-as") acquire, !mmra 
[[META2:![0-9]+]]
-; CHECK-NEXT:    [[LD:%.*]] = load i32, ptr addrspace(1) [[P1]], align 4
+; CHECK-NEXT:    [[LD:%.*]] = load i32, ptr addrspace(1) [[P1]], align 4, 
!amdgpu.noclobber [[META0]]
 ; CHECK-NEXT:    store atomic i32 [[LD]], ptr addrspace(1) [[OUT]] seq_cst, 
align 4
 ; CHECK-NEXT:    ret void
 ;
@@ -1394,8 +1394,9 @@ define amdgpu_kernel void 
@fence_acquire_one_as_different(ptr addrspace(1) noali
 ; GCN-NEXT:    s_load_dwordx4 s[0:3], s[4:5], 0x24
 ; GCN-NEXT:    s_waitcnt lgkmcnt(0)
 ; GCN-NEXT:    v_mov_b32_e32 v0, 0
-; GCN-NEXT:    global_load_dword v1, v0, s[2:3]
-; GCN-NEXT:    s_waitcnt vmcnt(0)
+; GCN-NEXT:    s_load_dword s2, s[2:3], 0x0
+; GCN-NEXT:    s_waitcnt lgkmcnt(0)
+; GCN-NEXT:    v_mov_b32_e32 v1, s2
 ; GCN-NEXT:    global_store_dword v0, v1, s[0:1]
 ; GCN-NEXT:    s_endpgm
   %acq = load atomic i32, ptr addrspace(3) %p3 monotonic, align 4
@@ -1410,7 +1411,7 @@ define amdgpu_kernel void 
@fence_acquire_mmra_different(ptr addrspace(1) noalias
 ; CHECK-SAME: ptr addrspace(1) noalias [[OUT:%.*]], ptr addrspace(1) 
[[P1:%.*]], ptr addrspace(3) [[P3:%.*]]) {
 ; CHECK-NEXT:    [[ACQ:%.*]] = load atomic i32, ptr addrspace(3) [[P3]] 
monotonic, align 4
 ; CHECK-NEXT:    fence syncscope("workgroup") acquire, !mmra [[META2]]
-; CHECK-NEXT:    [[LD:%.*]] = load i32, ptr addrspace(1) [[P1]], align 4
+; CHECK-NEXT:    [[LD:%.*]] = load i32, ptr addrspace(1) [[P1]], align 4, 
!amdgpu.noclobber [[META0]]
 ; CHECK-NEXT:    store atomic i32 [[LD]], ptr addrspace(1) [[OUT]] seq_cst, 
align 4
 ; CHECK-NEXT:    ret void
 ;
@@ -1418,13 +1419,14 @@ define amdgpu_kernel void 
@fence_acquire_mmra_different(ptr addrspace(1) noalias
 ; GCN:       ; %bb.0:
 ; GCN-NEXT:    s_load_dword s6, s[4:5], 0x34
 ; GCN-NEXT:    s_load_dwordx4 s[0:3], s[4:5], 0x24
-; GCN-NEXT:    v_mov_b32_e32 v0, 0
 ; GCN-NEXT:    s_waitcnt lgkmcnt(0)
-; GCN-NEXT:    v_mov_b32_e32 v1, s6
-; GCN-NEXT:    ds_read_b32 v1, v1
+; GCN-NEXT:    v_mov_b32_e32 v0, s6
+; GCN-NEXT:    ds_read_b32 v0, v0
 ; GCN-NEXT:    s_waitcnt lgkmcnt(0)
-; GCN-NEXT:    global_load_dword v1, v0, s[2:3]
-; GCN-NEXT:    s_waitcnt vmcnt(0)
+; GCN-NEXT:    s_load_dword s2, s[2:3], 0x0
+; GCN-NEXT:    v_mov_b32_e32 v0, 0
+; GCN-NEXT:    s_waitcnt lgkmcnt(0)
+; GCN-NEXT:    v_mov_b32_e32 v1, s2
 ; GCN-NEXT:    global_store_dword v0, v1, s[0:1]
 ; GCN-NEXT:    s_endpgm
   %acq = load atomic i32, ptr addrspace(3) %p3 monotonic, align 4
@@ -1440,18 +1442,19 @@ define amdgpu_kernel void @local_barrier(ptr 
addrspace(1) noalias %out, ptr addr
 ; CHECK-NEXT:    fence syncscope("workgroup") release, !mmra [[META2]]
 ; CHECK-NEXT:    tail call void @llvm.amdgcn.s.barrier()
 ; CHECK-NEXT:    fence syncscope("workgroup") acquire, !mmra [[META2]]
-; CHECK-NEXT:    [[LD:%.*]] = load i32, ptr addrspace(1) [[P1]], align 4
+; CHECK-NEXT:    [[LD:%.*]] = load i32, ptr addrspace(1) [[P1]], align 4, 
!amdgpu.noclobber [[META0]]
 ; CHECK-NEXT:    store atomic i32 [[LD]], ptr addrspace(1) [[OUT]] seq_cst, 
align 4
 ; CHECK-NEXT:    ret void
 ;
 ; GCN-LABEL: local_barrier:
 ; GCN:       ; %bb.0:
 ; GCN-NEXT:    s_load_dwordx4 s[0:3], s[4:5], 0x24
-; GCN-NEXT:    v_mov_b32_e32 v0, 0
 ; GCN-NEXT:    s_waitcnt lgkmcnt(0)
 ; GCN-NEXT:    s_barrier
-; GCN-NEXT:    global_load_dword v1, v0, s[2:3]
-; GCN-NEXT:    s_waitcnt vmcnt(0)
+; GCN-NEXT:    v_mov_b32_e32 v0, 0
+; GCN-NEXT:    s_load_dword s2, s[2:3], 0x0
+; GCN-NEXT:    s_waitcnt lgkmcnt(0)
+; GCN-NEXT:    v_mov_b32_e32 v1, s2
 ; GCN-NEXT:    global_store_dword v0, v1, s[0:1]
 ; GCN-NEXT:    s_endpgm
   fence syncscope("workgroup") release, !mmra !{!"amdgpu-synchronize-as", 
!"local"}

>From 1b09ce866109c6ce0d5d1be1fd955eb3a4fafbd1 Mon Sep 17 00:00:00 2001
From: Fabian Ritter <[email protected]>
Date: Tue, 27 Oct 2026 07:08:39 -0400
Subject: [PATCH 2/2] Adjust to removed std::optional in
 getSynchronizeAddrSpace's return type.

---
 llvm/lib/Target/AMDGPU/AMDGPUMemoryUtils.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMemoryUtils.cpp 
b/llvm/lib/Target/AMDGPU/AMDGPUMemoryUtils.cpp
index 074608c29b7ab..c45a17bbbba22 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMemoryUtils.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMemoryUtils.cpp
@@ -419,11 +419,8 @@ bool isReallyAClobber(const Value *Ptr, MemoryDef *Def, 
AAResults *AA) {
       return false;
     SIAtomicAddrSpace AccessedAS =
         toSIAtomicAddrSpace(Ptr->getType()->getPointerAddressSpace());
-    std::optional<SIAtomicAddrSpace> SynchronizedAS =
-        getSynchronizeAddrSpace(*F);
-    // If SynchronizedAS is std::nullopt, it refers to all address spaces.
-    return !SynchronizedAS ||
-           (*SynchronizedAS & AccessedAS) != SIAtomicAddrSpace::NONE;
+    return (AccessedAS & getSynchronizeAddrSpace(*F)) !=
+           SIAtomicAddrSpace::NONE;
   }
 
   if (const auto *I = dyn_cast<AtomicRMWInst>(DefInst))

_______________________________________________
llvm-branch-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits

Reply via email to