[clang] [CIR][AMDGPU] Look through address_space views when forwarding indirect args (PR #239158)

via cfe-commits cfe-commits at lists.llvm.org
Thu Nov 5 01:45:59 PST 2026


https://github.com/skc7 created https://github.com/llvm/llvm-project/pull/239158

Summary:

- `CIRGen` loads AMDGPU locals through an `address_space` cast of their addrspace(5) `alloca`. 
- Pass the `alloca` instead of copying into a new `byref` slot.
- `forwardableIndirectLoad` becomes `forwardableIndirectAddr` and returns the cast's source when it has the parameter's type.

Assisted by: claude opus 5.5

>From e556de4229f187ed044f93ac1d952720492d32b8 Mon Sep 17 00:00:00 2001
From: skc7 <Krishna.Sankisa at amd.com>
Date: Thu, 5 Nov 2026 15:10:21 +0530
Subject: [PATCH] [CIR][AMDGPU] Look through address_space views when
 forwarding indirect args

---
 .../TargetLowering/CIRABIRewriteContext.cpp   | 49 +++++++++++--------
 .../Transforms/abi-lowering/amdgpu-byref.cir  | 16 ++++++
 .../abi-lowering/indirect-byval.cir           | 20 ++++----
 .../indirect-non-byval-forward-param.cir      | 47 ++++++++++++++++++
 .../abi-lowering/indirect-non-byval-nyi.cir   | 45 -----------------
 5 files changed, 101 insertions(+), 76 deletions(-)

diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp
index d329938b69cdc..1b909f3cf47f0 100644
--- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp
@@ -964,15 +964,16 @@ static cir::LoadOp getWholeRecordLoad(mlir::Value recordVal) {
   return load;
 }
 
-/// Returns \p load if the address it read from can be passed in place of the
-/// loaded value for an indirect argument that needs \p minAlign alignment,
-/// and null otherwise, including when \p load is null.  A byval or byref
-/// argument also needs storageUnwrittenBetween.  On null the caller reports a
-/// non-byval argument or fills a slot of its own.
+/// Returns the address \p load read from, as a pointer of type \p paramTy, if
+/// it can be passed in place of the loaded value for an indirect argument that
+/// needs \p minAlign alignment, and null otherwise, including when \p load is
+/// null.  A byval or byref argument also needs storageUnwrittenBetween.  On
+/// null the caller reports a non-byval argument or fills a slot of its own.
 ///
 /// The address has to have \p paramTy, the rewritten parameter's type, since a
-/// cir.load pins the pointee type without pinning the address space.  The
-/// storage it names has to be a slot allocated here, reached through
+/// cir.load pins the pointee type without pinning the address space.  An
+/// address_space cast of a \p paramTy pointer qualifies through its source.
+/// The storage it names has to be a slot allocated here, reached through
 /// storage-preserving casts, already stating at least \p minAlign.  The
 /// enclosing function's own non-byval parameter qualifies as well, since its
 /// slot stands until finalizeParameterSlots and prepareNonByvalParameters has
@@ -984,13 +985,21 @@ static cir::LoadOp getWholeRecordLoad(mlir::Value recordVal) {
 /// Raising a slot's alignment here would not hold for one that stands in
 /// for a parameter, since finalizeParameterSlots replaces it with the
 /// incoming pointer, which promises only what the caller gave it.
-static cir::LoadOp forwardableIndirectLoad(cir::LoadOp load,
+static mlir::Value forwardableIndirectAddr(cir::LoadOp load,
                                            cir::PointerType paramTy,
                                            uint64_t minAlign) {
-  if (!load || load.getAddr().getType() != paramTy)
+  if (!load)
     return {};
-  cir::AllocaOp slot = cir::getUnderlyingAlloca(load.getAddr());
-  return slot && slot.getAlignment() >= minAlign ? load : cir::LoadOp();
+  mlir::Value addr = load.getAddr();
+  // CIRGen reads an alloca outside the default address space through a cast.
+  if (auto view = addr.getDefiningOp<cir::CastOp>();
+      view && view.getKind() == cir::CastKind::address_space &&
+      view.getSrc().getType() == paramTy)
+    addr = view.getSrc();
+  if (addr.getType() != paramTy)
+    return {};
+  cir::AllocaOp slot = cir::getUnderlyingAlloca(addr);
+  return slot && slot.getAlignment() >= minAlign ? addr : mlir::Value();
 }
 
 /// True when \p aliasAnalysis shows that nothing between \p load and \p call
@@ -2213,14 +2222,14 @@ CIRABIRewriteContext::rewriteCallSite(mlir::Operation *callOp,
       // loaded value, so a store to that storage after the load is visible to
       // the callee.  byval fills a slot below, this cannot.
       if (!byCopy) {
-        cir::LoadOp fwdLoad = forwardableIndirectLoad(srcLoad, ptrTy, minAlign);
-        if (!fwdLoad)
+        mlir::Value fwdAddr = forwardableIndirectAddr(srcLoad, ptrTy, minAlign);
+        if (!fwdAddr)
           return call->emitOpError()
                  << "non-byval indirect argument that does not name the "
                     "caller's storage is not yet implemented in "
                     "CallConvLowering";
-        newArgs.push_back(fwdLoad.getAddr());
-        deadRecordLoads.push_back(fwdLoad);
+        newArgs.push_back(fwdAddr);
+        deadRecordLoads.push_back(srcLoad);
         continue;
       }
 
@@ -2230,12 +2239,12 @@ CIRABIRewriteContext::rewriteCallSite(mlir::Operation *callOp,
       // call, since the operand carries the value as of the load.  A volatile
       // load is not forwarded, since the copy byval takes at the call is not
       // volatile.
-      if (cir::LoadOp fwdLoad =
-              forwardableIndirectLoad(srcLoad, ptrTy, minAlign);
-          fwdLoad && storageUnwrittenBetween(fwdLoad, call.getOperation(),
+      if (mlir::Value fwdAddr =
+              forwardableIndirectAddr(srcLoad, ptrTy, minAlign);
+          fwdAddr && storageUnwrittenBetween(srcLoad, call.getOperation(),
                                              aliasAnalysis)) {
-        newArgs.push_back(fwdLoad.getAddr());
-        deadRecordLoads.push_back(fwdLoad);
+        newArgs.push_back(fwdAddr);
+        deadRecordLoads.push_back(srcLoad);
         continue;
       }
 
diff --git a/clang/test/CIR/Transforms/abi-lowering/amdgpu-byref.cir b/clang/test/CIR/Transforms/abi-lowering/amdgpu-byref.cir
index 45a4886a33ee5..374c5b446c5d5 100644
--- a/clang/test/CIR/Transforms/abi-lowering/amdgpu-byref.cir
+++ b/clang/test/CIR/Transforms/abi-lowering/amdgpu-byref.cir
@@ -52,4 +52,20 @@ module attributes {
   // CHECK-NEXT: %[[B_SLOT:.*]] = cir.alloca "b" align(4) : !cir.ptr<!rec_Big, target_address_space(5)>
   // CHECK-NEXT: cir.call @take_big(%[[B_SLOT]]) : (!cir.ptr<!rec_Big, target_address_space(5)> {llvm.align = 4 : i64, llvm.byref = !rec_Big, llvm.noundef}) -> ()
   // CHECK-NEXT: cir.return
+
+  // CIRGen reads the local through its default address space view. The
+  // addrspace(5) alloca under the view is passed, not a copy of it.
+  cir.func @call_big_view() requires_call_conv_lowering {
+    %0 = cir.alloca "b" align(4) : !cir.ptr<!rec_Big, target_address_space(5)>
+    %1 = cir.cast address_space %0 : !cir.ptr<!rec_Big, target_address_space(5)> -> !cir.ptr<!rec_Big>
+    %2 = cir.load %1 : !cir.ptr<!rec_Big>, !rec_Big
+    cir.call @take_big(%2) : (!rec_Big) -> ()
+    cir.return
+  }
+
+  // CHECK: cir.func{{.*}} @call_big_view() {
+  // CHECK-NEXT: %[[B_SLOT:.*]] = cir.alloca "b" align(4) : !cir.ptr<!rec_Big, target_address_space(5)>
+  // CHECK-NEXT: %{{.*}} = cir.cast address_space %[[B_SLOT]] : !cir.ptr<!rec_Big, target_address_space(5)> -> !cir.ptr<!rec_Big>
+  // CHECK-NEXT: cir.call @take_big(%[[B_SLOT]]) : (!cir.ptr<!rec_Big, target_address_space(5)> {llvm.align = 4 : i64, llvm.byref = !rec_Big, llvm.noundef}) -> ()
+  // CHECK-NEXT: cir.return
 }
diff --git a/clang/test/CIR/Transforms/abi-lowering/indirect-byval.cir b/clang/test/CIR/Transforms/abi-lowering/indirect-byval.cir
index 4976580cc8fc0..87244540df0e5 100644
--- a/clang/test/CIR/Transforms/abi-lowering/indirect-byval.cir
+++ b/clang/test/CIR/Transforms/abi-lowering/indirect-byval.cir
@@ -802,9 +802,8 @@ module attributes {
   // CHECK-NEXT:   cir.call @takes_big_align16(%[[SLOT]]) : (!cir.ptr<!rec_Big>
   // CHECK-SAME:     llvm.align = 16 : i64, llvm.byval = !rec_Big, llvm.noundef
 
-  // The slot underneath the cast is aligned well enough, but the rewritten
-  // parameter is a pointer in the default address space, so the operand
-  // cannot be handed on and a slot of its own is filled instead.
+  // The operand is loaded through an address_space cast of a slot that already
+  // has the rewritten parameter's type, so the slot itself is handed on.
   cir.func @caller_byval_through_addrspace(%s: !rec_Big)
       requires_call_conv_lowering attributes { test_classify = #passthrough } {
     %raw = cir.alloca "raw" align(8) : !cir.ptr<!rec_Big>
@@ -817,14 +816,13 @@ module attributes {
     cir.return
   }
 
-  // CHECK:      cir.func{{.*}} @caller_byval_through_addrspace
-  // CHECK:        %[[RAW:.*]] = cir.alloca "raw" align(8) : !cir.ptr<!rec_Big>
-  // CHECK:        %[[AS:.*]] = cir.cast address_space %[[RAW]]
-  // CHECK:        %[[SLOT:.*]] = cir.alloca "byval" align(8) : !cir.ptr<!rec_Big>
-  // CHECK-NEXT:   cir.copy %[[AS]] align(8) to %[[SLOT]] align(8)
-  // CHECK-SAME:     : !cir.ptr<!rec_Big, target_address_space(5)>, !cir.ptr<!rec_Big>
-  // CHECK-NEXT:   %{{.*}} = cir.call @takes_big(%[[SLOT]]) :
-  // CHECK-SAME:     llvm.byval = !rec_Big, llvm.noundef
+  // CHECK:      cir.func{{.*}} @caller_byval_through_addrspace(%[[S:.*]]: !rec_Big)
+  // CHECK-NEXT:   %[[RAW:.*]] = cir.alloca "raw" align(8) : !cir.ptr<!rec_Big>
+  // CHECK-NEXT:   %[[AS:.*]] = cir.cast address_space %[[RAW]] : !cir.ptr<!rec_Big> -> !cir.ptr<!rec_Big, target_address_space(5)>
+  // CHECK-NEXT:   cir.store %[[S]], %[[AS]] : !rec_Big, !cir.ptr<!rec_Big, target_address_space(5)>
+  // CHECK-NEXT:   %{{.*}} = cir.call @takes_big(%[[RAW]]) :
+  // CHECK-SAME:     (!cir.ptr<!rec_Big> {llvm.align = 8 : i64, llvm.byval = !rec_Big, llvm.noundef}) -> !s32i
+  // CHECK-NEXT:   cir.return
 
   // One load feeding both byval operands is forwarded to both, and erased
   // once, since neither hand-off reads it.  byval makes each callee a copy
diff --git a/clang/test/CIR/Transforms/abi-lowering/indirect-non-byval-forward-param.cir b/clang/test/CIR/Transforms/abi-lowering/indirect-non-byval-forward-param.cir
index f82fb321dce29..ad4cbcbdb1390 100644
--- a/clang/test/CIR/Transforms/abi-lowering/indirect-non-byval-forward-param.cir
+++ b/clang/test/CIR/Transforms/abi-lowering/indirect-non-byval-forward-param.cir
@@ -1040,3 +1040,50 @@ module attributes {
       requires_call_conv_lowering attributes { test_classify = #byval_arg }
 
 }
+
+// -----
+
+!s64i = !cir.int<s, 64>
+!rec_Big = !cir.struct<"Big" {data !s64i, data !s64i, data !s64i, data !s64i}>
+
+#non_byval_arg = {
+  return = { kind = "direct" },
+  args   = [ { kind = "indirect", indirect_align = 8, byval = false } ]
+}
+
+#passthrough = {
+  return = { kind = "direct" },
+  args   = [ ]
+}
+
+module attributes {
+  dlti.dl_spec = #dlti.dl_spec<
+    #dlti.dl_entry<i64, dense<64>: vector<2xi64>>>
+} {
+
+  cir.func private @takes_big_non_byval(%arg0: !rec_Big)
+      requires_call_conv_lowering attributes { test_classify = #non_byval_arg }
+
+  // The operand is loaded through an address_space cast of a slot that already
+  // has the rewritten parameter's type, so the slot itself is handed on.
+  cir.func @caller_non_byval_through_addrspace(%s: !rec_Big)
+      requires_call_conv_lowering attributes { test_classify = #passthrough } {
+    %raw = cir.alloca "raw" align(8) : !cir.ptr<!rec_Big>
+    %slot = cir.cast address_space %raw
+        : !cir.ptr<!rec_Big> -> !cir.ptr<!rec_Big, target_address_space(5)>
+    cir.store %s, %slot : !rec_Big, !cir.ptr<!rec_Big, target_address_space(5)>
+    %asload = cir.load %slot
+        : !cir.ptr<!rec_Big, target_address_space(5)>, !rec_Big
+    cir.call @takes_big_non_byval(%asload) : (!rec_Big) -> ()
+    cir.return
+  }
+
+  // CHECK:      cir.func{{.*}} @caller_non_byval_through_addrspace(%[[S:.*]]: !rec_Big)
+  // CHECK-NEXT:   %[[RAW:.*]] = cir.alloca "raw" align(8) : !cir.ptr<!rec_Big>
+  // CHECK-NEXT:   %[[AS:.*]] = cir.cast address_space %[[RAW]] : !cir.ptr<!rec_Big> -> !cir.ptr<!rec_Big, target_address_space(5)>
+  // CHECK-NEXT:   cir.store %[[S]], %[[AS]] : !rec_Big, !cir.ptr<!rec_Big, target_address_space(5)>
+  // CHECK-NEXT:   cir.call @takes_big_non_byval(%[[RAW]]) :
+  // CHECK-SAME:     (!cir.ptr<!rec_Big> {llvm.align = 8 : i64, llvm.dead_on_return = -1 : i64, llvm.dereferenceable = 32 : i64, llvm.nofreeobj, llvm.noundef}) -> ()
+  // CHECK-NEXT:   cir.return
+
+}
diff --git a/clang/test/CIR/Transforms/abi-lowering/indirect-non-byval-nyi.cir b/clang/test/CIR/Transforms/abi-lowering/indirect-non-byval-nyi.cir
index 387160db5dfde..c125c07bb9319 100644
--- a/clang/test/CIR/Transforms/abi-lowering/indirect-non-byval-nyi.cir
+++ b/clang/test/CIR/Transforms/abi-lowering/indirect-non-byval-nyi.cir
@@ -470,51 +470,6 @@ module attributes {
   args   = [ { kind = "indirect", indirect_align = 8, byval = false } ]
 }
 
-#passthrough = {
-  return = { kind = "direct" },
-  args   = [ ]
-}
-
-module attributes {
-  dlti.dl_spec = #dlti.dl_spec<
-    #dlti.dl_entry<i64, dense<64>: vector<2xi64>>>
-} {
-
-  cir.func private @takes_big_non_byval(%arg0: !rec_Big)
-      requires_call_conv_lowering attributes { test_classify = #non_byval_arg }
-
-  // The slot underneath the cast is forwardable, but the rewritten parameter
-  // is a pointer in the default address space, so the operand cannot be
-  // handed on as it stands.
-  cir.func @caller_non_byval_through_addrspace(%s: !rec_Big)
-      requires_call_conv_lowering attributes { test_classify = #passthrough } {
-    %raw = cir.alloca "raw" align(8) : !cir.ptr<!rec_Big>
-    %slot = cir.cast address_space %raw
-        : !cir.ptr<!rec_Big> -> !cir.ptr<!rec_Big, target_address_space(5)>
-    cir.store %s, %slot : !rec_Big, !cir.ptr<!rec_Big, target_address_space(5)>
-    %asload = cir.load %slot
-        : !cir.ptr<!rec_Big, target_address_space(5)>, !rec_Big
-    cir.call @takes_big_non_byval(%asload) : (!rec_Big) -> ()
-    cir.return
-  }
-
-  // CHECK: error: 'cir.call' op non-byval indirect argument that
-  // CHECK-SAME: does not name the caller's storage is not yet
-  // CHECK-SAME: implemented in CallConvLowering
-  // CHECK-NEXT: cir.call @takes_big_non_byval(%asload)
-
-}
-
-// -----
-
-!s64i = !cir.int<s, 64>
-!rec_Big = !cir.struct<"Big" {data !s64i, data !s64i, data !s64i, data !s64i}>
-
-#non_byval_arg = {
-  return = { kind = "direct" },
-  args   = [ { kind = "indirect", indirect_align = 8, byval = false } ]
-}
-
 #direct_ptr = {
   return = { kind = "direct" },
   args   = [ { kind = "direct" } ]



More information about the cfe-commits mailing list