[llvm] [AMDGPU] Do not propagate vgpr count in dVGPR mode (PR #187078)

Mirko BrkuĊĦanin via llvm-commits llvm-commits at lists.llvm.org
Tue Jun 2 05:43:46 PDT 2026


https://github.com/mbrkusanin updated https://github.com/llvm/llvm-project/pull/187078

>From 6350a438891b1913cebfdc01e242391610e54a4d Mon Sep 17 00:00:00 2001
From: Mirko Brkusanin <Mirko.Brkusanin at amd.com>
Date: Tue, 17 Mar 2026 18:43:48 +0100
Subject: [PATCH 1/8] [AMDGPU] Do not propagate vgpr count in dVGPR mode

When dVGPR mode is enabled simply set the .vgpr_count to local
number of VGPRs instead of module wide maximum.

Keep the maximum for retry_vgpr_alloc and first_retry_wrapper.
---
 .../Target/AMDGPU/AMDGPUMCResourceInfo.cpp    | 24 ++++++-
 .../AMDGPU/dvgpr-vgpr-count-propagation.ll    | 62 +++++++++++++++++++
 2 files changed, 83 insertions(+), 3 deletions(-)
 create mode 100644 llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll

diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
index 2d43019a8d66b..3b48720e3be9d 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
@@ -13,7 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "AMDGPUMCResourceInfo.h"
-#include "AMDGPUTargetMachine.h"
+#include "SIMachineFunctionInfo.h"
 #include "Utils/AMDGPUBaseInfo.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCAsmInfo.h"
@@ -318,9 +318,27 @@ void MCResourceInfo::gatherResourceInfo(
     }
   };
 
+  auto SetToLocal = [&](int64_t LocalValue, ResourceInfoKind RIK) {
+    MCSymbol *Sym = getSymbol(FnSym->getName(), RIK, OutContext, IsLocal);
+    LLVM_DEBUG(
+        dbgs() << "MCResUse:   " << Sym->getName() << ": Adding " << LocalValue
+               << ", no further propagation as indirect callee found within\n");
+    Sym->setVariableValue(MCConstantExpr::create(LocalValue, OutContext));
+  };
+
+  // When DynamicVGPR is enabled do not propagate VGPR counts from callees.
+  bool SkipVGPRPropagation =
+      MF.getInfo<SIMachineFunctionInfo>()->isDynamicVGPREnabled() &&
+      MF.getFunction().getCallingConv() == CallingConv::AMDGPU_CS_Chain;
+
   LLVM_DEBUG(dbgs() << "MCResUse: " << FnSym->getName() << '\n');
-  SetMaxReg(MaxVGPRSym, FRI.NumVGPR, RIK_NumVGPR);
-  SetMaxReg(MaxAGPRSym, FRI.NumAGPR, RIK_NumAGPR);
+  if (SkipVGPRPropagation) {
+    SetToLocal(FRI.NumVGPR, RIK_NumVGPR);
+    SetToLocal(FRI.NumAGPR, RIK_NumAGPR);
+  } else {
+    SetMaxReg(MaxVGPRSym, FRI.NumVGPR, RIK_NumVGPR);
+    SetMaxReg(MaxAGPRSym, FRI.NumAGPR, RIK_NumAGPR);
+  }
   SetMaxReg(MaxSGPRSym, FRI.NumExplicitSGPR, RIK_NumSGPR);
   SetMaxReg(MaxNamedBarrierSym, FRI.NumNamedBarrier, RIK_NumNamedBarrier);
 
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
new file mode 100644
index 0000000000000..2b3ca42eb04d8
--- /dev/null
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
@@ -0,0 +1,62 @@
+; RUN: llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 < %s | FileCheck -check-prefix=DVGPR %s
+; RUN: sed 's/"amdgpu-dynamic-vgpr-block-size"="16"/nounwind/' %s \
+; RUN:   | llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 | FileCheck -check-prefix=NODVGPR %s
+
+; DVGPR-DAG:   .set func.0.num_vgpr, 15
+; DVGPR-DAG:   .set func.0.has_indirect_call, 1
+; DVGPR-DAG:   .set func.1.num_vgpr, 55
+; DVGPR-DAG:   .set func.1.has_indirect_call, 1
+; DVGPR-DAG:   .set retry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; DVGPR-DAG:   .set retry_vgpr_alloc.has_indirect_call, 1
+; DVGPR-DAG:   .set first_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; DVGPR-DAG:   .set first_retry_wrapper.has_indirect_call, 1
+; DVGPR-DAG:   .set amdgpu.max_num_vgpr, 55
+
+; DVGPR:       .shader_functions:
+; DVGPR:         func.0:
+; DVGPR:           .vgpr_count: 0xf
+; DVGPR:         func.1:
+; DVGPR:           .vgpr_count: 0x37
+
+; NODVGPR-DAG: .set func.0.num_vgpr, max(15, amdgpu.max_num_vgpr)
+; NODVGPR-DAG: .set func.0.has_indirect_call, 1
+; NODVGPR-DAG: .set func.1.num_vgpr, max(55, amdgpu.max_num_vgpr)
+; NODVGPR-DAG: .set func.1.has_indirect_call, 1
+; NODVGPR-DAG: .set retry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR-DAG: .set retry_vgpr_alloc.has_indirect_call, 1
+; NODVGPR-DAG: .set first_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR-DAG: .set first_retry_wrapper.has_indirect_call, 1
+; NODVGPR-DAG: .set amdgpu.max_num_vgpr, 55
+
+; NODVGPR:     .shader_functions:
+; NODVGPR:       func.0:
+; NODVGPR:         .vgpr_count: 0x37
+; NODVGPR:       func.1:
+; NODVGPR:         .vgpr_count: 0x37
+
+define amdgpu_cs_chain void @func.0(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9}"()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> %vgprs, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
+  unreachable
+}
+
+define amdgpu_cs_chain void @func.1(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39},~{v40},~{v41},~{v42},~{v43},~{v44},~{v45},~{v46},~{v47},~{v48},~{v49}"()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> %vgprs, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
+  unreachable
+}
+
+define amdgpu_cs_chain_preserve void @retry_vgpr_alloc(<3 x i32> inreg %sgprs) #0 {
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @retry_vgpr_alloc)
+  unreachable
+}
+
+define amdgpu_cs_chain_preserve void @first_retry_wrapper(<3 x i32> inreg %sgprs) #0 {
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg @retry_vgpr_alloc, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @retry_vgpr_alloc)
+  unreachable
+}
+
+attributes #0 = { "amdgpu-dynamic-vgpr-block-size"="16" }

>From 0d4bee339f3d2d39f39c8b45a6536ebff73d2136 Mon Sep 17 00:00:00 2001
From: Mirko Brkusanin <Mirko.Brkusanin at amd.com>
Date: Wed, 25 Mar 2026 17:53:44 +0100
Subject: [PATCH 2/8] update

---
 .../Target/AMDGPU/AMDGPUMCResourceInfo.cpp    |  26 +++-
 .../AMDGPU/dvgpr-vgpr-count-propagation.ll    | 141 +++++++++++++-----
 2 files changed, 123 insertions(+), 44 deletions(-)

diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
index 3b48720e3be9d..9efb7bf55eea7 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
@@ -326,15 +326,25 @@ void MCResourceInfo::gatherResourceInfo(
     Sym->setVariableValue(MCConstantExpr::create(LocalValue, OutContext));
   };
 
-  // When DynamicVGPR is enabled do not propagate VGPR counts from callees.
-  bool SkipVGPRPropagation =
-      MF.getInfo<SIMachineFunctionInfo>()->isDynamicVGPREnabled() &&
-      MF.getFunction().getCallingConv() == CallingConv::AMDGPU_CS_Chain;
-
   LLVM_DEBUG(dbgs() << "MCResUse: " << FnSym->getName() << '\n');
-  if (SkipVGPRPropagation) {
-    SetToLocal(FRI.NumVGPR, RIK_NumVGPR);
-    SetToLocal(FRI.NumAGPR, RIK_NumAGPR);
+
+  CallingConv::ID CC = MF.getFunction().getCallingConv();
+
+  // When DynamicVGPR is enabled, chain functions should not propagate VGPR
+  // counts from other chain callees since each chain function can have its own
+  // VGPR allocation, but should still propagate from non-chain callees.
+  if (MF.getInfo<SIMachineFunctionInfo>()->isDynamicVGPREnabled() &&
+      (CC == CallingConv::AMDGPU_CS_Chain || CC == CallingConv::AMDGPU_CS)) {
+    SmallVector<const Function *, 16> NonChainCallees;
+    for (const Function *Callee : FRI.Callees) {
+      if (!AMDGPU::isChainCC(Callee->getCallingConv()) &&
+          !Callee->isDeclaration())
+        NonChainCallees.push_back(Callee);
+    }
+    assignResourceInfoExpr(FRI.NumVGPR, RIK_NumVGPR, AMDGPUMCExpr::AGVK_Max, MF,
+                           NonChainCallees, OutContext);
+    assignResourceInfoExpr(FRI.NumAGPR, RIK_NumAGPR, AMDGPUMCExpr::AGVK_Max, MF,
+                           NonChainCallees, OutContext);
   } else {
     SetMaxReg(MaxVGPRSym, FRI.NumVGPR, RIK_NumVGPR);
     SetMaxReg(MaxAGPRSym, FRI.NumAGPR, RIK_NumAGPR);
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
index 2b3ca42eb04d8..2a920bbe01449 100644
--- a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
@@ -1,50 +1,119 @@
 ; RUN: llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 < %s | FileCheck -check-prefix=DVGPR %s
-; RUN: sed 's/"amdgpu-dynamic-vgpr-block-size"="16"/nounwind/' %s \
+; RUN: sed 's/"amdgpu-dynamic-vgpr-block-size"="16"/"amdgpu-dynamic-vgpr-block-size"="0"/' %s \
 ; RUN:   | llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 | FileCheck -check-prefix=NODVGPR %s
 
-; DVGPR-DAG:   .set func.0.num_vgpr, 15
-; DVGPR-DAG:   .set func.0.has_indirect_call, 1
-; DVGPR-DAG:   .set func.1.num_vgpr, 55
-; DVGPR-DAG:   .set func.1.has_indirect_call, 1
-; DVGPR-DAG:   .set retry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; DVGPR-DAG:   .set retry_vgpr_alloc.has_indirect_call, 1
-; DVGPR-DAG:   .set first_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; DVGPR-DAG:   .set first_retry_wrapper.has_indirect_call, 1
-; DVGPR-DAG:   .set amdgpu.max_num_vgpr, 55
-
-; DVGPR:       .shader_functions:
-; DVGPR:         func.0:
-; DVGPR:           .vgpr_count: 0xf
-; DVGPR:         func.1:
-; DVGPR:           .vgpr_count: 0x37
-
-; NODVGPR-DAG: .set func.0.num_vgpr, max(15, amdgpu.max_num_vgpr)
-; NODVGPR-DAG: .set func.0.has_indirect_call, 1
-; NODVGPR-DAG: .set func.1.num_vgpr, max(55, amdgpu.max_num_vgpr)
-; NODVGPR-DAG: .set func.1.has_indirect_call, 1
-; NODVGPR-DAG: .set retry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR-DAG: .set retry_vgpr_alloc.has_indirect_call, 1
-; NODVGPR-DAG: .set first_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR-DAG: .set first_retry_wrapper.has_indirect_call, 1
-; NODVGPR-DAG: .set amdgpu.max_num_vgpr, 55
-
-; NODVGPR:     .shader_functions:
-; NODVGPR:       func.0:
-; NODVGPR:         .vgpr_count: 0x37
-; NODVGPR:       func.1:
-; NODVGPR:         .vgpr_count: 0x37
+; DVGPR:  .set gfx_func_a.num_vgpr, 40
+; DVGPR:  .set gfx_func_b2.num_vgpr, 80
+; DVGPR:  .set gfx_func_b.num_vgpr, max(61, gfx_func_b2.num_vgpr)
+; DVGPR:  .set amdgpu_cs_main.num_vgpr, max(42, gfx_func_a.num_vgpr)
+; DVGPR:  .set func.0.num_vgpr, 11
+; DVGPR:  .set func.1.num_vgpr, max(11, gfx_func_a.num_vgpr, gfx_func_b.num_vgpr)
+; DVGPR:  .set func.2.num_vgpr, max(11, gfx_func_a.num_vgpr)
+; DVGPR:  .set func.3.num_vgpr, max(11, gfx_func_b.num_vgpr)
+; DVGPR:  .set retry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; DVGPR:  .set first_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; DVGPR:  .set amdgpu.max_num_vgpr, 80
+
+; NODVGPR:  .set gfx_func_a.num_vgpr, 40
+; NODVGPR:  .set gfx_func_b2.num_vgpr, 80
+; NODVGPR:  .set gfx_func_b.num_vgpr, max(61, gfx_func_b2.num_vgpr)
+; NODVGPR:  .set amdgpu_cs_main.num_vgpr, max(42, amdgpu.max_num_vgpr)
+; NODVGPR:  .set func.0.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set func.1.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set func.2.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set func.3.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set retry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set first_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set amdgpu.max_num_vgpr, 80
+
+; DVGPR:  - .hardware_stages:
+; DVGPR:        .vgpr_count: 0x2a
+; DVGPR:    .shader_functions:
+; DVGPR:      func.0:
+; DVGPR:        .vgpr_count: 0xb
+; DVGPR:      func.1:
+; DVGPR:        .vgpr_count: 0x50
+; DVGPR:      func.2:
+; DVGPR:        .vgpr_count: 0x28
+; DVGPR:      func.3:
+; DVGPR:        .vgpr_count: 0x50
+; DVGPR:      gfx_func_a:
+; DVGPR:        .vgpr_count: 0x28
+; DVGPR:      gfx_func_b:
+; DVGPR:        .vgpr_count: 0x50
+; DVGPR:      gfx_func_b2:
+; DVGPR:        .vgpr_count: 0x50
+
+; NODVGPR:  - .hardware_stages:
+; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:    .shader_functions:
+; NODVGPR:      func.0:
+; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:      func.1:
+; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:      func.2:
+; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:      func.3:
+; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:      gfx_func_a:
+; NODVGPR:        .vgpr_count: 0x28
+; NODVGPR:      gfx_func_b:
+; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:      gfx_func_b2:
+; NODVGPR:        .vgpr_count: 0x50
+
+define amdgpu_gfx void @gfx_func_a() #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39}"()
+  ret void
+}
+
+define amdgpu_gfx void @gfx_func_b2() #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39},~{v40},~{v41},~{v42},~{v43},~{v44},~{v45},~{v46},~{v47},~{v48},~{v49},~{v50},~{v51},~{v52},~{v53},~{v54},~{v55},~{v56},~{v57},~{v58},~{v59},~{v60},~{v61},~{v62},~{v63},~{v64},~{v65},~{v66},~{v67},~{v68},~{v69},~{v70},~{v71},~{v72},~{v73},~{v74},~{v75},~{v76},~{v77},~{v78},~{v79}"()
+  ret void
+}
+
+define amdgpu_gfx void @gfx_func_b() #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39},~{v40},~{v41},~{v42},~{v43},~{v44},~{v45},~{v46},~{v47},~{v48},~{v49},~{v50},~{v51},~{v52},~{v53},~{v54},~{v55},~{v56},~{v57},~{v58},~{v59}"()
+  call amdgpu_gfx void @gfx_func_b2()
+  ret void
+}
+
+define amdgpu_cs void @amdgpu_cs_main(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call amdgpu_gfx void @gfx_func_a()
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @func.1)
+  unreachable
+}
 
 define amdgpu_cs_chain void @func.0(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
-  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9}"()
+  call void asm sideeffect "", "~{v0},~{v1}"()
   %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
-  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> %vgprs, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
   unreachable
 }
 
 define amdgpu_cs_chain void @func.1(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
-  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39},~{v40},~{v41},~{v42},~{v43},~{v44},~{v45},~{v46},~{v47},~{v48},~{v49}"()
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3}"()
+  call amdgpu_gfx void @gfx_func_a()
+  call amdgpu_gfx void @gfx_func_b()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
+  unreachable
+}
+
+define amdgpu_cs_chain void @func.2(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5}"()
+  call amdgpu_gfx void @gfx_func_a()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
+  unreachable
+}
+
+define amdgpu_cs_chain void @func.3(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7}"()
+  call amdgpu_gfx void @gfx_func_b()
   %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
-  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> %vgprs, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
   unreachable
 }
 

>From 496ec59bf49155ae190a20c75a00aa88ed483083 Mon Sep 17 00:00:00 2001
From: Mirko Brkusanin <Mirko.Brkusanin at amd.com>
Date: Tue, 19 May 2026 17:26:29 +0200
Subject: [PATCH 3/8] handle indirect calls; construct MCExpr for values not
 yet available

---
 llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp   | 53 ++++++++++-----
 .../Target/AMDGPU/AMDGPUMCResourceInfo.cpp    | 66 +++++++++++++------
 llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h |  5 ++
 .../AMDGPU/AMDGPUResourceUsageAnalysis.cpp    |  3 +
 .../AMDGPU/AMDGPUResourceUsageAnalysis.h      |  1 +
 .../MCTargetDesc/AMDGPUTargetStreamer.cpp     |  3 +-
 .../MCTargetDesc/AMDGPUTargetStreamer.h       |  2 +
 .../dvgpr-vgpr-count-propagation-indirect.ll  | 47 +++++++++++++
 .../AMDGPU/dvgpr-vgpr-count-propagation.ll    | 42 ++++++------
 9 files changed, 162 insertions(+), 60 deletions(-)
 create mode 100644 llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll

diff --git a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
index f1c015312d9a7..1ab786b051f7e 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
@@ -731,7 +731,8 @@ bool AMDGPUAsmPrinter::doFinalization(Module &M) {
   OutStreamer->switchSection(MaxGPRSection);
   getTargetStreamer()->EmitMCResourceMaximums(
       RI.getMaxVGPRSymbol(OutContext), RI.getMaxAGPRSymbol(OutContext),
-      RI.getMaxSGPRSymbol(OutContext), RI.getMaxNamedBarrierSymbol(OutContext));
+      RI.getMaxSGPRSymbol(OutContext), RI.getMaxNonChainVGPRSymbol(OutContext),
+      RI.getMaxNamedBarrierSymbol(OutContext));
   OutStreamer->popSection();
 
   // In the object-linking pipeline per-function resource MCExprs reference
@@ -1131,28 +1132,44 @@ void AMDGPUAsmPrinter::emitDVgprSymbol(MachineFunction &MF) {
       MF.getFunction().getCallingConv() == CallingConv::AMDGPU_CS_Chain) {
     MCContext &Ctx = MF.getContext();
     unsigned BlockSize = MFI.getDynamicVGPRBlockSize();
+
+    const MCExpr *EncodedBlocks;
     MCValue NumVGPRs;
-    if (!CurrentProgramInfo.NumVGPRsForWavesPerEU->evaluateAsRelocatable(
-            NumVGPRs, nullptr) ||
-        !NumVGPRs.isAbsolute()) {
-      llvm_unreachable("unable to resolve NumVGPRs for _dvgpr$ symbol");
+    if (CurrentProgramInfo.NumVGPRsForWavesPerEU->evaluateAsRelocatable(
+            NumVGPRs, nullptr) &&
+        NumVGPRs.isAbsolute()) {
+
+      // Calculate number of VGPR blocks.
+      // Treat 0 VGPRs as 1 VGPR to avoid underflowing.
+      unsigned NumBlocks =
+          divideCeil(std::max(unsigned(NumVGPRs.getConstant()), 1U), BlockSize);
+
+      if (NumBlocks > 8) {
+        OutContext.reportError(
+            {}, "too many DVGPR blocks for _dvgpr$ symbol for '" +
+                    Twine(CurrentFnSym->getName()) + "'");
+        return;
+      }
+      unsigned EncodedNumBlocks = (NumBlocks - 1) << 3;
+      EncodedBlocks = MCConstantExpr::create(EncodedNumBlocks, Ctx);
+    } else {
+      // Value not yet available so build a symbolic MCExpr:
+      // ((alignTo(max(NumVGPRs, 1), BlockSize) / BlockSize - 1) << 3
+      const MCExpr *One = MCConstantExpr::create(1, Ctx);
+      const MCExpr *BlockSizeConst = MCConstantExpr::create(BlockSize, Ctx);
+      const MCExpr *MaxVGPRs = AMDGPUMCExpr::createMax(
+          {CurrentProgramInfo.NumVGPRsForWavesPerEU, One}, Ctx);
+      const MCExpr *NumBlocks = MCBinaryExpr::createDiv(
+          AMDGPUMCExpr::createAlignTo(MaxVGPRs, BlockSizeConst, Ctx),
+          BlockSizeConst, Ctx);
+      EncodedBlocks =
+          MCBinaryExpr::createShl(MCBinaryExpr::createSub(NumBlocks, One, Ctx),
+                                  MCConstantExpr::create(3, Ctx), Ctx);
     }
-    // Calculate number of VGPR blocks.
-    // Treat 0 VGPRs as 1 VGPR to avoid underflowing.
-    unsigned NumBlocks =
-        divideCeil(std::max(unsigned(NumVGPRs.getConstant()), 1U), BlockSize);
 
-    if (NumBlocks > 8) {
-      OutContext.reportError({},
-                             "too many DVGPR blocks for _dvgpr$ symbol for '" +
-                                 Twine(CurrentFnSym->getName()) + "'");
-      return;
-    }
-    unsigned EncodedNumBlocks = (NumBlocks - 1) << 3;
     // Add to function symbol to create _dvgpr$ symbol.
     const MCExpr *DVgprFuncVal = MCBinaryExpr::createAdd(
-        MCSymbolRefExpr::create(CurrentFnSym, Ctx),
-        MCConstantExpr::create(EncodedNumBlocks, Ctx), Ctx);
+        MCSymbolRefExpr::create(CurrentFnSym, Ctx), EncodedBlocks, Ctx);
     MCSymbol *DVgprFuncSym =
         Ctx.getOrCreateSymbol(Twine("_dvgpr$") + CurrentFnSym->getName());
     OutStreamer->emitAssignment(DVgprFuncSym, DVgprFuncVal);
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
index 9efb7bf55eea7..062f3b8eaed21 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
@@ -68,6 +68,7 @@ void MCResourceInfo::assignMaxRegs(MCContext &OutContext) {
   MCSymbol *MaxVGPRSym = getMaxVGPRSymbol(OutContext);
   MCSymbol *MaxAGPRSym = getMaxAGPRSymbol(OutContext);
   MCSymbol *MaxSGPRSym = getMaxSGPRSymbol(OutContext);
+  MCSymbol *MaxNonChainVGPRSym = getMaxNonChainVGPRSymbol(OutContext);
   MCSymbol *MaxNamedBarrierSym = getMaxNamedBarrierSymbol(OutContext);
 
   auto assignMaxRegSym = [&OutContext](MCSymbol *Sym, int32_t RegCount) {
@@ -78,6 +79,7 @@ void MCResourceInfo::assignMaxRegs(MCContext &OutContext) {
   assignMaxRegSym(MaxVGPRSym, MaxVGPR);
   assignMaxRegSym(MaxAGPRSym, MaxAGPR);
   assignMaxRegSym(MaxSGPRSym, MaxSGPR);
+  assignMaxRegSym(MaxNonChainVGPRSym, MaxNonChainVGPR);
   assignMaxRegSym(MaxNamedBarrierSym, MaxNamedBarrier);
 }
 
@@ -101,6 +103,10 @@ MCSymbol *MCResourceInfo::getMaxSGPRSymbol(MCContext &OutContext) {
   return OutContext.getOrCreateSymbol("amdgpu.max_num_sgpr");
 }
 
+MCSymbol *MCResourceInfo::getMaxNonChainVGPRSymbol(MCContext &OutContext) {
+  return OutContext.getOrCreateSymbol("amdgpu.max_num_non_chain_vgpr");
+}
+
 MCSymbol *MCResourceInfo::getMaxNamedBarrierSymbol(MCContext &OutContext) {
   return OutContext.getOrCreateSymbol("amdgpu.max_num_named_barrier");
 }
@@ -254,12 +260,22 @@ void MCResourceInfo::gatherResourceInfo(
   MCSymbol *MaxVGPRSym = getMaxVGPRSymbol(OutContext);
   MCSymbol *MaxAGPRSym = getMaxAGPRSymbol(OutContext);
   MCSymbol *MaxSGPRSym = getMaxSGPRSymbol(OutContext);
+  MCSymbol *MaxNonChainVGPRSym = getMaxNonChainVGPRSymbol(OutContext);
   MCSymbol *MaxNamedBarrierSym = getMaxNamedBarrierSymbol(OutContext);
 
+  CallingConv::ID CC = MF.getFunction().getCallingConv();
+  bool IsDVGPRChain = CC == CallingConv::AMDGPU_CS_Chain ||
+                      CC == CallingConv::AMDGPU_CS_ChainPreserve;
+  bool IsDynamicVGPREnabled =
+      MF.getInfo<SIMachineFunctionInfo>()->isDynamicVGPREnabled();
+
   if (!AMDGPU::isEntryFunctionCC(MF.getFunction().getCallingConv())) {
     addMaxVGPRCandidate(FRI.NumVGPR);
     addMaxAGPRCandidate(FRI.NumAGPR);
     addMaxSGPRCandidate(FRI.NumExplicitSGPR);
+    if (IsDynamicVGPREnabled && !IsDVGPRChain) {
+      addMaxNonChainVGPRCandidate(FRI.NumVGPR);
+    }
     addMaxNamedBarrierCandidate(FRI.NumNamedBarrier);
   }
 
@@ -318,33 +334,41 @@ void MCResourceInfo::gatherResourceInfo(
     }
   };
 
-  auto SetToLocal = [&](int64_t LocalValue, ResourceInfoKind RIK) {
-    MCSymbol *Sym = getSymbol(FnSym->getName(), RIK, OutContext, IsLocal);
-    LLVM_DEBUG(
-        dbgs() << "MCResUse:   " << Sym->getName() << ": Adding " << LocalValue
-               << ", no further propagation as indirect callee found within\n");
-    Sym->setVariableValue(MCConstantExpr::create(LocalValue, OutContext));
-  };
-
   LLVM_DEBUG(dbgs() << "MCResUse: " << FnSym->getName() << '\n');
 
-  CallingConv::ID CC = MF.getFunction().getCallingConv();
-
   // When DynamicVGPR is enabled, chain functions should not propagate VGPR
   // counts from other chain callees since each chain function can have its own
   // VGPR allocation, but should still propagate from non-chain callees.
-  if (MF.getInfo<SIMachineFunctionInfo>()->isDynamicVGPREnabled() &&
-      (CC == CallingConv::AMDGPU_CS_Chain || CC == CallingConv::AMDGPU_CS)) {
-    SmallVector<const Function *, 16> NonChainCallees;
-    for (const Function *Callee : FRI.Callees) {
-      if (!AMDGPU::isChainCC(Callee->getCallingConv()) &&
-          !Callee->isDeclaration())
-        NonChainCallees.push_back(Callee);
+  if (IsDynamicVGPREnabled && (IsDVGPRChain || CC == CallingConv::AMDGPU_CS)) {
+    if (FRI.HasNonChainIndirectCall) {
+      // Has indirect calls to non-chain functions. Use max of direct non-chain
+      // callees and module-wide non-chain maximum.
+      SmallVector<const MCExpr *, 8> ArgExprs;
+      ArgExprs.push_back(MCConstantExpr::create(FRI.NumVGPR, OutContext));
+      ArgExprs.push_back(
+          MCSymbolRefExpr::create(MaxNonChainVGPRSym, OutContext));
+
+      SmallPtrSet<const Function *, 8> Seen;
+      for (const Function *Callee : FRI.Callees) {
+        if (AMDGPU::isChainCC(Callee->getCallingConv()))
+          continue;
+        if (!Seen.insert(Callee).second || Callee->isDeclaration())
+          continue;
+        MCSymbol *CalleeFnSym = TM.getSymbol(&Callee->getFunction());
+        MCSymbol *CalleeValSym =
+            getSymbol(CalleeFnSym->getName(), RIK_NumVGPR, OutContext);
+        ArgExprs.push_back(MCSymbolRefExpr::create(CalleeValSym, OutContext));
+      }
+      MCSymbol *Sym = getSymbol(FnSym->getName(), RIK_NumVGPR, OutContext);
+      Sym->setVariableValue(AMDGPUMCExpr::createMax(ArgExprs, OutContext));
+      SetMaxReg(MaxAGPRSym, FRI.NumAGPR, RIK_NumAGPR);
+    } else {
+      // No indirect calls to non-chain functions. Propagate from direct callees
+      assignResourceInfoExpr(FRI.NumVGPR, RIK_NumVGPR, AMDGPUMCExpr::AGVK_Max,
+                             MF, FRI.Callees, OutContext);
+      assignResourceInfoExpr(FRI.NumAGPR, RIK_NumAGPR, AMDGPUMCExpr::AGVK_Max,
+                             MF, FRI.Callees, OutContext);
     }
-    assignResourceInfoExpr(FRI.NumVGPR, RIK_NumVGPR, AMDGPUMCExpr::AGVK_Max, MF,
-                           NonChainCallees, OutContext);
-    assignResourceInfoExpr(FRI.NumAGPR, RIK_NumAGPR, AMDGPUMCExpr::AGVK_Max, MF,
-                           NonChainCallees, OutContext);
   } else {
     SetMaxReg(MaxVGPRSym, FRI.NumVGPR, RIK_NumVGPR);
     SetMaxReg(MaxAGPRSym, FRI.NumAGPR, RIK_NumAGPR);
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h
index 3cb063ef8e962..bdd71a660fbd2 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h
@@ -44,6 +44,7 @@ class MCResourceInfo {
   int32_t MaxVGPR = 0;
   int32_t MaxAGPR = 0;
   int32_t MaxSGPR = 0;
+  int32_t MaxNonChainVGPR = 0;
   int32_t MaxNamedBarrier = 0;
 
   // Whether the MCResourceInfo has been finalized through finalize(MCContext
@@ -77,6 +78,9 @@ class MCResourceInfo {
   void addMaxSGPRCandidate(int32_t candidate) {
     MaxSGPR = std::max(MaxSGPR, candidate);
   }
+  void addMaxNonChainVGPRCandidate(int32_t candidate) {
+    MaxNonChainVGPR = std::max(MaxNonChainVGPR, candidate);
+  }
   void addMaxNamedBarrierCandidate(int32_t candidate) {
     MaxNamedBarrier = std::max(MaxNamedBarrier, candidate);
   }
@@ -95,6 +99,7 @@ class MCResourceInfo {
   MCSymbol *getMaxVGPRSymbol(MCContext &OutContext);
   MCSymbol *getMaxAGPRSymbol(MCContext &OutContext);
   MCSymbol *getMaxSGPRSymbol(MCContext &OutContext);
+  MCSymbol *getMaxNonChainVGPRSymbol(MCContext &OutContext);
   MCSymbol *getMaxNamedBarrierSymbol(MCContext &OutContext);
 
   /// AMDGPUResourceUsageAnalysis gathers resource usage on a per-function
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.cpp b/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.cpp
index 09d59664f8dd4..aab43f23cf606 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.cpp
@@ -275,6 +275,9 @@ AMDGPUResourceUsageAnalysisImpl::analyzeResourceUsage(
         bool IsIndirect = !Callee || Callee->isDeclaration();
         Info.HasIndirectCall |= IsIndirect;
 
+        bool IsChainCall = MI.getOpcode() == AMDGPU::SI_TCRETURN_CHAIN;
+        Info.HasNonChainIndirectCall |= (!IsChainCall && IsIndirect);
+
         // In object linking mode the linker has the full cross-TU view. It
         // propagates resource usage across both direct calls to external
         // declarations and true indirect calls. Skip the compile-time
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.h b/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.h
index 9ae3bb3ca048e..2e0a447ebe5c4 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.h
+++ b/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.h
@@ -43,6 +43,7 @@ struct AMDGPUResourceUsageAnalysisImpl {
     bool HasDynamicallySizedStack = false;
     bool HasRecursion = false;
     bool HasIndirectCall = false;
+    bool HasNonChainIndirectCall = false;
     SmallVector<const Function *, 16> Callees;
   };
 
diff --git a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp
index e9d7cc3f1476d..62d0b3c34a67c 100644
--- a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp
+++ b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp
@@ -318,7 +318,7 @@ void AMDGPUTargetAsmStreamer::EmitMCResourceInfo(
 
 void AMDGPUTargetAsmStreamer::EmitMCResourceMaximums(
     const MCSymbol *MaxVGPR, const MCSymbol *MaxAGPR, const MCSymbol *MaxSGPR,
-    const MCSymbol *MaxNamedBarrier) {
+    const MCSymbol *MaxNonChainVGPR, const MCSymbol *MaxNamedBarrier) {
 #define PRINT_RES_INFO(ARG)                                                    \
   OS << "\t.set ";                                                             \
   ARG->print(OS, &getContext().getAsmInfo());                                  \
@@ -329,6 +329,7 @@ void AMDGPUTargetAsmStreamer::EmitMCResourceMaximums(
   PRINT_RES_INFO(MaxVGPR);
   PRINT_RES_INFO(MaxAGPR);
   PRINT_RES_INFO(MaxSGPR);
+  PRINT_RES_INFO(MaxNonChainVGPR);
   PRINT_RES_INFO(MaxNamedBarrier);
 #undef PRINT_RES_INFO
 }
diff --git a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h
index ca1fe3ccf3da1..cc891cd4196fa 100644
--- a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h
+++ b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h
@@ -94,6 +94,7 @@ class AMDGPUTargetStreamer : public MCTargetStreamer {
   virtual void EmitMCResourceMaximums(const MCSymbol *MaxVGPR,
                                       const MCSymbol *MaxAGPR,
                                       const MCSymbol *MaxSGPR,
+                                      const MCSymbol *MaxNonChainVGPR,
                                       const MCSymbol *MaxNamedBarrier) {};
 
   /// \returns True on success, false on failure.
@@ -177,6 +178,7 @@ class AMDGPUTargetAsmStreamer final : public AMDGPUTargetStreamer {
 
   void EmitMCResourceMaximums(const MCSymbol *MaxVGPR, const MCSymbol *MaxAGPR,
                               const MCSymbol *MaxSGPR,
+                              const MCSymbol *MaxNonChainVGPR,
                               const MCSymbol *MaxNamedBarrier) override;
 
   /// \returns True on success, false on failure.
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll
new file mode 100644
index 0000000000000..b41c6585c03e3
--- /dev/null
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll
@@ -0,0 +1,47 @@
+; RUN: llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 < %s | FileCheck %s
+
+; CHECK:  .set .Lgfx_func_a.num_vgpr, 40
+; CHECK:  .set .Lgfx_func_b.num_vgpr, 80
+; CHECK:  .set .Lfunc_with_indirect_call.num_vgpr, max(11, amdgpu.max_num_non_chain_vgpr, .Lgfx_func_a.num_vgpr)
+; CHECK:  .set .Lfunc_direct_only.num_vgpr, max(11, .Lgfx_func_a.num_vgpr)
+; CHECK:  .set .Lfunc_chain_only.num_vgpr, 11
+; CHECK:  .set amdgpu.max_num_vgpr, 80
+; CHECK:  .set amdgpu.max_num_non_chain_vgpr, 80
+
+define amdgpu_gfx void @gfx_func_a() #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39}"()
+  ret void
+}
+
+define amdgpu_gfx void @gfx_func_b() #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39},~{v40},~{v41},~{v42},~{v43},~{v44},~{v45},~{v46},~{v47},~{v48},~{v49},~{v50},~{v51},~{v52},~{v53},~{v54},~{v55},~{v56},~{v57},~{v58},~{v59},~{v60},~{v61},~{v62},~{v63},~{v64},~{v65},~{v66},~{v67},~{v68},~{v69},~{v70},~{v71},~{v72},~{v73},~{v74},~{v75},~{v76},~{v77},~{v78},~{v79}"()
+  ret void
+}
+
+define amdgpu_cs_chain void @func_with_indirect_call(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2}"()
+  call amdgpu_gfx void @gfx_func_a()
+  %fptr_gfx = load ptr, ptr inttoptr(i64 8 to ptr)
+  call amdgpu_gfx void %fptr_gfx()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @func_chain_only)
+  unreachable
+}
+
+define amdgpu_cs_chain void @func_direct_only(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3}"()
+  call amdgpu_gfx void @gfx_func_a()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @func_chain_only)
+  unreachable
+}
+
+define amdgpu_cs_chain void @func_chain_only(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4}"()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @func_chain_only)
+  unreachable
+}
+
+declare void @llvm.amdgcn.cs.chain.v3i32(ptr, i32, <3 x i32>, <3 x i32>, i32 immarg, ...)
+attributes #0 = { "amdgpu-dynamic-vgpr-block-size"="16" }
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
index 2a920bbe01449..1e0c53a47a61a 100644
--- a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
@@ -2,29 +2,31 @@
 ; RUN: sed 's/"amdgpu-dynamic-vgpr-block-size"="16"/"amdgpu-dynamic-vgpr-block-size"="0"/' %s \
 ; RUN:   | llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 | FileCheck -check-prefix=NODVGPR %s
 
-; DVGPR:  .set gfx_func_a.num_vgpr, 40
-; DVGPR:  .set gfx_func_b2.num_vgpr, 80
-; DVGPR:  .set gfx_func_b.num_vgpr, max(61, gfx_func_b2.num_vgpr)
-; DVGPR:  .set amdgpu_cs_main.num_vgpr, max(42, gfx_func_a.num_vgpr)
-; DVGPR:  .set func.0.num_vgpr, 11
-; DVGPR:  .set func.1.num_vgpr, max(11, gfx_func_a.num_vgpr, gfx_func_b.num_vgpr)
-; DVGPR:  .set func.2.num_vgpr, max(11, gfx_func_a.num_vgpr)
-; DVGPR:  .set func.3.num_vgpr, max(11, gfx_func_b.num_vgpr)
-; DVGPR:  .set retry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; DVGPR:  .set first_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; DVGPR:  .set .Lgfx_func_a.num_vgpr, 40
+; DVGPR:  .set .Lgfx_func_b2.num_vgpr, 80
+; DVGPR:  .set .Lgfx_func_b.num_vgpr, max(61, .Lgfx_func_b2.num_vgpr)
+; DVGPR:  .set .Lamdgpu_cs_main.num_vgpr, max(42, .Lgfx_func_a.num_vgpr)
+; DVGPR:  .set .Lfunc.0.num_vgpr, 11
+; DVGPR:  .set .Lfunc.1.num_vgpr, max(11, .Lgfx_func_a.num_vgpr, .Lgfx_func_b.num_vgpr)
+; DVGPR:  .set .Lfunc.2.num_vgpr, max(11, .Lgfx_func_a.num_vgpr)
+; DVGPR:  .set .Lfunc.3.num_vgpr, max(11, .Lgfx_func_b.num_vgpr)
+; DVGPR:  .set .Lretry_vgpr_alloc.num_vgpr, 11
+; DVGPR:  .set .Lfirst_retry_wrapper.num_vgpr, 11
 ; DVGPR:  .set amdgpu.max_num_vgpr, 80
+; DVGPR:  .set amdgpu.max_num_non_chain_vgpr, 80
 
-; NODVGPR:  .set gfx_func_a.num_vgpr, 40
-; NODVGPR:  .set gfx_func_b2.num_vgpr, 80
-; NODVGPR:  .set gfx_func_b.num_vgpr, max(61, gfx_func_b2.num_vgpr)
-; NODVGPR:  .set amdgpu_cs_main.num_vgpr, max(42, amdgpu.max_num_vgpr)
-; NODVGPR:  .set func.0.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR:  .set func.1.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR:  .set func.2.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR:  .set func.3.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR:  .set retry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR:  .set first_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lgfx_func_a.num_vgpr, 40
+; NODVGPR:  .set .Lgfx_func_b2.num_vgpr, 80
+; NODVGPR:  .set .Lgfx_func_b.num_vgpr, max(61, .Lgfx_func_b2.num_vgpr)
+; NODVGPR:  .set .Lamdgpu_cs_main.num_vgpr, max(42, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.0.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.1.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.2.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.3.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lretry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfirst_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
 ; NODVGPR:  .set amdgpu.max_num_vgpr, 80
+; NODVGPR:  .set amdgpu.max_num_non_chain_vgpr, 0
 
 ; DVGPR:  - .hardware_stages:
 ; DVGPR:        .vgpr_count: 0x2a

>From 143424c3296b297600b3264f9ae299b81eb1c45c Mon Sep 17 00:00:00 2001
From: Mirko Brkusanin <Mirko.Brkusanin at amd.com>
Date: Tue, 26 May 2026 14:27:08 +0200
Subject: [PATCH 4/8] simplify calc of max; address comments; add const for
 MaxDynamicVGPRBlocks

---
 llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp   |  2 +-
 .../Target/AMDGPU/AMDGPUMCResourceInfo.cpp    | 35 ++++++-------------
 .../Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp    |  8 +++--
 llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h |  3 ++
 .../dvgpr-vgpr-count-propagation-indirect.ll  | 26 +++++++++-----
 .../AMDGPU/dvgpr-vgpr-count-propagation.ll    |  2 --
 6 files changed, 37 insertions(+), 39 deletions(-)

diff --git a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
index 1ab786b051f7e..8a8ea95709dbe 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
@@ -1144,7 +1144,7 @@ void AMDGPUAsmPrinter::emitDVgprSymbol(MachineFunction &MF) {
       unsigned NumBlocks =
           divideCeil(std::max(unsigned(NumVGPRs.getConstant()), 1U), BlockSize);
 
-      if (NumBlocks > 8) {
+      if (NumBlocks > AMDGPU::IsaInfo::MaxDynamicVGPRBlocks) {
         OutContext.reportError(
             {}, "too many DVGPR blocks for _dvgpr$ symbol for '" +
                     Twine(CurrentFnSym->getName()) + "'");
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
index 062f3b8eaed21..a4e4cd4dcc79f 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
@@ -264,13 +264,13 @@ void MCResourceInfo::gatherResourceInfo(
   MCSymbol *MaxNamedBarrierSym = getMaxNamedBarrierSymbol(OutContext);
 
   CallingConv::ID CC = MF.getFunction().getCallingConv();
-  bool IsDVGPRChain = CC == CallingConv::AMDGPU_CS_Chain ||
-                      CC == CallingConv::AMDGPU_CS_ChainPreserve;
+  bool IsChainCC = AMDGPU::isChainCC(CC);
   bool IsDynamicVGPREnabled =
       MF.getInfo<SIMachineFunctionInfo>()->isDynamicVGPREnabled();
 
-  if (!AMDGPU::isEntryFunctionCC(MF.getFunction().getCallingConv())) {
-    addMaxVGPRCandidate(FRI.NumVGPR);
+  if (!AMDGPU::isEntryFunctionCC(CC)) {
+    if (!IsDynamicVGPREnabled || !IsChainCC)
+      addMaxVGPRCandidate(FRI.NumVGPR);
     addMaxAGPRCandidate(FRI.NumAGPR);
     addMaxSGPRCandidate(FRI.NumExplicitSGPR);
     if (IsDynamicVGPREnabled && !IsDVGPRChain) {
@@ -339,28 +339,15 @@ void MCResourceInfo::gatherResourceInfo(
   // When DynamicVGPR is enabled, chain functions should not propagate VGPR
   // counts from other chain callees since each chain function can have its own
   // VGPR allocation, but should still propagate from non-chain callees.
-  if (IsDynamicVGPREnabled && (IsDVGPRChain || CC == CallingConv::AMDGPU_CS)) {
+  if (IsDynamicVGPREnabled && (IsChainCC || CC == CallingConv::AMDGPU_CS)) {
     if (FRI.HasNonChainIndirectCall) {
-      // Has indirect calls to non-chain functions. Use max of direct non-chain
-      // callees and module-wide non-chain maximum.
-      SmallVector<const MCExpr *, 8> ArgExprs;
-      ArgExprs.push_back(MCConstantExpr::create(FRI.NumVGPR, OutContext));
-      ArgExprs.push_back(
-          MCSymbolRefExpr::create(MaxNonChainVGPRSym, OutContext));
-
-      SmallPtrSet<const Function *, 8> Seen;
-      for (const Function *Callee : FRI.Callees) {
-        if (AMDGPU::isChainCC(Callee->getCallingConv()))
-          continue;
-        if (!Seen.insert(Callee).second || Callee->isDeclaration())
-          continue;
-        MCSymbol *CalleeFnSym = TM.getSymbol(&Callee->getFunction());
-        MCSymbol *CalleeValSym =
-            getSymbol(CalleeFnSym->getName(), RIK_NumVGPR, OutContext);
-        ArgExprs.push_back(MCSymbolRefExpr::create(CalleeValSym, OutContext));
-      }
+      // Has indirect calls to non-chain functions. Use max of local count and
+      // module-wide non-chain maximum.
       MCSymbol *Sym = getSymbol(FnSym->getName(), RIK_NumVGPR, OutContext);
-      Sym->setVariableValue(AMDGPUMCExpr::createMax(ArgExprs, OutContext));
+      Sym->setVariableValue(AMDGPUMCExpr::createMax(
+          {MCConstantExpr::create(FRI.NumVGPR, OutContext),
+           MCSymbolRefExpr::create(MaxVGPRSym, OutContext)},
+          OutContext));
       SetMaxReg(MaxAGPRSym, FRI.NumAGPR, RIK_NumAGPR);
     } else {
       // No indirect calls to non-chain functions. Propagate from direct callees
diff --git a/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp b/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
index 9954c14a0851d..33df51e8a7e07 100644
--- a/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
@@ -1473,9 +1473,11 @@ unsigned getAddressableNumVGPRs(const MCSubtargetInfo &STI,
   if (Features.test(FeatureGFX90AInsts))
     return 512;
 
-  if (DynamicVGPRBlockSize != 0)
-    // On GFX12 we can allocate at most 8 blocks of VGPRs.
-    return 8 * getVGPRAllocGranule(STI, DynamicVGPRBlockSize);
+  if (DynamicVGPRBlockSize != 0) {
+    // On GFX12 we can allocate at most MaxDynamicVGPRBlocks blocks of VGPRs.
+    return MaxDynamicVGPRBlocks *
+           getVGPRAllocGranule(STI, DynamicVGPRBlockSize);
+  }
   return getAddressableNumArchVGPRs(STI);
 }
 
diff --git a/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h b/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h
index d761da4d0d804..1f7084c8d25ae 100644
--- a/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h
+++ b/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h
@@ -342,6 +342,9 @@ unsigned getArchVGPRAllocGranule();
 /// \returns Total number of VGPRs for given subtarget \p STI.
 unsigned getTotalNumVGPRs(const MCSubtargetInfo &STI);
 
+/// Maximum number of VGPR blocks that can be allocated in dynamic VGPR mode.
+static constexpr unsigned MaxDynamicVGPRBlocks = 8;
+
 /// \returns Addressable number of architectural VGPRs for a given subtarget \p
 /// STI.
 unsigned getAddressableNumArchVGPRs(const MCSubtargetInfo &STI);
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll
index b41c6585c03e3..f9efe4c130fd2 100644
--- a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll
@@ -1,12 +1,20 @@
-; RUN: llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 < %s | FileCheck %s
-
-; CHECK:  .set .Lgfx_func_a.num_vgpr, 40
-; CHECK:  .set .Lgfx_func_b.num_vgpr, 80
-; CHECK:  .set .Lfunc_with_indirect_call.num_vgpr, max(11, amdgpu.max_num_non_chain_vgpr, .Lgfx_func_a.num_vgpr)
-; CHECK:  .set .Lfunc_direct_only.num_vgpr, max(11, .Lgfx_func_a.num_vgpr)
-; CHECK:  .set .Lfunc_chain_only.num_vgpr, 11
-; CHECK:  .set amdgpu.max_num_vgpr, 80
-; CHECK:  .set amdgpu.max_num_non_chain_vgpr, 80
+; RUN: llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 < %s | FileCheck -check-prefix=DVGPR %s
+; RUN: sed 's/"amdgpu-dynamic-vgpr-block-size"="16"/"amdgpu-dynamic-vgpr-block-size"="0"/' %s \
+; RUN:   | llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 | FileCheck -check-prefix=NODVGPR %s
+
+; DVGPR:  .set .Lgfx_func_a.num_vgpr, 40
+; DVGPR:  .set .Lgfx_func_b.num_vgpr, 80
+; DVGPR:  .set .Lfunc_with_indirect_call.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; DVGPR:  .set .Lfunc_direct_only.num_vgpr, max(11, .Lgfx_func_a.num_vgpr)
+; DVGPR:  .set .Lfunc_chain_only.num_vgpr, 11
+; DVGPR:  .set amdgpu.max_num_vgpr, 80
+
+; NODVGPR:  .set .Lgfx_func_a.num_vgpr, 40
+; NODVGPR:  .set .Lgfx_func_b.num_vgpr, 80
+; NODVGPR:  .set .Lfunc_with_indirect_call.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc_direct_only.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc_chain_only.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set amdgpu.max_num_vgpr, 80
 
 define amdgpu_gfx void @gfx_func_a() #0 {
   call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39}"()
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
index 1e0c53a47a61a..469b9c743473e 100644
--- a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
@@ -13,7 +13,6 @@
 ; DVGPR:  .set .Lretry_vgpr_alloc.num_vgpr, 11
 ; DVGPR:  .set .Lfirst_retry_wrapper.num_vgpr, 11
 ; DVGPR:  .set amdgpu.max_num_vgpr, 80
-; DVGPR:  .set amdgpu.max_num_non_chain_vgpr, 80
 
 ; NODVGPR:  .set .Lgfx_func_a.num_vgpr, 40
 ; NODVGPR:  .set .Lgfx_func_b2.num_vgpr, 80
@@ -26,7 +25,6 @@
 ; NODVGPR:  .set .Lretry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
 ; NODVGPR:  .set .Lfirst_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
 ; NODVGPR:  .set amdgpu.max_num_vgpr, 80
-; NODVGPR:  .set amdgpu.max_num_non_chain_vgpr, 0
 
 ; DVGPR:  - .hardware_stages:
 ; DVGPR:        .vgpr_count: 0x2a

>From 2020954d4de0a710a4c46a32f4d8d5065d00de30 Mon Sep 17 00:00:00 2001
From: Mirko Brkusanin <Mirko.Brkusanin at amd.com>
Date: Tue, 26 May 2026 14:27:31 +0200
Subject: [PATCH 5/8] remove MaxNonChainVGPRSym

---
 llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp            |  3 +--
 llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp        | 10 ----------
 llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h          |  5 -----
 .../AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp       |  3 +--
 .../Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h  |  2 --
 5 files changed, 2 insertions(+), 21 deletions(-)

diff --git a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
index 8a8ea95709dbe..e76cb486edb2d 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
@@ -731,8 +731,7 @@ bool AMDGPUAsmPrinter::doFinalization(Module &M) {
   OutStreamer->switchSection(MaxGPRSection);
   getTargetStreamer()->EmitMCResourceMaximums(
       RI.getMaxVGPRSymbol(OutContext), RI.getMaxAGPRSymbol(OutContext),
-      RI.getMaxSGPRSymbol(OutContext), RI.getMaxNonChainVGPRSymbol(OutContext),
-      RI.getMaxNamedBarrierSymbol(OutContext));
+      RI.getMaxSGPRSymbol(OutContext), RI.getMaxNamedBarrierSymbol(OutContext));
   OutStreamer->popSection();
 
   // In the object-linking pipeline per-function resource MCExprs reference
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
index a4e4cd4dcc79f..1731b0463a099 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
@@ -68,7 +68,6 @@ void MCResourceInfo::assignMaxRegs(MCContext &OutContext) {
   MCSymbol *MaxVGPRSym = getMaxVGPRSymbol(OutContext);
   MCSymbol *MaxAGPRSym = getMaxAGPRSymbol(OutContext);
   MCSymbol *MaxSGPRSym = getMaxSGPRSymbol(OutContext);
-  MCSymbol *MaxNonChainVGPRSym = getMaxNonChainVGPRSymbol(OutContext);
   MCSymbol *MaxNamedBarrierSym = getMaxNamedBarrierSymbol(OutContext);
 
   auto assignMaxRegSym = [&OutContext](MCSymbol *Sym, int32_t RegCount) {
@@ -79,7 +78,6 @@ void MCResourceInfo::assignMaxRegs(MCContext &OutContext) {
   assignMaxRegSym(MaxVGPRSym, MaxVGPR);
   assignMaxRegSym(MaxAGPRSym, MaxAGPR);
   assignMaxRegSym(MaxSGPRSym, MaxSGPR);
-  assignMaxRegSym(MaxNonChainVGPRSym, MaxNonChainVGPR);
   assignMaxRegSym(MaxNamedBarrierSym, MaxNamedBarrier);
 }
 
@@ -103,10 +101,6 @@ MCSymbol *MCResourceInfo::getMaxSGPRSymbol(MCContext &OutContext) {
   return OutContext.getOrCreateSymbol("amdgpu.max_num_sgpr");
 }
 
-MCSymbol *MCResourceInfo::getMaxNonChainVGPRSymbol(MCContext &OutContext) {
-  return OutContext.getOrCreateSymbol("amdgpu.max_num_non_chain_vgpr");
-}
-
 MCSymbol *MCResourceInfo::getMaxNamedBarrierSymbol(MCContext &OutContext) {
   return OutContext.getOrCreateSymbol("amdgpu.max_num_named_barrier");
 }
@@ -260,7 +254,6 @@ void MCResourceInfo::gatherResourceInfo(
   MCSymbol *MaxVGPRSym = getMaxVGPRSymbol(OutContext);
   MCSymbol *MaxAGPRSym = getMaxAGPRSymbol(OutContext);
   MCSymbol *MaxSGPRSym = getMaxSGPRSymbol(OutContext);
-  MCSymbol *MaxNonChainVGPRSym = getMaxNonChainVGPRSymbol(OutContext);
   MCSymbol *MaxNamedBarrierSym = getMaxNamedBarrierSymbol(OutContext);
 
   CallingConv::ID CC = MF.getFunction().getCallingConv();
@@ -273,9 +266,6 @@ void MCResourceInfo::gatherResourceInfo(
       addMaxVGPRCandidate(FRI.NumVGPR);
     addMaxAGPRCandidate(FRI.NumAGPR);
     addMaxSGPRCandidate(FRI.NumExplicitSGPR);
-    if (IsDynamicVGPREnabled && !IsDVGPRChain) {
-      addMaxNonChainVGPRCandidate(FRI.NumVGPR);
-    }
     addMaxNamedBarrierCandidate(FRI.NumNamedBarrier);
   }
 
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h
index bdd71a660fbd2..3cb063ef8e962 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h
@@ -44,7 +44,6 @@ class MCResourceInfo {
   int32_t MaxVGPR = 0;
   int32_t MaxAGPR = 0;
   int32_t MaxSGPR = 0;
-  int32_t MaxNonChainVGPR = 0;
   int32_t MaxNamedBarrier = 0;
 
   // Whether the MCResourceInfo has been finalized through finalize(MCContext
@@ -78,9 +77,6 @@ class MCResourceInfo {
   void addMaxSGPRCandidate(int32_t candidate) {
     MaxSGPR = std::max(MaxSGPR, candidate);
   }
-  void addMaxNonChainVGPRCandidate(int32_t candidate) {
-    MaxNonChainVGPR = std::max(MaxNonChainVGPR, candidate);
-  }
   void addMaxNamedBarrierCandidate(int32_t candidate) {
     MaxNamedBarrier = std::max(MaxNamedBarrier, candidate);
   }
@@ -99,7 +95,6 @@ class MCResourceInfo {
   MCSymbol *getMaxVGPRSymbol(MCContext &OutContext);
   MCSymbol *getMaxAGPRSymbol(MCContext &OutContext);
   MCSymbol *getMaxSGPRSymbol(MCContext &OutContext);
-  MCSymbol *getMaxNonChainVGPRSymbol(MCContext &OutContext);
   MCSymbol *getMaxNamedBarrierSymbol(MCContext &OutContext);
 
   /// AMDGPUResourceUsageAnalysis gathers resource usage on a per-function
diff --git a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp
index 62d0b3c34a67c..e9d7cc3f1476d 100644
--- a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp
+++ b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp
@@ -318,7 +318,7 @@ void AMDGPUTargetAsmStreamer::EmitMCResourceInfo(
 
 void AMDGPUTargetAsmStreamer::EmitMCResourceMaximums(
     const MCSymbol *MaxVGPR, const MCSymbol *MaxAGPR, const MCSymbol *MaxSGPR,
-    const MCSymbol *MaxNonChainVGPR, const MCSymbol *MaxNamedBarrier) {
+    const MCSymbol *MaxNamedBarrier) {
 #define PRINT_RES_INFO(ARG)                                                    \
   OS << "\t.set ";                                                             \
   ARG->print(OS, &getContext().getAsmInfo());                                  \
@@ -329,7 +329,6 @@ void AMDGPUTargetAsmStreamer::EmitMCResourceMaximums(
   PRINT_RES_INFO(MaxVGPR);
   PRINT_RES_INFO(MaxAGPR);
   PRINT_RES_INFO(MaxSGPR);
-  PRINT_RES_INFO(MaxNonChainVGPR);
   PRINT_RES_INFO(MaxNamedBarrier);
 #undef PRINT_RES_INFO
 }
diff --git a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h
index cc891cd4196fa..ca1fe3ccf3da1 100644
--- a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h
+++ b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h
@@ -94,7 +94,6 @@ class AMDGPUTargetStreamer : public MCTargetStreamer {
   virtual void EmitMCResourceMaximums(const MCSymbol *MaxVGPR,
                                       const MCSymbol *MaxAGPR,
                                       const MCSymbol *MaxSGPR,
-                                      const MCSymbol *MaxNonChainVGPR,
                                       const MCSymbol *MaxNamedBarrier) {};
 
   /// \returns True on success, false on failure.
@@ -178,7 +177,6 @@ class AMDGPUTargetAsmStreamer final : public AMDGPUTargetStreamer {
 
   void EmitMCResourceMaximums(const MCSymbol *MaxVGPR, const MCSymbol *MaxAGPR,
                               const MCSymbol *MaxSGPR,
-                              const MCSymbol *MaxNonChainVGPR,
                               const MCSymbol *MaxNamedBarrier) override;
 
   /// \returns True on success, false on failure.

>From f0c3293bb67201e71c2b763cc9663e031e4e40bb Mon Sep 17 00:00:00 2001
From: Mirko Brkusanin <Mirko.Brkusanin at amd.com>
Date: Tue, 26 May 2026 16:07:09 +0200
Subject: [PATCH 6/8] update error message

---
 llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp                  | 5 ++++-
 .../CodeGen/AMDGPU/dvgpr_sym_fail_too_many_block_size_16.ll  | 2 +-
 .../AMDGPU/dvgpr_sym_fail_too_many_block_size_16_anon.ll     | 2 +-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
index e76cb486edb2d..d32cdb6d960fc 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
@@ -1145,7 +1145,10 @@ void AMDGPUAsmPrinter::emitDVgprSymbol(MachineFunction &MF) {
 
       if (NumBlocks > AMDGPU::IsaInfo::MaxDynamicVGPRBlocks) {
         OutContext.reportError(
-            {}, "too many DVGPR blocks for _dvgpr$ symbol for '" +
+            {}, "DVGPR block count " + Twine(NumBlocks) +
+                    " exceeds maximum of " +
+                    Twine(AMDGPU::IsaInfo::MaxDynamicVGPRBlocks) +
+                    " for __dvgpr$ symbol for '" +
                     Twine(CurrentFnSym->getName()) + "'");
         return;
       }
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr_sym_fail_too_many_block_size_16.ll b/llvm/test/CodeGen/AMDGPU/dvgpr_sym_fail_too_many_block_size_16.ll
index 4bd173c6eb885..76f6a56d22535 100644
--- a/llvm/test/CodeGen/AMDGPU/dvgpr_sym_fail_too_many_block_size_16.ll
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr_sym_fail_too_many_block_size_16.ll
@@ -5,7 +5,7 @@
 ; Function with 129 VGPRs, which is too many with a block size of 16.
 ;
 ; ERR-DAG: .set .Lfunc129.num_vgpr, 129
-; ERR-DAG: too many DVGPR blocks for _dvgpr$ symbol for 'func129'
+; ERR-DAG: DVGPR block count 9 exceeds maximum of 8 for __dvgpr$ symbol for 'func129'
 ;
 define amdgpu_cs_chain void @func129(<121 x float> %arg) #0 {
   tail call void @func129(<121 x float> %arg)
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr_sym_fail_too_many_block_size_16_anon.ll b/llvm/test/CodeGen/AMDGPU/dvgpr_sym_fail_too_many_block_size_16_anon.ll
index 773fec2e68287..eb2eba22e7325 100644
--- a/llvm/test/CodeGen/AMDGPU/dvgpr_sym_fail_too_many_block_size_16_anon.ll
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr_sym_fail_too_many_block_size_16_anon.ll
@@ -5,7 +5,7 @@
 ; Anonymous function with 129 VGPRs, which is too many with a block size of 16.
 ;
 ; ERR-DAG: .set .L__unnamed_1.num_vgpr, 129
-; ERR-DAG: too many DVGPR blocks for _dvgpr$ symbol for '__unnamed_1'
+; ERR-DAG: DVGPR block count 9 exceeds maximum of 8 for __dvgpr$ symbol for '__unnamed_1'
 ;
 define amdgpu_cs_chain void @0(<121 x float> %arg) #0 {
   tail call void @0(<121 x float> %arg)

>From 8428888c006eda8ca6ed8829fb58e382113c3e04 Mon Sep 17 00:00:00 2001
From: Mirko Brkusanin <Mirko.Brkusanin at amd.com>
Date: Fri, 29 May 2026 14:44:41 +0200
Subject: [PATCH 7/8] more tests

---
 ...gpr-vgpr-count-propagation-direct-chain.ll | 120 ++++++++++++++++++
 .../AMDGPU/dvgpr-vgpr-count-propagation.ll    |  52 +++++---
 2 files changed, 153 insertions(+), 19 deletions(-)
 create mode 100644 llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-direct-chain.ll

diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-direct-chain.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-direct-chain.ll
new file mode 100644
index 0000000000000..82d7772f57b70
--- /dev/null
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-direct-chain.ll
@@ -0,0 +1,120 @@
+; RUN: llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 < %s | FileCheck -check-prefix=DVGPR %s
+; RUN: sed 's/"amdgpu-dynamic-vgpr-block-size"="16"/"amdgpu-dynamic-vgpr-block-size"="0"/' %s \
+; RUN:   | llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 | FileCheck -check-prefix=NODVGPR %s
+
+; DVGPR:  .set .Lgfx_func_a.num_vgpr, 40
+; DVGPR:  .set .Lamdgpu_cs_main.num_vgpr, max(42, .Lgfx_func_a.num_vgpr)
+; DVGPR:  .set .Lfunc.0.num_vgpr, max(11, .Lgfx_func_a.num_vgpr)
+; DVGPR:  .set .Lfunc.1.num_vgpr, 82
+; DVGPR:  .set .Lfunc.2.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; DVGPR:  .set .Lfunc.3.num_vgpr, 11
+; DVGPR:  .set .Lfunc.4.num_vgpr, max(82, amdgpu.max_num_vgpr)
+; DVGPR:  .set .Lretry_vgpr_alloc.num_vgpr, 11
+; DVGPR:  .set .Lfirst_retry_wrapper.num_vgpr, 11
+; DVGPR:  .set amdgpu.max_num_vgpr, 82
+
+; NODVGPR:  .set .Lgfx_func_a.num_vgpr, 40
+; NODVGPR:  .set .Lamdgpu_cs_main.num_vgpr, max(42, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.0.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.1.num_vgpr, max(82, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.2.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.3.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.4.num_vgpr, max(82, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lretry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfirst_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set amdgpu.max_num_vgpr, 82
+
+; DVGPR:  - .hardware_stages:
+; DVGPR:        .vgpr_count: 0x2a
+; DVGPR:    .shader_functions:
+; DVGPR:      func.0:
+; DVGPR:        .vgpr_count: 0x28
+; DVGPR:      func.1:
+; DVGPR:        .vgpr_count: 0x52
+; DVGPR:      func.2:
+; DVGPR:        .vgpr_count: 0x52
+; DVGPR:      func.3:
+; DVGPR:        .vgpr_count: 0xb
+; DVGPR:      func.4:
+; DVGPR:        .vgpr_count: 0x52
+; DVGPR:      gfx_func_a:
+; DVGPR:        .vgpr_count: 0x28
+
+; NODVGPR:  - .hardware_stages:
+; NODVGPR:        .vgpr_count: 0x52
+; NODVGPR:    .shader_functions:
+; NODVGPR:      func.0:
+; NODVGPR:        .vgpr_count: 0x52
+; NODVGPR:      func.1:
+; NODVGPR:        .vgpr_count: 0x52
+; NODVGPR:      func.2:
+; NODVGPR:        .vgpr_count: 0x52
+; NODVGPR:      func.3:
+; NODVGPR:        .vgpr_count: 0x52
+; NODVGPR:      func.4:
+; NODVGPR:        .vgpr_count: 0x52
+; NODVGPR:      gfx_func_a:
+; NODVGPR:        .vgpr_count: 0x28
+
+define amdgpu_gfx void @gfx_func_a() #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39}"()
+  ret void
+}
+
+define amdgpu_cs void @amdgpu_cs_main(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call amdgpu_gfx void @gfx_func_a()
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @func.1)
+  unreachable
+}
+
+define amdgpu_cs_chain void @func.0(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  call amdgpu_gfx void @gfx_func_a()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
+  unreachable
+}
+
+; Has direct chain call to func.2 instead of using first_retry_wrapper
+define amdgpu_cs_chain void @func.1(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39},~{v40},~{v41},~{v42},~{v43},~{v44},~{v45},~{v46},~{v47},~{v48},~{v49},~{v50},~{v51},~{v52},~{v53},~{v54},~{v55},~{v56},~{v57},~{v58},~{v59},~{v60},~{v61},~{v62},~{v63},~{v64},~{v65},~{v66},~{v67},~{v68},~{v69},~{v70},~{v71},~{v72},~{v73},~{v74},~{v75},~{v76},~{v77},~{v78},~{v79}"()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @func.2)
+  unreachable
+}
+
+; amdgpu-dynamic-vgpr-block-size = 0
+define amdgpu_cs_chain void @func.2(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #1 {
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
+  unreachable
+}
+
+; Has direct chain call to func.4 instead of using first_retry_wrapper
+define amdgpu_cs_chain void @func.3(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @func.4)
+  unreachable
+}
+
+; amdgpu-dynamic-vgpr-block-size = 0
+define amdgpu_cs_chain void @func.4(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #1 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39},~{v40},~{v41},~{v42},~{v43},~{v44},~{v45},~{v46},~{v47},~{v48},~{v49},~{v50},~{v51},~{v52},~{v53},~{v54},~{v55},~{v56},~{v57},~{v58},~{v59},~{v60},~{v61},~{v62},~{v63},~{v64},~{v65},~{v66},~{v67},~{v68},~{v69},~{v70},~{v71},~{v72},~{v73},~{v74},~{v75},~{v76},~{v77},~{v78},~{v79}"()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
+  unreachable
+}
+
+define amdgpu_cs_chain_preserve void @retry_vgpr_alloc(<3 x i32> inreg %sgprs) #0 {
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @retry_vgpr_alloc)
+  unreachable
+}
+
+define amdgpu_cs_chain_preserve void @first_retry_wrapper(<3 x i32> inreg %sgprs) #0 {
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg @retry_vgpr_alloc, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @retry_vgpr_alloc)
+  unreachable
+}
+
+attributes #0 = { "amdgpu-dynamic-vgpr-block-size"="16" }
+attributes #1 = { "amdgpu-dynamic-vgpr-block-size"="0" }
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
index 469b9c743473e..47f0f0488bb22 100644
--- a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
@@ -6,10 +6,11 @@
 ; DVGPR:  .set .Lgfx_func_b2.num_vgpr, 80
 ; DVGPR:  .set .Lgfx_func_b.num_vgpr, max(61, .Lgfx_func_b2.num_vgpr)
 ; DVGPR:  .set .Lamdgpu_cs_main.num_vgpr, max(42, .Lgfx_func_a.num_vgpr)
-; DVGPR:  .set .Lfunc.0.num_vgpr, 11
-; DVGPR:  .set .Lfunc.1.num_vgpr, max(11, .Lgfx_func_a.num_vgpr, .Lgfx_func_b.num_vgpr)
-; DVGPR:  .set .Lfunc.2.num_vgpr, max(11, .Lgfx_func_a.num_vgpr)
-; DVGPR:  .set .Lfunc.3.num_vgpr, max(11, .Lgfx_func_b.num_vgpr)
+; DVGPR:  .set .Lfunc.0.num_vgpr, 13
+; DVGPR:  .set .Lfunc.1.num_vgpr, max(14, .Lgfx_func_a.num_vgpr, .Lgfx_func_b.num_vgpr)
+; DVGPR:  .set .Lfunc.2.num_vgpr, max(16, .Lgfx_func_a.num_vgpr)
+; DVGPR:  .set .Lfunc.3.num_vgpr, max(15, .Lgfx_func_b.num_vgpr)
+; DVGPR:  .set .Lfunc.4.num_vgpr, max(100, .Lgfx_func_b.num_vgpr)
 ; DVGPR:  .set .Lretry_vgpr_alloc.num_vgpr, 11
 ; DVGPR:  .set .Lfirst_retry_wrapper.num_vgpr, 11
 ; DVGPR:  .set amdgpu.max_num_vgpr, 80
@@ -18,25 +19,28 @@
 ; NODVGPR:  .set .Lgfx_func_b2.num_vgpr, 80
 ; NODVGPR:  .set .Lgfx_func_b.num_vgpr, max(61, .Lgfx_func_b2.num_vgpr)
 ; NODVGPR:  .set .Lamdgpu_cs_main.num_vgpr, max(42, amdgpu.max_num_vgpr)
-; NODVGPR:  .set .Lfunc.0.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR:  .set .Lfunc.1.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR:  .set .Lfunc.2.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR:  .set .Lfunc.3.num_vgpr, max(11, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.0.num_vgpr, max(13, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.1.num_vgpr, max(14, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.2.num_vgpr, max(16, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.3.num_vgpr, max(15, amdgpu.max_num_vgpr)
+; NODVGPR:  .set .Lfunc.4.num_vgpr, max(100, amdgpu.max_num_vgpr)
 ; NODVGPR:  .set .Lretry_vgpr_alloc.num_vgpr, max(11, amdgpu.max_num_vgpr)
 ; NODVGPR:  .set .Lfirst_retry_wrapper.num_vgpr, max(11, amdgpu.max_num_vgpr)
-; NODVGPR:  .set amdgpu.max_num_vgpr, 80
+; NODVGPR:  .set amdgpu.max_num_vgpr, 100
 
 ; DVGPR:  - .hardware_stages:
 ; DVGPR:        .vgpr_count: 0x2a
 ; DVGPR:    .shader_functions:
 ; DVGPR:      func.0:
-; DVGPR:        .vgpr_count: 0xb
+; DVGPR:        .vgpr_count: 0xd
 ; DVGPR:      func.1:
 ; DVGPR:        .vgpr_count: 0x50
 ; DVGPR:      func.2:
 ; DVGPR:        .vgpr_count: 0x28
 ; DVGPR:      func.3:
 ; DVGPR:        .vgpr_count: 0x50
+; DVGPR:      func.4:
+; DVGPR:        .vgpr_count: 0x64
 ; DVGPR:      gfx_func_a:
 ; DVGPR:        .vgpr_count: 0x28
 ; DVGPR:      gfx_func_b:
@@ -45,16 +49,18 @@
 ; DVGPR:        .vgpr_count: 0x50
 
 ; NODVGPR:  - .hardware_stages:
-; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:        .vgpr_count: 0x64
 ; NODVGPR:    .shader_functions:
 ; NODVGPR:      func.0:
-; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:        .vgpr_count: 0x64
 ; NODVGPR:      func.1:
-; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:        .vgpr_count: 0x64
 ; NODVGPR:      func.2:
-; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:        .vgpr_count: 0x64
 ; NODVGPR:      func.3:
-; NODVGPR:        .vgpr_count: 0x50
+; NODVGPR:        .vgpr_count: 0x64
+; NODVGPR:      func.4:
+; NODVGPR:        .vgpr_count: 0x64
 ; NODVGPR:      gfx_func_a:
 ; NODVGPR:        .vgpr_count: 0x28
 ; NODVGPR:      gfx_func_b:
@@ -86,14 +92,14 @@ define amdgpu_cs void @amdgpu_cs_main(<3 x i32> inreg %sgprs, <3 x i32> %vgprs)
 }
 
 define amdgpu_cs_chain void @func.0(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
-  call void asm sideeffect "", "~{v0},~{v1}"()
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10}"()
   %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
   call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
   unreachable
 }
 
 define amdgpu_cs_chain void @func.1(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
-  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3}"()
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13}"()
   call amdgpu_gfx void @gfx_func_a()
   call amdgpu_gfx void @gfx_func_b()
   %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
@@ -102,7 +108,7 @@ define amdgpu_cs_chain void @func.1(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0
 }
 
 define amdgpu_cs_chain void @func.2(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
-  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5}"()
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15}"()
   call amdgpu_gfx void @gfx_func_a()
   %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
   call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
@@ -110,7 +116,15 @@ define amdgpu_cs_chain void @func.2(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0
 }
 
 define amdgpu_cs_chain void @func.3(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
-  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7}"()
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14}"()
+  call amdgpu_gfx void @gfx_func_b()
+  %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
+  call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)
+  unreachable
+}
+
+define amdgpu_cs_chain void @func.4(<3 x i32> inreg %sgprs, <3 x i32> %vgprs) #0 {
+  call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{v32},~{v33},~{v34},~{v35},~{v36},~{v37},~{v38},~{v39},~{v40},~{v41},~{v42},~{v43},~{v44},~{v45},~{v46},~{v47},~{v48},~{v49},~{v50},~{v51},~{v52},~{v53},~{v54},~{v55},~{v56},~{v57},~{v58},~{v59},~{v60},~{v61},~{v62},~{v63},~{v64},~{v65},~{v66},~{v67},~{v68},~{v69},~{v70},~{v71},~{v72},~{v73},~{v74},~{v75},~{v76},~{v77},~{v78},~{v79},~{v80},~{v81},~{v82},~{v83},~{v84},~{v85},~{v86},~{v87},~{v88},~{v89},~{v90},~{v91},~{v92},~{v93},~{v94},~{v95},~{v96},~{v97},~{v98},~{v99}"()
   call amdgpu_gfx void @gfx_func_b()
   %fptr = load ptr, ptr inttoptr(i64 0 to ptr)
   call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr inreg %fptr, i32 inreg 0, <3 x i32> inreg %sgprs, <3 x i32> zeroinitializer, i32 1, i32 0, i32 -1, ptr @first_retry_wrapper)

>From ad4852b036abc43620b3b929bf1525800cf5ee37 Mon Sep 17 00:00:00 2001
From: Mirko Brkusanin <Mirko.Brkusanin at amd.com>
Date: Tue, 2 Jun 2026 14:42:01 +0200
Subject: [PATCH 8/8] test comments

---
 .../AMDGPU/dvgpr-vgpr-count-propagation-direct-chain.ll  | 8 ++++++++
 .../AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll      | 4 ++++
 llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll | 9 +++++++++
 3 files changed, 21 insertions(+)

diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-direct-chain.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-direct-chain.ll
index 82d7772f57b70..7b01eec2698c3 100644
--- a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-direct-chain.ll
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-direct-chain.ll
@@ -2,6 +2,14 @@
 ; RUN: sed 's/"amdgpu-dynamic-vgpr-block-size"="16"/"amdgpu-dynamic-vgpr-block-size"="0"/' %s \
 ; RUN:   | llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 | FileCheck -check-prefix=NODVGPR %s
 
+; Test a set of functions with mixed use of DVGPR (enabled or disabled). Also
+; test chain functions directly calling other chain functions without going
+; through `first_retry_wrapper` helper. A chain function will not propagate VGPR
+; counts to a directly called chain function, regardless of whether either has
+; DVGPRs enabled or disabled.
+
+; func.2 and func.4 have DVGPRs disabled
+
 ; DVGPR:  .set .Lgfx_func_a.num_vgpr, 40
 ; DVGPR:  .set .Lamdgpu_cs_main.num_vgpr, max(42, .Lgfx_func_a.num_vgpr)
 ; DVGPR:  .set .Lfunc.0.num_vgpr, max(11, .Lgfx_func_a.num_vgpr)
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll
index f9efe4c130fd2..f9cf887ac668b 100644
--- a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation-indirect.ll
@@ -2,6 +2,10 @@
 ; RUN: sed 's/"amdgpu-dynamic-vgpr-block-size"="16"/"amdgpu-dynamic-vgpr-block-size"="0"/' %s \
 ; RUN:   | llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 | FileCheck -check-prefix=NODVGPR %s
 
+; In DVGPR mode, chain functions that have indirect non-chain calls should have
+; their `num_vgpr` count set to the max of their local count and the module-wide
+; max VGPR count of all non-chain functions.
+
 ; DVGPR:  .set .Lgfx_func_a.num_vgpr, 40
 ; DVGPR:  .set .Lgfx_func_b.num_vgpr, 80
 ; DVGPR:  .set .Lfunc_with_indirect_call.num_vgpr, max(11, amdgpu.max_num_vgpr)
diff --git a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
index 47f0f0488bb22..7001e23f7002d 100644
--- a/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
+++ b/llvm/test/CodeGen/AMDGPU/dvgpr-vgpr-count-propagation.ll
@@ -2,6 +2,15 @@
 ; RUN: sed 's/"amdgpu-dynamic-vgpr-block-size"="16"/"amdgpu-dynamic-vgpr-block-size"="0"/' %s \
 ; RUN:   | llc -mtriple=amdgcn-amd-amdpal -mcpu=gfx1200 | FileCheck -check-prefix=NODVGPR %s
 
+; Chain calls are treated as indirect calls, but with dynamic VGPRs enabled each
+; function will get its own VGPR allocation. Chain functions that have no
+; indirect non-chain calls should have their num_vgpr count set to the max of
+; their local count and the counts of all direct callees.
+
+; With DVGPRs enabled "max_num_vgpr" represents the maximum VGPR count of all
+; non-chain functions. With DVGPRs disabled, it represents module-wide max VGPR
+; count.
+
 ; DVGPR:  .set .Lgfx_func_a.num_vgpr, 40
 ; DVGPR:  .set .Lgfx_func_b2.num_vgpr, 80
 ; DVGPR:  .set .Lgfx_func_b.num_vgpr, max(61, .Lgfx_func_b2.num_vgpr)



More information about the llvm-commits mailing list