[llvm-branch-commits] [llvm] AMDGPU: Include callees in backend_stack_size PAL metadata (PR #234522)
Diana Picus via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Nov 17 02:52:59 PST 2026
https://github.com/rovka updated https://github.com/llvm/llvm-project/pull/234522
>From 37d173dce3e1748a95a72b939796ba6ff36d94bc Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Tue, 20 Oct 2026 11:16:13 +0200
Subject: [PATCH 01/11] AMDGPU: Precommit test cases for PEI
---
.../test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll | 73 ++++++++++
.../dynamic-vgpr-reserve-stack-for-cwsr.ll | 132 ++++++++++++++++++
.../CodeGen/AMDGPU/pei-amdgpu-cs-chain.mir | 87 ++++++++++++
3 files changed, 292 insertions(+)
diff --git a/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll b/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll
index d1aa26cb217046..60a1a03ee356be 100644
--- a/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll
+++ b/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll
@@ -582,6 +582,79 @@ define amdgpu_cs void @cs_to_chain_nonuniform(<3 x i32> %a, <3 x i32> %b) #0 {
unreachable
}
+; FIXME: The SP points after the locals, but we should reset to 0 before tail calling.
+define amdgpu_cs void @cs_with_frame_to_chain(<3 x i32> inreg %a, <3 x i32> %b) #0 {
+; GISEL-GFX11-LABEL: cs_with_frame_to_chain:
+; GISEL-GFX11: ; %bb.0:
+; GISEL-GFX11-NEXT: v_dual_mov_b32 v3, 42 :: v_dual_mov_b32 v8, v0
+; GISEL-GFX11-NEXT: v_dual_mov_b32 v9, v1 :: v_dual_mov_b32 v10, v2
+; GISEL-GFX11-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; GISEL-GFX11-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; GISEL-GFX11-NEXT: s_mov_b32 s32, 8
+; GISEL-GFX11-NEXT: scratch_store_b32 off, v3, off
+; GISEL-GFX11-NEXT: s_mov_b32 exec_lo, -1
+; GISEL-GFX11-NEXT: s_setpc_b64 s[4:5]
+;
+; GISEL-GFX10-LABEL: cs_with_frame_to_chain:
+; GISEL-GFX10: ; %bb.0:
+; GISEL-GFX10-NEXT: s_getpc_b64 s[100:101]
+; GISEL-GFX10-NEXT: s_mov_b32 s100, s0
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v3, 42
+; GISEL-GFX10-NEXT: s_load_dwordx4 s[100:103], s[100:101], 0x10
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v8, v0
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v9, v1
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v10, v2
+; GISEL-GFX10-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; GISEL-GFX10-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; GISEL-GFX10-NEXT: s_movk_i32 s32, 0x100
+; GISEL-GFX10-NEXT: s_waitcnt lgkmcnt(0)
+; GISEL-GFX10-NEXT: s_bitset0_b32 s103, 21
+; GISEL-GFX10-NEXT: s_add_u32 s100, s100, s3
+; GISEL-GFX10-NEXT: s_addc_u32 s101, s101, 0
+; GISEL-GFX10-NEXT: s_mov_b64 s[50:51], s[102:103]
+; GISEL-GFX10-NEXT: s_mov_b64 s[48:49], s[100:101]
+; GISEL-GFX10-NEXT: buffer_store_dword v3, off, s[100:103], 0
+; GISEL-GFX10-NEXT: s_mov_b32 exec_lo, -1
+; GISEL-GFX10-NEXT: s_setpc_b64 s[4:5]
+;
+; DAGISEL-GFX11-LABEL: cs_with_frame_to_chain:
+; DAGISEL-GFX11: ; %bb.0:
+; DAGISEL-GFX11-NEXT: v_dual_mov_b32 v3, 42 :: v_dual_mov_b32 v8, v0
+; DAGISEL-GFX11-NEXT: v_dual_mov_b32 v9, v1 :: v_dual_mov_b32 v10, v2
+; DAGISEL-GFX11-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; DAGISEL-GFX11-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; DAGISEL-GFX11-NEXT: s_mov_b32 s32, 8
+; DAGISEL-GFX11-NEXT: scratch_store_b32 off, v3, off
+; DAGISEL-GFX11-NEXT: s_mov_b32 exec_lo, -1
+; DAGISEL-GFX11-NEXT: s_setpc_b64 s[4:5]
+;
+; DAGISEL-GFX10-LABEL: cs_with_frame_to_chain:
+; DAGISEL-GFX10: ; %bb.0:
+; DAGISEL-GFX10-NEXT: s_getpc_b64 s[100:101]
+; DAGISEL-GFX10-NEXT: s_mov_b32 s100, s0
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v3, 42
+; DAGISEL-GFX10-NEXT: s_load_dwordx4 s[100:103], s[100:101], 0x10
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v8, v0
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v9, v1
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v10, v2
+; DAGISEL-GFX10-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; DAGISEL-GFX10-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; DAGISEL-GFX10-NEXT: s_movk_i32 s32, 0x100
+; DAGISEL-GFX10-NEXT: s_waitcnt lgkmcnt(0)
+; DAGISEL-GFX10-NEXT: s_bitset0_b32 s103, 21
+; DAGISEL-GFX10-NEXT: s_add_u32 s100, s100, s3
+; DAGISEL-GFX10-NEXT: s_addc_u32 s101, s101, 0
+; DAGISEL-GFX10-NEXT: s_mov_b64 s[50:51], s[102:103]
+; DAGISEL-GFX10-NEXT: s_mov_b64 s[48:49], s[100:101]
+; DAGISEL-GFX10-NEXT: buffer_store_dword v3, off, s[100:103], 0
+; DAGISEL-GFX10-NEXT: s_mov_b32 exec_lo, -1
+; DAGISEL-GFX10-NEXT: s_setpc_b64 s[4:5]
+ %v = alloca i32, addrspace(5)
+ store i32 42, ptr addrspace(5) %v
+ call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr @chain_callee, i32 -1, <3 x i32> inreg %a, <3 x i32> %b, i32 0)
+ unreachable
+}
+
define amdgpu_cs_chain void @chain_to_chain(<3 x i32> inreg %a, <3 x i32> %b) #0 {
; GISEL-GFX11-LABEL: chain_to_chain:
; GISEL-GFX11: ; %bb.0:
diff --git a/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll b/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll
index acedd27bee8dad..6ead3c9bb37576 100644
--- a/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll
+++ b/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll
@@ -137,6 +137,110 @@ define amdgpu_cs void @with_calls_no_inline_const() #0 {
ret void
}
+; FIXME: The SP points past this frame's locals - we should reset it before the chain call.
+define amdgpu_cs void @with_chain_call() #0 {
+; CHECK-TRUE16-LABEL: with_chain_call:
+; CHECK-TRUE16: ; %bb.0:
+; CHECK-TRUE16-NEXT: s_getreg_b32 s33, hwreg(HW_REG_WAVE_HW_ID2, 8, 2)
+; CHECK-TRUE16-NEXT: v_mov_b16_e32 v0.l, 13
+; CHECK-TRUE16-NEXT: v_mov_b32_e32 v8, 0
+; CHECK-TRUE16-NEXT: s_cmp_lg_u32 0, s33
+; CHECK-TRUE16-NEXT: s_mov_b32 s3, chain_callee at abs32@hi
+; CHECK-TRUE16-NEXT: s_cmovk_i32 s33, 0x1c0
+; CHECK-TRUE16-NEXT: s_mov_b32 s2, chain_callee at abs32@lo
+; CHECK-TRUE16-NEXT: s_mov_b32 s0, 0
+; CHECK-TRUE16-NEXT: s_cselect_b32 s32, 0x1c8, 8
+; CHECK-TRUE16-NEXT: scratch_store_b8 off, v0, s33 scope:SCOPE_SYS
+; CHECK-TRUE16-NEXT: s_wait_storecnt 0x0
+; CHECK-TRUE16-NEXT: s_mov_b32 exec_lo, -1
+; CHECK-TRUE16-NEXT: s_setpc_b64 s[2:3]
+;
+; CHECK-FAKE16-LABEL: with_chain_call:
+; CHECK-FAKE16: ; %bb.0:
+; CHECK-FAKE16-NEXT: s_getreg_b32 s33, hwreg(HW_REG_WAVE_HW_ID2, 8, 2)
+; CHECK-FAKE16-NEXT: v_mov_b32_e32 v0, 13
+; CHECK-FAKE16-NEXT: v_mov_b32_e32 v8, 0
+; CHECK-FAKE16-NEXT: s_cmp_lg_u32 0, s33
+; CHECK-FAKE16-NEXT: s_mov_b32 s3, chain_callee at abs32@hi
+; CHECK-FAKE16-NEXT: s_cmovk_i32 s33, 0x1c0
+; CHECK-FAKE16-NEXT: s_mov_b32 s2, chain_callee at abs32@lo
+; CHECK-FAKE16-NEXT: s_mov_b32 s0, 0
+; CHECK-FAKE16-NEXT: s_cselect_b32 s32, 0x1c8, 8
+; CHECK-FAKE16-NEXT: scratch_store_b8 off, v0, s33 scope:SCOPE_SYS
+; CHECK-FAKE16-NEXT: s_wait_storecnt 0x0
+; CHECK-FAKE16-NEXT: s_mov_b32 exec_lo, -1
+; CHECK-FAKE16-NEXT: s_setpc_b64 s[2:3]
+ %local = alloca i32, addrspace(5)
+ store volatile i8 13, ptr addrspace(5) %local
+ call void(ptr, i32, i32, i32, i32, ...) @llvm.amdgcn.cs.chain(ptr @chain_callee, i32 -1, i32 inreg 0, i32 0, i32 0)
+ unreachable
+}
+
+; No local frame - SP doesn't need to be adjusted.
+define amdgpu_cs void @with_chain_call_no_local() #0 {
+; CHECK-LABEL: with_chain_call_no_local:
+; CHECK: ; %bb.0:
+; CHECK-NEXT: v_mov_b32_e32 v8, 0
+; CHECK-NEXT: s_getreg_b32 s33, hwreg(HW_REG_WAVE_HW_ID2, 8, 2)
+; CHECK-NEXT: s_mov_b32 s3, chain_callee at abs32@hi
+; CHECK-NEXT: s_cmp_lg_u32 0, s33
+; CHECK-NEXT: s_mov_b32 s2, chain_callee at abs32@lo
+; CHECK-NEXT: s_mov_b32 s0, 0
+; CHECK-NEXT: s_cmovk_i32 s33, 0x1c0
+; CHECK-NEXT: s_cselect_b32 s32, 0x1c0, 0
+; CHECK-NEXT: s_mov_b32 exec_lo, -1
+; CHECK-NEXT: s_setpc_b64 s[2:3]
+ call void(ptr, i32, i32, i32, i32, ...) @llvm.amdgcn.cs.chain(ptr @chain_callee, i32 -1, i32 inreg 0, i32 0, i32 0)
+ unreachable
+}
+
+; Same, for the dynamic VGPR variant of the chain pseudo.
+define amdgpu_cs void @with_chain_call_dvgpr() #0 {
+; CHECK-TRUE16-LABEL: with_chain_call_dvgpr:
+; CHECK-TRUE16: ; %bb.0:
+; CHECK-TRUE16-NEXT: s_getreg_b32 s33, hwreg(HW_REG_WAVE_HW_ID2, 8, 2)
+; CHECK-TRUE16-NEXT: v_mov_b16_e32 v0.l, 13
+; CHECK-TRUE16-NEXT: v_mov_b32_e32 v8, 0
+; CHECK-TRUE16-NEXT: s_cmp_lg_u32 0, s33
+; CHECK-TRUE16-NEXT: s_mov_b32 s3, retry_vgpr_alloc at abs32@hi
+; CHECK-TRUE16-NEXT: s_cmovk_i32 s33, 0x1c0
+; CHECK-TRUE16-NEXT: s_mov_b32 s2, retry_vgpr_alloc at abs32@lo
+; CHECK-TRUE16-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; CHECK-TRUE16-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; CHECK-TRUE16-NEXT: s_mov_b32 s0, 0
+; CHECK-TRUE16-NEXT: s_cselect_b32 s32, 0x1c8, 8
+; CHECK-TRUE16-NEXT: scratch_store_b8 off, v0, s33 scope:SCOPE_SYS
+; CHECK-TRUE16-NEXT: s_wait_storecnt 0x0
+; CHECK-TRUE16-NEXT: s_alloc_vgpr 64
+; CHECK-TRUE16-NEXT: s_cselect_b64 s[4:5], s[4:5], s[2:3]
+; CHECK-TRUE16-NEXT: s_cselect_b32 exec_lo, -1, -1
+; CHECK-TRUE16-NEXT: s_setpc_b64 s[4:5]
+;
+; CHECK-FAKE16-LABEL: with_chain_call_dvgpr:
+; CHECK-FAKE16: ; %bb.0:
+; CHECK-FAKE16-NEXT: s_getreg_b32 s33, hwreg(HW_REG_WAVE_HW_ID2, 8, 2)
+; CHECK-FAKE16-NEXT: v_mov_b32_e32 v0, 13
+; CHECK-FAKE16-NEXT: v_mov_b32_e32 v8, 0
+; CHECK-FAKE16-NEXT: s_cmp_lg_u32 0, s33
+; CHECK-FAKE16-NEXT: s_mov_b32 s3, retry_vgpr_alloc at abs32@hi
+; CHECK-FAKE16-NEXT: s_cmovk_i32 s33, 0x1c0
+; CHECK-FAKE16-NEXT: s_mov_b32 s2, retry_vgpr_alloc at abs32@lo
+; CHECK-FAKE16-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; CHECK-FAKE16-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; CHECK-FAKE16-NEXT: s_mov_b32 s0, 0
+; CHECK-FAKE16-NEXT: s_cselect_b32 s32, 0x1c8, 8
+; CHECK-FAKE16-NEXT: scratch_store_b8 off, v0, s33 scope:SCOPE_SYS
+; CHECK-FAKE16-NEXT: s_wait_storecnt 0x0
+; CHECK-FAKE16-NEXT: s_alloc_vgpr 64
+; CHECK-FAKE16-NEXT: s_cselect_b64 s[4:5], s[4:5], s[2:3]
+; CHECK-FAKE16-NEXT: s_cselect_b32 exec_lo, -1, -1
+; CHECK-FAKE16-NEXT: s_setpc_b64 s[4:5]
+ %local = alloca i32, addrspace(5)
+ store volatile i8 13, ptr addrspace(5) %local
+ call void(ptr, i32, i32, i32, i32, ...) @llvm.amdgcn.cs.chain(ptr @chain_callee, i32 -1, i32 inreg 0, i32 0, i32 1, i32 inreg 64, i32 inreg -1, ptr @retry_vgpr_alloc)
+ unreachable
+}
+
define amdgpu_cs void @with_spills() #0 {
; CHECK-LABEL: with_spills:
; CHECK: ; %bb.0:
@@ -367,6 +471,34 @@ define void @default() #0 {
ret void
}
+; Chain callees have to be defined in this file, otherwise we hit an unrelated
+; crash while emitting PAL metadata for a call to a declared-only function.
+define amdgpu_cs_chain void @chain_callee(i32 inreg) #0 {
+; CHECK-LABEL: chain_callee:
+; CHECK: ; %bb.0:
+; CHECK-NEXT: s_wait_loadcnt_dscnt 0x0
+; CHECK-NEXT: s_wait_expcnt 0x0
+; CHECK-NEXT: s_wait_samplecnt 0x0
+; CHECK-NEXT: s_wait_bvhcnt 0x0
+; CHECK-NEXT: s_wait_kmcnt 0x0
+; CHECK-NEXT: s_alloc_vgpr 0
+; CHECK-NEXT: s_endpgm
+ ret void
+}
+
+define amdgpu_cs_chain_preserve void @retry_vgpr_alloc(i32 inreg) #0 {
+; CHECK-LABEL: retry_vgpr_alloc:
+; CHECK: ; %bb.0:
+; CHECK-NEXT: s_wait_loadcnt_dscnt 0x0
+; CHECK-NEXT: s_wait_expcnt 0x0
+; CHECK-NEXT: s_wait_samplecnt 0x0
+; CHECK-NEXT: s_wait_bvhcnt 0x0
+; CHECK-NEXT: s_wait_kmcnt 0x0
+; CHECK-NEXT: s_alloc_vgpr 0
+; CHECK-NEXT: s_endpgm
+ ret void
+}
+
declare amdgpu_gfx void @callee(i32) #0
attributes #0 = { nounwind "amdgpu-dynamic-vgpr-block-size"="16" }
diff --git a/llvm/test/CodeGen/AMDGPU/pei-amdgpu-cs-chain.mir b/llvm/test/CodeGen/AMDGPU/pei-amdgpu-cs-chain.mir
index e1f8b3e0e3a7b8..bfc5fdd1c5a298 100644
--- a/llvm/test/CodeGen/AMDGPU/pei-amdgpu-cs-chain.mir
+++ b/llvm/test/CodeGen/AMDGPU/pei-amdgpu-cs-chain.mir
@@ -13,6 +13,9 @@
define amdgpu_cs_chain void @dont_preserve_non_wwm() #0 {ret void}
define amdgpu_cs_chain void @dont_preserve_v0_v7() #0 {ret void}
define amdgpu_cs_chain void @dont_preserve_sgpr() #0 {ret void}
+ define amdgpu_cs void @entry_reset_sp_before_chain_call() #0 {ret void}
+ define amdgpu_cs void @entry_no_frame_reset_sp() #0 {ret void}
+ define amdgpu_cs void @entry_call_and_chain_call() #0 {ret void}
attributes #0 = { nounwind }
...
@@ -214,3 +217,87 @@ body: |
SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs, implicit $sgpr0
...
+
+# FIXME: SP should be set to 0 before the tail call.
+
+---
+name: entry_reset_sp_before_chain_call
+tracksRegLiveness: true
+frameInfo:
+ maxAlignment: 4
+ hasTailCall: true
+stack:
+ - { id: 0, size: 4, alignment: 4 }
+machineFunctionInfo:
+ isEntryFunction: true
+ stackPtrOffsetReg: '$sgpr32'
+ frameOffsetReg: '$sgpr33'
+ returnsVoid: true
+body: |
+ bb.0:
+ liveins: $sgpr0
+
+ ; GCN-LABEL: name: entry_reset_sp_before_chain_call
+ ; GCN: liveins: $sgpr0
+ ; GCN-NEXT: {{ $}}
+ ; GCN-NEXT: $sgpr32 = S_MOV_B32 8
+ ; GCN-NEXT: renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
+ ; GCN-NEXT: SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs, implicit $sgpr0
+ renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
+ SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs, implicit $sgpr0
+
+...
+
+---
+name: entry_no_frame_reset_sp
+tracksRegLiveness: true
+frameInfo:
+ hasTailCall: true
+machineFunctionInfo:
+ isEntryFunction: true
+ stackPtrOffsetReg: '$sgpr32'
+ frameOffsetReg: '$sgpr33'
+ returnsVoid: true
+body: |
+ bb.0:
+ liveins: $sgpr0
+
+ ; GCN-LABEL: name: entry_no_frame_reset_sp
+ ; GCN: liveins: $sgpr0
+ ; GCN-NEXT: {{ $}}
+ ; GCN-NEXT: $sgpr32 = S_MOV_B32 0
+ ; GCN-NEXT: renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
+ ; GCN-NEXT: SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs, implicit $sgpr0
+ renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
+ SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs, implicit $sgpr0
+
+...
+
+---
+name: entry_call_and_chain_call
+tracksRegLiveness: true
+frameInfo:
+ maxAlignment: 4
+ hasCalls: true
+ hasTailCall: true
+stack:
+ - { id: 0, size: 4, alignment: 4 }
+machineFunctionInfo:
+ isEntryFunction: true
+ stackPtrOffsetReg: '$sgpr32'
+ frameOffsetReg: '$sgpr33'
+ returnsVoid: true
+body: |
+ bb.0:
+ ; GCN-LABEL: name: entry_call_and_chain_call
+ ; GCN: $sgpr32 = S_MOV_B32 8
+ ; GCN-NEXT: renamable $sgpr6_sgpr7 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @gfx_callee + 4, target-flags(amdgpu-gotprel32-hi) @gfx_callee + 12, implicit-def dead $scc
+ ; GCN-NEXT: dead $sgpr30_sgpr31 = SI_CALL killed renamable $sgpr6_sgpr7, @gfx_callee, csr_amdgpu_si_gfx
+ ; GCN-NEXT: renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
+ ; GCN-NEXT: SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs
+ renamable $sgpr6_sgpr7 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @gfx_callee + 4, target-flags(amdgpu-gotprel32-hi) @gfx_callee + 12, implicit-def dead $scc
+ dead $sgpr30_sgpr31 = SI_CALL killed renamable $sgpr6_sgpr7, @gfx_callee, csr_amdgpu_si_gfx
+ renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
+ SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs
+
+...
>From 56b4538ca6c52f884c3d78a94c2c88034d338407 Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Tue, 13 Oct 2026 14:34:22 +0200
Subject: [PATCH 02/11] AMDGPU: Precommit testcases for stack metadata. NFC
---
.../CodeGen/AMDGPU/amdpal-chain-metadata.ll | 123 +++++++++++++++++-
1 file changed, 119 insertions(+), 4 deletions(-)
diff --git a/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll b/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
index 8716b81d952992..4f3d1e0bdcbbd7 100644
--- a/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
+++ b/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
@@ -1,16 +1,63 @@
; RUN: llc -mtriple=amdgpu11.00--amdpal <%s | FileCheck %s
; CHECK-LABEL: {{^}}amdgpu_cs_chain_func:
-; CHECK: .amdgpu_pal_metadata
+; CHECK: .set .Lamdgpu_cs_chain_func.private_seg_size, 16{{$}}
+
+; CHECK-LABEL: {{^}}chain_callee_smaller_stack:
+; CHECK: .set .Lchain_callee_smaller_stack.private_seg_size, 36+max(.Lamdgpu_cs_chain_func.private_seg_size){{$}}
+
+; CHECK-LABEL: {{^}}chain_callee_larger_stack:
+; CHECK: .set .Lchain_callee_larger_stack.private_seg_size, 8+max(.Lamdgpu_cs_chain_func.private_seg_size){{$}}
+
+; CHECK-LABEL: {{^}}chain_and_wwf:
+; CHECK: .set .Lchain_and_wwf.private_seg_size, 80+max(.Lwwf_alloca.private_seg_size, .Lamdgpu_cs_chain_func.private_seg_size){{$}}
+
+; CHECK-LABEL: {{^}}wwf_alloca:
+; CHECK: .set .Lwwf_alloca.private_seg_size, 28{{$}}
+
+; CHECK-LABEL: {{^}}gfx_alloca:
+; CHECK: .set .Lgfx_alloca.private_seg_size, 28{{$}}
+
+; CHECK-LABEL: {{^}}chain_and_gfx:
+; CHECK: .set .Lchain_and_gfx.private_seg_size, 32+max(.Lgfx_alloca.private_seg_size, .Lamdgpu_cs_chain_func.private_seg_size){{$}}
+
+; CHECK-LABEL: {{^}}cs_to_chain_and_wwf:
+; CHECK: .set .Lcs_to_chain_and_wwf.private_seg_size, 12+max(.Lchain_and_wwf.private_seg_size){{$}}
+
+; CHECK-LABEL: {{^}}chain_indirect_and_wwf:
+; CHECK: .set .Lchain_indirect_and_wwf.private_seg_size, 64+max(.Lwwf_alloca.private_seg_size){{$}}
+; CHECK: .set .Lchain_indirect_and_wwf.has_indirect_call, 1{{$}}
+
+; CHECK-LABEL: .amdgpu_pal_metadata
; CHECK-NEXT: ---
; CHECK-NEXT: amdpal.pipelines:
; CHECK-NEXT: - .api: Vulkan
+; CHECK-LABEL: .hardware_stages:
+; CHECK: .cs:
+; CHECK: .entry_point_symbol: cs_to_chain_and_wwf
+; CHECK: .scratch_memory_size: 0x80{{$}}
; CHECK: .shader_functions:
-; CHECK-NEXT: amdgpu_cs_chain_func:
+; CHECK-LABEL: amdgpu_cs_chain_func:
; CHECK: .backend_stack_size: 0x10{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x10{{$}}
-; CHECK-NEXT: .vgpr_count:
-; CHECK-NEXT: .shaders:
+; CHECK-LABEL: chain_and_gfx:
+; CHECK: .backend_stack_size: 0x20{{$}}
+; CHECK: .stack_frame_size_in_bytes: 0x20{{$}}
+; CHECK-LABEL: chain_and_wwf:
+; CHECK: .backend_stack_size: 0x50{{$}}
+; CHECK: .stack_frame_size_in_bytes: 0x50{{$}}
+; CHECK-LABEL: chain_callee_larger_stack:
+; CHECK: .backend_stack_size: 0x8{{$}}
+; CHECK: .stack_frame_size_in_bytes: 0x8{{$}}
+; CHECK-LABEL: chain_callee_smaller_stack:
+; CHECK: .backend_stack_size: 0x24{{$}}
+; CHECK: .stack_frame_size_in_bytes: 0x24{{$}}
+; CHECK-LABEL: chain_indirect_and_wwf:
+; CHECK: .backend_stack_size: 0x40{{$}}
+; CHECK: .stack_frame_size_in_bytes: 0x40{{$}}
+; CHECK-LABEL: gfx_alloca:
+; CHECK: .backend_stack_size: 0x1c{{$}}
+; CHECK: .stack_frame_size_in_bytes: 0x1c{{$}}
; CHECK:amdpal.version:
; CHECK-NEXT: - 0x3
; CHECK-NEXT: - 0
@@ -25,11 +72,79 @@ define amdgpu_cs_chain void @amdgpu_cs_chain_func(<40 x i32> %should_spill) {
ret void
}
+define amdgpu_cs_chain void @chain_callee_smaller_stack(<40 x i32> %v) {
+.entry:
+ %a = alloca [8 x i32], addrspace(5)
+ store volatile i32 1, ptr addrspace(5) %a
+ call void (ptr, i32, {}, <40 x i32>, i32, ...) @llvm.amdgcn.cs.chain.p0.i32.s.v40i32(ptr @amdgpu_cs_chain_func, i32 -1, {} inreg poison, <40 x i32> %v, i32 0)
+ unreachable
+}
+
+define amdgpu_cs_chain void @chain_callee_larger_stack(<40 x i32> %v) {
+.entry:
+ %a = alloca [1 x i32], addrspace(5)
+ store volatile i32 1, ptr addrspace(5) %a
+ call void (ptr, i32, {}, <40 x i32>, i32, ...) @llvm.amdgcn.cs.chain.p0.i32.s.v40i32(ptr @amdgpu_cs_chain_func, i32 -1, {} inreg poison, <40 x i32> %v, i32 0)
+ unreachable
+}
+
+define amdgpu_cs_chain void @chain_and_wwf(<40 x i32> %v) {
+.entry:
+ %a = alloca [16 x i32], addrspace(5)
+ store i32 2, ptr addrspace(5) %a
+ call void (ptr, ...) @llvm.amdgcn.call.whole.wave(ptr @wwf_alloca, ptr addrspace(5) %a)
+ call void (ptr, i32, {}, <40 x i32>, i32, ...) @llvm.amdgcn.cs.chain.p0.i32.s.v40i32(ptr @amdgpu_cs_chain_func, i32 -1, {} inreg poison, <40 x i32> %v, i32 0)
+ unreachable
+}
+
+define amdgpu_gfx_whole_wave void @wwf_alloca(i1 %active, ptr addrspace(5) %p) {
+ %a = alloca [4 x i32], addrspace(5)
+ store volatile i32 3, ptr addrspace(5) %a
+ store i32 4, ptr addrspace(5) %p
+ ret void
+}
+
+define amdgpu_cs_chain void @chain_and_gfx(<40 x i32> %v) {
+.entry:
+ %a = alloca [4 x i32], addrspace(5)
+ store i32 6, ptr addrspace(5) %a
+ call amdgpu_gfx void @gfx_alloca(ptr addrspace(5) %a)
+ call void (ptr, i32, {}, <40 x i32>, i32, ...) @llvm.amdgcn.cs.chain.p0.i32.s.v40i32(ptr @amdgpu_cs_chain_func, i32 -1, {} inreg poison, <40 x i32> %v, i32 0)
+ unreachable
+}
+
+define amdgpu_gfx void @gfx_alloca(ptr addrspace(5) %p) {
+ %a = alloca [6 x i32], addrspace(5)
+ store volatile i32 7, ptr addrspace(5) %a
+ store i32 8, ptr addrspace(5) %p
+ ret void
+}
+
+define amdgpu_cs void @cs_to_chain_and_wwf(<40 x i32> %v) {
+.entry:
+ %a = alloca [2 x i32], addrspace(5)
+ store volatile i32 9, ptr addrspace(5) %a
+ call void (ptr, i32, {}, <40 x i32>, i32, ...) @llvm.amdgcn.cs.chain.p0.i32.s.v40i32(ptr @chain_and_wwf, i32 -1, {} inreg poison, <40 x i32> %v, i32 0)
+ unreachable
+}
+
+define amdgpu_cs_chain void @chain_indirect_and_wwf(ptr inreg %callee, <40 x i32> %v) {
+.entry:
+ %a = alloca [12 x i32], addrspace(5)
+ store i32 10, ptr addrspace(5) %a
+ call void (ptr, ...) @llvm.amdgcn.call.whole.wave(ptr @wwf_alloca, ptr addrspace(5) %a)
+ call void (ptr, i32, {}, <40 x i32>, i32, ...) @llvm.amdgcn.cs.chain.p0.i32.s.v40i32(ptr %callee, i32 -1, {} inreg poison, <40 x i32> %v, i32 0)
+ unreachable
+}
+
define amdgpu_cs_chain_preserve void @amdgpu_cs_chain_preserve_func() {
.entry:
ret void
}
+declare void @llvm.amdgcn.call.whole.wave(ptr, ...)
+declare void @llvm.amdgcn.cs.chain.p0.i32.s.v40i32(ptr, i32, {}, <40 x i32>, i32 immarg, ...)
+
declare amdgpu_gfx void @use(...)
!amdgpu.pal.metadata.msgpack = !{!0}
>From 76877060520fa4a12cedceb469a52975e987bf09 Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Mon, 19 Oct 2026 10:28:36 +0200
Subject: [PATCH 03/11] AMDGPU: Reset SP in entry point before chain call
Chain calls are always tail calls and they are expected to completely
take over the caller's stack frame. Chain functions receive a stack
pointer from their caller, but that is only in order to support
reserving space at the bottom of the stack for CWSR.
Currently, when an entry function has its own stack variables, the SP we
pass on to the chain function points after the stack of the caller. This
is wasteful, so the current patch introduces an epilogue for entry
functions if they contain a chain call. The epilogue will reset SP to
point to the bottom of the stack, either by copying it from FP if we've
been reserving space for CWSR or by setting it directly to zero.
Note that we also modify `requiresStackPointerReference` to return false
for tail calls. This means the prologue will only initialize SP if it's
really needed by the current function, relying on the epilogue to handle
it if we only need to set SP for the sake of our chain callee. This
avoids situations where we might unnecessarily initialize the SP with
the size of the current frame in the prologue, only to later reset to
the bottom of the stack in the epilogue.
Assisted-by: AI
---
llvm/lib/Target/AMDGPU/SIFrameLowering.cpp | 51 +++++++++++++++++--
llvm/lib/Target/AMDGPU/SIFrameLowering.h | 3 ++
.../test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll | 9 ++--
.../dynamic-vgpr-reserve-stack-for-cwsr.ll | 17 +++----
.../CodeGen/AMDGPU/pei-amdgpu-cs-chain.mir | 10 ++--
5 files changed, 65 insertions(+), 25 deletions(-)
diff --git a/llvm/lib/Target/AMDGPU/SIFrameLowering.cpp b/llvm/lib/Target/AMDGPU/SIFrameLowering.cpp
index 364d8f07b6df25..7a18965247cbf0 100644
--- a/llvm/lib/Target/AMDGPU/SIFrameLowering.cpp
+++ b/llvm/lib/Target/AMDGPU/SIFrameLowering.cpp
@@ -938,6 +938,48 @@ void SIFrameLowering::emitEntryFunctionPrologue(MachineFunction &MF,
}
}
+void SIFrameLowering::emitEntryFunctionEpilogue(MachineFunction &MF,
+ MachineBasicBlock &MBB) const {
+ // Entry functions don't usually need an epilogue. The only exception is
+ // if we have a chain call (which is the only possible tail call in an
+ // entry function), in which case the current frame is becoming dead and we
+ // need to reset SP to point to the base of the stack.
+ const MachineFrameInfo &FrameInfo = MF.getFrameInfo();
+ if (!FrameInfo.hasTailCall())
+ return;
+
+ // If the prologue has set SP and there aren't any local variables, then we
+ // don't need to restore anything.
+ if (requiresStackPointerReference(MF) && FrameInfo.getStackSize() == 0)
+ return;
+
+ const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
+ const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
+ const SIInstrInfo *TII = ST.getInstrInfo();
+ MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
+ const DebugLoc &DL = MBBI->getDebugLoc();
+
+ Register SPReg = MFI->getStackPtrOffsetReg();
+ assert(SPReg != AMDGPU::SP_REG);
+
+ // We need to either reset SP to point before the local variables, or to
+ // initialize it in case we skipped it in the prologue. In either case,
+ // the SP needs to be either 0 or point right after the space reserved for
+ // CWSR (which the prologue conveniently puts in FP).
+ if (mayReserveScratchForCWSR(MF)) {
+ assert(hasFP(MF));
+ Register FPReg = MFI->getFrameOffsetReg();
+ assert(FPReg != AMDGPU::FP_REG);
+ BuildMI(MBB, MBBI, DL, TII->get(AMDGPU::COPY), SPReg)
+ .addReg(FPReg)
+ .setMIFlag(MachineInstr::FrameDestroy);
+ } else {
+ BuildMI(MBB, MBBI, DL, TII->get(AMDGPU::S_MOV_B32), SPReg)
+ .addImm(0)
+ .setMIFlag(MachineInstr::FrameDestroy);
+ }
+}
+
// Emit scratch RSRC setup code, assuming `ScratchRsrcReg != AMDGPU::NoReg`
void SIFrameLowering::emitEntryFunctionScratchRsrcRegSetup(
MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
@@ -1580,8 +1622,10 @@ void SIFrameLowering::emitPrologue(MachineFunction &MF,
void SIFrameLowering::emitEpilogue(MachineFunction &MF,
MachineBasicBlock &MBB) const {
const SIMachineFunctionInfo *FuncInfo = MF.getInfo<SIMachineFunctionInfo>();
- if (FuncInfo->isEntryFunction())
+ if (FuncInfo->isEntryFunction()) {
+ emitEntryFunctionEpilogue(MF, MBB);
return;
+ }
const MachineFrameInfo &MFI = MF.getFrameInfo();
if (FuncInfo->isChainFunction() && !MFI.hasTailCall())
@@ -2506,9 +2550,8 @@ bool SIFrameLowering::requiresStackPointerReference(
const MachineFrameInfo &MFI = MF.getFrameInfo();
// Entry points ordinarily don't need to initialize SP. We have to set it up
- // for callees if there are any. Also note tail calls are only possible via
- // the `llvm.amdgcn.cs.chain` intrinsic.
- if (MFI.hasCalls() || MFI.hasTailCall())
+ // for callees if there are any.
+ if (MFI.hasCalls())
return true;
// We still need to initialize the SP if we're doing anything weird that
diff --git a/llvm/lib/Target/AMDGPU/SIFrameLowering.h b/llvm/lib/Target/AMDGPU/SIFrameLowering.h
index 7dbaf9df4dad2a..3da071f93ee631 100644
--- a/llvm/lib/Target/AMDGPU/SIFrameLowering.h
+++ b/llvm/lib/Target/AMDGPU/SIFrameLowering.h
@@ -26,6 +26,9 @@ class SIFrameLowering final : public AMDGPUFrameLowering {
void emitEntryFunctionPrologue(MachineFunction &MF,
MachineBasicBlock &MBB) const;
+ void emitEntryFunctionEpilogue(MachineFunction &MF,
+ MachineBasicBlock &MBB) const;
+
void emitPrologue(MachineFunction &MF,
MachineBasicBlock &MBB) const override;
void emitEpilogue(MachineFunction &MF,
diff --git a/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll b/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll
index 60a1a03ee356be..3d3d1df0f619f3 100644
--- a/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll
+++ b/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll
@@ -582,7 +582,6 @@ define amdgpu_cs void @cs_to_chain_nonuniform(<3 x i32> %a, <3 x i32> %b) #0 {
unreachable
}
-; FIXME: The SP points after the locals, but we should reset to 0 before tail calling.
define amdgpu_cs void @cs_with_frame_to_chain(<3 x i32> inreg %a, <3 x i32> %b) #0 {
; GISEL-GFX11-LABEL: cs_with_frame_to_chain:
; GISEL-GFX11: ; %bb.0:
@@ -590,8 +589,8 @@ define amdgpu_cs void @cs_with_frame_to_chain(<3 x i32> inreg %a, <3 x i32> %b)
; GISEL-GFX11-NEXT: v_dual_mov_b32 v9, v1 :: v_dual_mov_b32 v10, v2
; GISEL-GFX11-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
; GISEL-GFX11-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
-; GISEL-GFX11-NEXT: s_mov_b32 s32, 8
; GISEL-GFX11-NEXT: scratch_store_b32 off, v3, off
+; GISEL-GFX11-NEXT: s_mov_b32 s32, 0
; GISEL-GFX11-NEXT: s_mov_b32 exec_lo, -1
; GISEL-GFX11-NEXT: s_setpc_b64 s[4:5]
;
@@ -606,7 +605,7 @@ define amdgpu_cs void @cs_with_frame_to_chain(<3 x i32> inreg %a, <3 x i32> %b)
; GISEL-GFX10-NEXT: v_mov_b32_e32 v10, v2
; GISEL-GFX10-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
; GISEL-GFX10-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
-; GISEL-GFX10-NEXT: s_movk_i32 s32, 0x100
+; GISEL-GFX10-NEXT: s_mov_b32 s32, 0
; GISEL-GFX10-NEXT: s_waitcnt lgkmcnt(0)
; GISEL-GFX10-NEXT: s_bitset0_b32 s103, 21
; GISEL-GFX10-NEXT: s_add_u32 s100, s100, s3
@@ -623,8 +622,8 @@ define amdgpu_cs void @cs_with_frame_to_chain(<3 x i32> inreg %a, <3 x i32> %b)
; DAGISEL-GFX11-NEXT: v_dual_mov_b32 v9, v1 :: v_dual_mov_b32 v10, v2
; DAGISEL-GFX11-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
; DAGISEL-GFX11-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
-; DAGISEL-GFX11-NEXT: s_mov_b32 s32, 8
; DAGISEL-GFX11-NEXT: scratch_store_b32 off, v3, off
+; DAGISEL-GFX11-NEXT: s_mov_b32 s32, 0
; DAGISEL-GFX11-NEXT: s_mov_b32 exec_lo, -1
; DAGISEL-GFX11-NEXT: s_setpc_b64 s[4:5]
;
@@ -639,7 +638,7 @@ define amdgpu_cs void @cs_with_frame_to_chain(<3 x i32> inreg %a, <3 x i32> %b)
; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v10, v2
; DAGISEL-GFX10-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
; DAGISEL-GFX10-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
-; DAGISEL-GFX10-NEXT: s_movk_i32 s32, 0x100
+; DAGISEL-GFX10-NEXT: s_mov_b32 s32, 0
; DAGISEL-GFX10-NEXT: s_waitcnt lgkmcnt(0)
; DAGISEL-GFX10-NEXT: s_bitset0_b32 s103, 21
; DAGISEL-GFX10-NEXT: s_add_u32 s100, s100, s3
diff --git a/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll b/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll
index 6ead3c9bb37576..9f8e70602a8284 100644
--- a/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll
+++ b/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll
@@ -137,7 +137,6 @@ define amdgpu_cs void @with_calls_no_inline_const() #0 {
ret void
}
-; FIXME: The SP points past this frame's locals - we should reset it before the chain call.
define amdgpu_cs void @with_chain_call() #0 {
; CHECK-TRUE16-LABEL: with_chain_call:
; CHECK-TRUE16: ; %bb.0:
@@ -149,9 +148,9 @@ define amdgpu_cs void @with_chain_call() #0 {
; CHECK-TRUE16-NEXT: s_cmovk_i32 s33, 0x1c0
; CHECK-TRUE16-NEXT: s_mov_b32 s2, chain_callee at abs32@lo
; CHECK-TRUE16-NEXT: s_mov_b32 s0, 0
-; CHECK-TRUE16-NEXT: s_cselect_b32 s32, 0x1c8, 8
; CHECK-TRUE16-NEXT: scratch_store_b8 off, v0, s33 scope:SCOPE_SYS
; CHECK-TRUE16-NEXT: s_wait_storecnt 0x0
+; CHECK-TRUE16-NEXT: s_mov_b32 s32, s33
; CHECK-TRUE16-NEXT: s_mov_b32 exec_lo, -1
; CHECK-TRUE16-NEXT: s_setpc_b64 s[2:3]
;
@@ -165,9 +164,9 @@ define amdgpu_cs void @with_chain_call() #0 {
; CHECK-FAKE16-NEXT: s_cmovk_i32 s33, 0x1c0
; CHECK-FAKE16-NEXT: s_mov_b32 s2, chain_callee at abs32@lo
; CHECK-FAKE16-NEXT: s_mov_b32 s0, 0
-; CHECK-FAKE16-NEXT: s_cselect_b32 s32, 0x1c8, 8
; CHECK-FAKE16-NEXT: scratch_store_b8 off, v0, s33 scope:SCOPE_SYS
; CHECK-FAKE16-NEXT: s_wait_storecnt 0x0
+; CHECK-FAKE16-NEXT: s_mov_b32 s32, s33
; CHECK-FAKE16-NEXT: s_mov_b32 exec_lo, -1
; CHECK-FAKE16-NEXT: s_setpc_b64 s[2:3]
%local = alloca i32, addrspace(5)
@@ -180,14 +179,14 @@ define amdgpu_cs void @with_chain_call() #0 {
define amdgpu_cs void @with_chain_call_no_local() #0 {
; CHECK-LABEL: with_chain_call_no_local:
; CHECK: ; %bb.0:
-; CHECK-NEXT: v_mov_b32_e32 v8, 0
; CHECK-NEXT: s_getreg_b32 s33, hwreg(HW_REG_WAVE_HW_ID2, 8, 2)
-; CHECK-NEXT: s_mov_b32 s3, chain_callee at abs32@hi
+; CHECK-NEXT: v_mov_b32_e32 v8, 0
; CHECK-NEXT: s_cmp_lg_u32 0, s33
+; CHECK-NEXT: s_mov_b32 s3, chain_callee at abs32@hi
+; CHECK-NEXT: s_cmovk_i32 s33, 0x1c0
; CHECK-NEXT: s_mov_b32 s2, chain_callee at abs32@lo
; CHECK-NEXT: s_mov_b32 s0, 0
-; CHECK-NEXT: s_cmovk_i32 s33, 0x1c0
-; CHECK-NEXT: s_cselect_b32 s32, 0x1c0, 0
+; CHECK-NEXT: s_mov_b32 s32, s33
; CHECK-NEXT: s_mov_b32 exec_lo, -1
; CHECK-NEXT: s_setpc_b64 s[2:3]
call void(ptr, i32, i32, i32, i32, ...) @llvm.amdgcn.cs.chain(ptr @chain_callee, i32 -1, i32 inreg 0, i32 0, i32 0)
@@ -208,9 +207,9 @@ define amdgpu_cs void @with_chain_call_dvgpr() #0 {
; CHECK-TRUE16-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
; CHECK-TRUE16-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
; CHECK-TRUE16-NEXT: s_mov_b32 s0, 0
-; CHECK-TRUE16-NEXT: s_cselect_b32 s32, 0x1c8, 8
; CHECK-TRUE16-NEXT: scratch_store_b8 off, v0, s33 scope:SCOPE_SYS
; CHECK-TRUE16-NEXT: s_wait_storecnt 0x0
+; CHECK-TRUE16-NEXT: s_mov_b32 s32, s33
; CHECK-TRUE16-NEXT: s_alloc_vgpr 64
; CHECK-TRUE16-NEXT: s_cselect_b64 s[4:5], s[4:5], s[2:3]
; CHECK-TRUE16-NEXT: s_cselect_b32 exec_lo, -1, -1
@@ -228,9 +227,9 @@ define amdgpu_cs void @with_chain_call_dvgpr() #0 {
; CHECK-FAKE16-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
; CHECK-FAKE16-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
; CHECK-FAKE16-NEXT: s_mov_b32 s0, 0
-; CHECK-FAKE16-NEXT: s_cselect_b32 s32, 0x1c8, 8
; CHECK-FAKE16-NEXT: scratch_store_b8 off, v0, s33 scope:SCOPE_SYS
; CHECK-FAKE16-NEXT: s_wait_storecnt 0x0
+; CHECK-FAKE16-NEXT: s_mov_b32 s32, s33
; CHECK-FAKE16-NEXT: s_alloc_vgpr 64
; CHECK-FAKE16-NEXT: s_cselect_b64 s[4:5], s[4:5], s[2:3]
; CHECK-FAKE16-NEXT: s_cselect_b32 exec_lo, -1, -1
diff --git a/llvm/test/CodeGen/AMDGPU/pei-amdgpu-cs-chain.mir b/llvm/test/CodeGen/AMDGPU/pei-amdgpu-cs-chain.mir
index bfc5fdd1c5a298..ec1f13306403e7 100644
--- a/llvm/test/CodeGen/AMDGPU/pei-amdgpu-cs-chain.mir
+++ b/llvm/test/CodeGen/AMDGPU/pei-amdgpu-cs-chain.mir
@@ -217,9 +217,6 @@ body: |
SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs, implicit $sgpr0
...
-
-# FIXME: SP should be set to 0 before the tail call.
-
---
name: entry_reset_sp_before_chain_call
tracksRegLiveness: true
@@ -240,14 +237,13 @@ body: |
; GCN-LABEL: name: entry_reset_sp_before_chain_call
; GCN: liveins: $sgpr0
; GCN-NEXT: {{ $}}
- ; GCN-NEXT: $sgpr32 = S_MOV_B32 8
; GCN-NEXT: renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
+ ; GCN-NEXT: $sgpr32 = frame-destroy S_MOV_B32 0
; GCN-NEXT: SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs, implicit $sgpr0
renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs, implicit $sgpr0
...
-
---
name: entry_no_frame_reset_sp
tracksRegLiveness: true
@@ -265,14 +261,13 @@ body: |
; GCN-LABEL: name: entry_no_frame_reset_sp
; GCN: liveins: $sgpr0
; GCN-NEXT: {{ $}}
- ; GCN-NEXT: $sgpr32 = S_MOV_B32 0
; GCN-NEXT: renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
+ ; GCN-NEXT: $sgpr32 = frame-destroy S_MOV_B32 0
; GCN-NEXT: SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs, implicit $sgpr0
renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs, implicit $sgpr0
...
-
---
name: entry_call_and_chain_call
tracksRegLiveness: true
@@ -294,6 +289,7 @@ body: |
; GCN-NEXT: renamable $sgpr6_sgpr7 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @gfx_callee + 4, target-flags(amdgpu-gotprel32-hi) @gfx_callee + 12, implicit-def dead $scc
; GCN-NEXT: dead $sgpr30_sgpr31 = SI_CALL killed renamable $sgpr6_sgpr7, @gfx_callee, csr_amdgpu_si_gfx
; GCN-NEXT: renamable $sgpr4_sgpr5 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @callee + 4, target-flags(amdgpu-gotprel32-hi) @callee + 12, implicit-def dead $scc
+ ; GCN-NEXT: $sgpr32 = frame-destroy S_MOV_B32 0
; GCN-NEXT: SI_CS_CHAIN_TC_W32 killed renamable $sgpr4_sgpr5, @callee, 0, -1, amdgpu_allvgprs
renamable $sgpr6_sgpr7 = SI_PC_ADD_REL_OFFSET target-flags(amdgpu-gotprel32-lo) @gfx_callee + 4, target-flags(amdgpu-gotprel32-hi) @gfx_callee + 12, implicit-def dead $scc
dead $sgpr30_sgpr31 = SI_CALL killed renamable $sgpr6_sgpr7, @gfx_callee, csr_amdgpu_si_gfx
>From 0cbd5d08f9f90b37e3222e478dba9327e14b8a3d Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Tue, 13 Oct 2026 14:55:28 +0200
Subject: [PATCH 04/11] AMDGPU: Don't include stack size of chain callees
Chain callees are always tail called into and overwrite the caller's
stack. Therefore, their stack size should not be added up to that of
their caller when computing the resource usage.
Assisted-by: AI
---
llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp | 5 ++++-
.../Target/AMDGPU/AMDGPUResourceUsageAnalysis.cpp | 8 +++++---
llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll | 12 ++++++------
3 files changed, 15 insertions(+), 10 deletions(-)
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
index 1731b0463a0991..a33a1d3c8fc05a 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
@@ -371,7 +371,10 @@ void MCResourceInfo::gatherResourceInfo(
for (const Function *Callee : FRI.Callees) {
if (!Seen.insert(Callee).second)
continue;
- if (!Callee->isDeclaration()) {
+
+ // Chain callees use the same stack frame. Exclude them.
+ if (!Callee->isDeclaration() &&
+ !AMDGPU::isChainCC(Callee->getCallingConv())) {
MCSymbol *CalleeFnSym = TM.getSymbol(&Callee->getFunction());
MCSymbol *CalleeValSym =
getSymbol(CalleeFnSym->getName(), RIK_PrivateSegSize, OutContext);
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.cpp b/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.cpp
index aab43f23cf6065..c2077e940ed3e3 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.cpp
@@ -306,9 +306,11 @@ AMDGPUResourceUsageAnalysisImpl::analyzeResourceUsage(
}
if (IsIndirect) {
- Info.CalleeSegmentSize =
- std::max(Info.CalleeSegmentSize,
- static_cast<uint64_t>(AssumedStackSizeForExternalCall));
+ // Chain callees use the same stack frame. Exclude them.
+ if (!IsChainCall)
+ Info.CalleeSegmentSize = std::max(
+ Info.CalleeSegmentSize,
+ static_cast<uint64_t>(AssumedStackSizeForExternalCall));
// Register usage of indirect calls gets handled later
Info.UsesVCC = true;
diff --git a/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll b/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
index 4f3d1e0bdcbbd7..d972dd7884902e 100644
--- a/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
+++ b/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
@@ -4,13 +4,13 @@
; CHECK: .set .Lamdgpu_cs_chain_func.private_seg_size, 16{{$}}
; CHECK-LABEL: {{^}}chain_callee_smaller_stack:
-; CHECK: .set .Lchain_callee_smaller_stack.private_seg_size, 36+max(.Lamdgpu_cs_chain_func.private_seg_size){{$}}
+; CHECK: .set .Lchain_callee_smaller_stack.private_seg_size, 36{{$}}
; CHECK-LABEL: {{^}}chain_callee_larger_stack:
-; CHECK: .set .Lchain_callee_larger_stack.private_seg_size, 8+max(.Lamdgpu_cs_chain_func.private_seg_size){{$}}
+; CHECK: .set .Lchain_callee_larger_stack.private_seg_size, 8{{$}}
; CHECK-LABEL: {{^}}chain_and_wwf:
-; CHECK: .set .Lchain_and_wwf.private_seg_size, 80+max(.Lwwf_alloca.private_seg_size, .Lamdgpu_cs_chain_func.private_seg_size){{$}}
+; CHECK: .set .Lchain_and_wwf.private_seg_size, 80+max(.Lwwf_alloca.private_seg_size){{$}}
; CHECK-LABEL: {{^}}wwf_alloca:
; CHECK: .set .Lwwf_alloca.private_seg_size, 28{{$}}
@@ -19,10 +19,10 @@
; CHECK: .set .Lgfx_alloca.private_seg_size, 28{{$}}
; CHECK-LABEL: {{^}}chain_and_gfx:
-; CHECK: .set .Lchain_and_gfx.private_seg_size, 32+max(.Lgfx_alloca.private_seg_size, .Lamdgpu_cs_chain_func.private_seg_size){{$}}
+; CHECK: .set .Lchain_and_gfx.private_seg_size, 32+max(.Lgfx_alloca.private_seg_size){{$}}
; CHECK-LABEL: {{^}}cs_to_chain_and_wwf:
-; CHECK: .set .Lcs_to_chain_and_wwf.private_seg_size, 12+max(.Lchain_and_wwf.private_seg_size){{$}}
+; CHECK: .set .Lcs_to_chain_and_wwf.private_seg_size, 12{{$}}
; CHECK-LABEL: {{^}}chain_indirect_and_wwf:
; CHECK: .set .Lchain_indirect_and_wwf.private_seg_size, 64+max(.Lwwf_alloca.private_seg_size){{$}}
@@ -35,7 +35,7 @@
; CHECK-LABEL: .hardware_stages:
; CHECK: .cs:
; CHECK: .entry_point_symbol: cs_to_chain_and_wwf
-; CHECK: .scratch_memory_size: 0x80{{$}}
+; CHECK: .scratch_memory_size: 0x10{{$}}
; CHECK: .shader_functions:
; CHECK-LABEL: amdgpu_cs_chain_func:
; CHECK: .backend_stack_size: 0x10{{$}}
>From 2652a6d29bdd457c8ce34b3de6a76ad28596bdab Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Wed, 14 Oct 2026 11:08:10 +0200
Subject: [PATCH 05/11] AMDGPU: Include callees in backend_stack_size PAL
metadata
The stack size reported in the PAL metadata of a chain function should
include the stack sizes of any callees, since the consumers don't have
access to the call graph (this is especially important for whole wave
functions, because we don't even emit any PAL metadata for them). The
consumers are generally expected to allocate scratch based on the
maximum `.backend_stack_size` emitted for the functions in a pipeline.
They will also have to deal with recursion and indirect calls.
The `.stack_frame_size_in_bytes` metadata remains unchanged, i.e. it
represents just the stack size of the current function (without its
callees).
Assisted-by: AI
---
llvm/docs/AMDGPUUsage.rst | 7 ++-
llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp | 3 +-
.../Target/AMDGPU/Utils/AMDGPUPALMetadata.cpp | 12 +++-
.../Target/AMDGPU/Utils/AMDGPUPALMetadata.h | 10 +++-
llvm/test/CodeGen/AMDGPU/amdpal-callable.ll | 4 +-
.../CodeGen/AMDGPU/amdpal-chain-metadata.ll | 60 +++++++++++++++++--
.../AMDGPU/pal-metadata-3.0-callable-dvgpr.ll | 4 +-
.../AMDGPU/pal-metadata-3.0-callable.ll | 4 +-
8 files changed, 87 insertions(+), 17 deletions(-)
diff --git a/llvm/docs/AMDGPUUsage.rst b/llvm/docs/AMDGPUUsage.rst
index 3de94d5617ac7b..53cbb657ef9811 100644
--- a/llvm/docs/AMDGPUUsage.rst
+++ b/llvm/docs/AMDGPUUsage.rst
@@ -20999,7 +20999,12 @@ within a map that has been added by the same *vendor-name*.
".lds_size" integer Size in bytes of LDS memory.
".vgpr_count" integer Number of VGPRs used by the shader.
".sgpr_count" integer Number of SGPRs used by the shader.
- ".stack_frame_size_in_bytes" integer Amount of stack size used by the shader.
+ ".stack_frame_size_in_bytes" integer Amount of stack size used by the shader itself, not including
+ the stack used by any of its callees.
+ ".backend_stack_size" integer Amount of stack size used by the shader, including the stack
+ used by its known callees. Chain callees are excluded, since they
+ reuse the caller's stack frame. Indirect calls and recursion do
+ not contribute.
".shader_subtype" string Shader subtype/kind. Values include:
- "Unknown"
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
index f2761dc9755b76..9b326a12521c36 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
@@ -1815,7 +1815,8 @@ void AMDGPUAsmPrinter::emitPALFunctionMetadata(const MachineFunction &MF) {
auto *MD = getTargetStreamer()->getPALMetadata();
const MachineFrameInfo &MFI = MF.getFrameInfo();
StringRef FnName = MF.getFunction().getName();
- MD->setFunctionScratchSize(FnName, MFI.getStackSize());
+ MD->setFunctionStackFrameSize(FnName, MFI.getStackSize());
+ MD->setFunctionBackendStackSize(FnName, CurrentProgramInfo.ScratchSize);
const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
MCContext &Ctx = MF.getContext();
diff --git a/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.cpp b/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.cpp
index 14a9a217c01cc0..33d0c5e7cbc7a9 100644
--- a/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.cpp
+++ b/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.cpp
@@ -366,11 +366,17 @@ void AMDGPUPALMetadata::setScratchSize(unsigned CC, const MCExpr *Val,
setHwStage(CC, ".scratch_memory_size", msgpack::Type::UInt, Val);
}
-// Set the stack frame size of a function in the metadata.
-void AMDGPUPALMetadata::setFunctionScratchSize(StringRef FnName, unsigned Val) {
+void AMDGPUPALMetadata::setFunctionStackFrameSize(StringRef FnName,
+ unsigned Val) {
auto Node = getShaderFunction(FnName);
Node[".stack_frame_size_in_bytes"] = MsgPackDoc.getNode(Val);
- Node[".backend_stack_size"] = MsgPackDoc.getNode(Val);
+}
+
+void AMDGPUPALMetadata::setFunctionBackendStackSize(StringRef FnName,
+ const MCExpr *Val) {
+ msgpack::MapDocNode Node = getShaderFunction(FnName);
+ DelayedExprs.assignDocNode(Node[".backend_stack_size"], msgpack::Type::UInt,
+ Val);
}
// Set the amount of LDS used in bytes in the metadata.
diff --git a/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.h b/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.h
index 6669cf387c5b56..e619d140fd8395 100644
--- a/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.h
+++ b/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.h
@@ -103,8 +103,14 @@ class AMDGPUPALMetadata {
void setScratchSize(unsigned CC, unsigned Val);
void setScratchSize(unsigned CC, const MCExpr *Val, MCContext &Ctx);
- // Set the stack frame size of a function in the metadata.
- void setFunctionScratchSize(StringRef FnName, unsigned Val);
+ // Set the stack frame size of a function in the metadata. This only covers
+ // the frame of the function itself, not the frames of any of its callees.
+ void setFunctionStackFrameSize(StringRef FnName, unsigned Val);
+
+ // Set the backend stack size metadata, including the frames of its known
+ // calles. Recursion and indirect/external calls must be handled by the
+ // consumer.
+ void setFunctionBackendStackSize(StringRef FnName, const MCExpr *Val);
// Set the amount of LDS used in bytes in the metadata. This is an optional
// advisory record for logging etc; wave dispatch actually uses the rsrc1
diff --git a/llvm/test/CodeGen/AMDGPU/amdpal-callable.ll b/llvm/test/CodeGen/AMDGPU/amdpal-callable.ll
index 20e9842d5e62b8..14bb9dc9da29e2 100644
--- a/llvm/test/CodeGen/AMDGPU/amdpal-callable.ll
+++ b/llvm/test/CodeGen/AMDGPU/amdpal-callable.ll
@@ -171,7 +171,7 @@ attributes #0 = { nounwind }
; GCN-NEXT: .stack_frame_size_in_bytes: 0{{$}}
; GCN-NEXT: .vgpr_count: 0x1{{$}}
; GCN-NEXT: no_stack_call:
-; GCN-NEXT: .backend_stack_size: 0x10{{$}}
+; GCN-NEXT: .backend_stack_size: 0x24{{$}}
; GCN-NEXT: .lds_size: 0{{$}}
; GCN-NEXT: .sgpr_count: 0x25{{$}}
; GCN-NEXT: .stack_frame_size_in_bytes: 0x10{{$}}
@@ -216,7 +216,7 @@ attributes #0 = { nounwind }
; GCN-NEXT: .stack_frame_size_in_bytes: 0x14{{$}}
; GCN-NEXT: .vgpr_count: 0x2{{$}}
; GCN-NEXT: simple_stack_call:
-; GCN-NEXT: .backend_stack_size: 0x20{{$}}
+; GCN-NEXT: .backend_stack_size: 0x34{{$}}
; GCN-NEXT: .lds_size: 0{{$}}
; GCN-NEXT: .sgpr_count: 0x25{{$}}
; GCN-NEXT: .stack_frame_size_in_bytes: 0x20{{$}}
diff --git a/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll b/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
index d972dd7884902e..9d8da278ac79c8 100644
--- a/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
+++ b/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
@@ -1,4 +1,4 @@
-; RUN: llc -mtriple=amdgpu11.00--amdpal <%s | FileCheck %s
+; RUN: llc -mtriple=amdgpu11.00--amdpal < %s | FileCheck %s
; CHECK-LABEL: {{^}}amdgpu_cs_chain_func:
; CHECK: .set .Lamdgpu_cs_chain_func.private_seg_size, 16{{$}}
@@ -28,6 +28,19 @@
; CHECK: .set .Lchain_indirect_and_wwf.private_seg_size, 64+max(.Lwwf_alloca.private_seg_size){{$}}
; CHECK: .set .Lchain_indirect_and_wwf.has_indirect_call, 1{{$}}
+; CHECK-LABEL: {{^}}chain_indirect_gfx_and_wwf:
+; CHECK: .set .Lchain_indirect_gfx_and_wwf.private_seg_size, 64+max(.Lwwf_alloca.private_seg_size){{$}}
+; CHECK: .set .Lchain_indirect_gfx_and_wwf.has_indirect_call, 1{{$}}
+
+; CHECK-LABEL: {{^}}gfx_stack_only:
+; CHECK: .set .Lgfx_stack_only.private_seg_size, 20{{$}}
+
+; CHECK-LABEL: {{^}}wwf_callee_stack_only:
+; CHECK: .set .Lwwf_callee_stack_only.private_seg_size, 16+max(.Lgfx_stack_only.private_seg_size){{$}}
+
+; CHECK-LABEL: {{^}}chain_own_and_callee_stack:
+; CHECK: .set .Lchain_own_and_callee_stack.private_seg_size, 32+max(.Lwwf_callee_stack_only.private_seg_size){{$}}
+
; CHECK-LABEL: .amdgpu_pal_metadata
; CHECK-NEXT: ---
; CHECK-NEXT: amdpal.pipelines:
@@ -41,10 +54,10 @@
; CHECK: .backend_stack_size: 0x10{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x10{{$}}
; CHECK-LABEL: chain_and_gfx:
-; CHECK: .backend_stack_size: 0x20{{$}}
+; CHECK: .backend_stack_size: 0x3c{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x20{{$}}
; CHECK-LABEL: chain_and_wwf:
-; CHECK: .backend_stack_size: 0x50{{$}}
+; CHECK: .backend_stack_size: 0x6c{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x50{{$}}
; CHECK-LABEL: chain_callee_larger_stack:
; CHECK: .backend_stack_size: 0x8{{$}}
@@ -53,11 +66,20 @@
; CHECK: .backend_stack_size: 0x24{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x24{{$}}
; CHECK-LABEL: chain_indirect_and_wwf:
-; CHECK: .backend_stack_size: 0x40{{$}}
+; CHECK: .backend_stack_size: 0x5c{{$}}
+; CHECK: .stack_frame_size_in_bytes: 0x40{{$}}
+; CHECK-LABEL: chain_indirect_gfx_and_wwf:
+; CHECK: .backend_stack_size: 0x5c{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x40{{$}}
+; CHECK-LABEL: chain_own_and_callee_stack:
+; CHECK: .backend_stack_size: 0x44{{$}}
+; CHECK: .stack_frame_size_in_bytes: 0x20{{$}}
; CHECK-LABEL: gfx_alloca:
; CHECK: .backend_stack_size: 0x1c{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x1c{{$}}
+; CHECK-LABEL: gfx_stack_only:
+; CHECK: .backend_stack_size: 0x14{{$}}
+; CHECK: .stack_frame_size_in_bytes: 0x14{{$}}
; CHECK:amdpal.version:
; CHECK-NEXT: - 0x3
; CHECK-NEXT: - 0
@@ -137,11 +159,41 @@ define amdgpu_cs_chain void @chain_indirect_and_wwf(ptr inreg %callee, <40 x i32
unreachable
}
+define amdgpu_cs_chain void @chain_indirect_gfx_and_wwf(ptr inreg %callee) {
+.entry:
+ %a = alloca [12 x i32], addrspace(5)
+ store i32 11, ptr addrspace(5) %a
+ call void (ptr, ...) @llvm.amdgcn.call.whole.wave(ptr @wwf_alloca, ptr addrspace(5) %a)
+ call amdgpu_gfx void %callee()
+ ret void
+}
+
define amdgpu_cs_chain_preserve void @amdgpu_cs_chain_preserve_func() {
.entry:
ret void
}
+; Stack sizes accumulate transitively through non-chain callees, across calling
+; conventions.
+define amdgpu_gfx void @gfx_stack_only() {
+ %a = alloca [4 x i32], addrspace(5)
+ store volatile i32 12, ptr addrspace(5) %a
+ ret void
+}
+
+define amdgpu_gfx_whole_wave void @wwf_callee_stack_only(i1 %active) {
+ call amdgpu_gfx void @gfx_stack_only()
+ ret void
+}
+
+define amdgpu_cs_chain void @chain_own_and_callee_stack() {
+.entry:
+ %a = alloca [4 x i32], addrspace(5)
+ store volatile i32 13, ptr addrspace(5) %a
+ call void (ptr, ...) @llvm.amdgcn.call.whole.wave(ptr @wwf_callee_stack_only)
+ ret void
+}
+
declare void @llvm.amdgcn.call.whole.wave(ptr, ...)
declare void @llvm.amdgcn.cs.chain.p0.i32.s.v40i32(ptr, i32, {}, <40 x i32>, i32 immarg, ...)
diff --git a/llvm/test/CodeGen/AMDGPU/pal-metadata-3.0-callable-dvgpr.ll b/llvm/test/CodeGen/AMDGPU/pal-metadata-3.0-callable-dvgpr.ll
index 1c570d6d21358a..95bea92f331e96 100644
--- a/llvm/test/CodeGen/AMDGPU/pal-metadata-3.0-callable-dvgpr.ll
+++ b/llvm/test/CodeGen/AMDGPU/pal-metadata-3.0-callable-dvgpr.ll
@@ -91,7 +91,7 @@
; CHECK-NEXT: .stack_frame_size_in_bytes: 0
; CHECK-NEXT: .vgpr_count: 0x1
; CHECK-NEXT: no_stack_call:
-; CHECK-NEXT: .backend_stack_size: 0x10
+; CHECK-NEXT: .backend_stack_size: 0x24
; CHECK-NEXT: .lds_size: 0
; CHECK-NEXT: .sgpr_count: 0x22
; CHECK-NEXT: .stack_frame_size_in_bytes: 0x10
@@ -133,7 +133,7 @@
; CHECK-NEXT: .stack_frame_size_in_bytes: 0x14
; CHECK-NEXT: .vgpr_count: 0x2
; CHECK-NEXT: simple_stack_call:
-; CHECK-NEXT: .backend_stack_size: 0x20
+; CHECK-NEXT: .backend_stack_size: 0x34
; CHECK-NEXT: .lds_size: 0
; CHECK-NEXT: .sgpr_count: 0x22
; CHECK-NEXT: .stack_frame_size_in_bytes: 0x20
diff --git a/llvm/test/CodeGen/AMDGPU/pal-metadata-3.0-callable.ll b/llvm/test/CodeGen/AMDGPU/pal-metadata-3.0-callable.ll
index ca0941e8cebc84..9f86587cd7bfef 100644
--- a/llvm/test/CodeGen/AMDGPU/pal-metadata-3.0-callable.ll
+++ b/llvm/test/CodeGen/AMDGPU/pal-metadata-3.0-callable.ll
@@ -92,7 +92,7 @@
; CHECK-NEXT: .stack_frame_size_in_bytes: 0
; CHECK-NEXT: .vgpr_count: 0x1
; CHECK-NEXT: no_stack_call:
-; CHECK-NEXT: .backend_stack_size: 0x10
+; CHECK-NEXT: .backend_stack_size: 0x24
; CHECK-NEXT: .lds_size: 0
; CHECK-NEXT: .sgpr_count: 0x22
; CHECK-NEXT: .stack_frame_size_in_bytes: 0x10
@@ -137,7 +137,7 @@
; CHECK-NEXT: .stack_frame_size_in_bytes: 0x14
; CHECK-NEXT: .vgpr_count: 0x2
; CHECK-NEXT: simple_stack_call:
-; CHECK-NEXT: .backend_stack_size: 0x20
+; CHECK-NEXT: .backend_stack_size: 0x34
; CHECK-NEXT: .lds_size: 0
; CHECK-NEXT: .sgpr_count: 0x22
; CHECK-NEXT: .stack_frame_size_in_bytes: 0x20
>From 0a2f2ef47c29399105e289d59c9a5ae6c406e4eb Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Tue, 27 Oct 2026 14:33:44 +0100
Subject: [PATCH 06/11] More tests + no epilogue before return
---
llvm/lib/Target/AMDGPU/SIFrameLowering.cpp | 20 +-
.../test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll | 257 ++++++++++++++++++
.../dynamic-vgpr-reserve-stack-for-cwsr.ll | 85 ++++++
3 files changed, 353 insertions(+), 9 deletions(-)
diff --git a/llvm/lib/Target/AMDGPU/SIFrameLowering.cpp b/llvm/lib/Target/AMDGPU/SIFrameLowering.cpp
index 7a18965247cbf0..5a8961b6c1ae58 100644
--- a/llvm/lib/Target/AMDGPU/SIFrameLowering.cpp
+++ b/llvm/lib/Target/AMDGPU/SIFrameLowering.cpp
@@ -940,23 +940,25 @@ void SIFrameLowering::emitEntryFunctionPrologue(MachineFunction &MF,
void SIFrameLowering::emitEntryFunctionEpilogue(MachineFunction &MF,
MachineBasicBlock &MBB) const {
- // Entry functions don't usually need an epilogue. The only exception is
- // if we have a chain call (which is the only possible tail call in an
- // entry function), in which case the current frame is becoming dead and we
- // need to reset SP to point to the base of the stack.
- const MachineFrameInfo &FrameInfo = MF.getFrameInfo();
- if (!FrameInfo.hasTailCall())
+ // Entry functions don't usually need an epilogue. The only exception is a
+ // block ending in a chain call (which is the only possible tail call in an
+ // entry function), in which case the current frame is becoming dead and we
+ // need to reset SP to point to the base of the stack. Other exits of the
+ // function, e.g. blocks ending in S_ENDPGM, don't need any of this.
+ const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
+ const SIInstrInfo *TII = ST.getInstrInfo();
+ MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
+ assert(MBBI != MBB.end() && "return block should end in a terminator");
+ if (!TII->isTailCall(*MBBI))
return;
// If the prologue has set SP and there aren't any local variables, then we
// don't need to restore anything.
+ const MachineFrameInfo &FrameInfo = MF.getFrameInfo();
if (requiresStackPointerReference(MF) && FrameInfo.getStackSize() == 0)
return;
const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
- const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
- const SIInstrInfo *TII = ST.getInstrInfo();
- MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
const DebugLoc &DL = MBBI->getDebugLoc();
Register SPReg = MFI->getStackPtrOffsetReg();
diff --git a/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll b/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll
index 3d3d1df0f619f3..71ded37c4d12f9 100644
--- a/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll
+++ b/llvm/test/CodeGen/AMDGPU/amdgpu-cs-chain-cc.ll
@@ -654,6 +654,263 @@ define amdgpu_cs void @cs_with_frame_to_chain(<3 x i32> inreg %a, <3 x i32> %b)
unreachable
}
+define amdgpu_cs void @cs_with_dyn_frame_to_chain(<3 x i32> inreg %a, <3 x i32> %b, i32 %count) #0 {
+; GISEL-GFX11-LABEL: cs_with_dyn_frame_to_chain:
+; GISEL-GFX11: ; %bb.0:
+; GISEL-GFX11-NEXT: v_lshl_add_u32 v3, v3, 2, 15
+; GISEL-GFX11-NEXT: s_mov_b32 s32, 16
+; GISEL-GFX11-NEXT: s_mov_b32 s33, 0
+; GISEL-GFX11-NEXT: s_mov_b32 s3, s32
+; GISEL-GFX11-NEXT: s_delay_alu instid0(VALU_DEP_1)
+; GISEL-GFX11-NEXT: v_and_b32_e32 v3, -16, v3
+; GISEL-GFX11-NEXT: s_or_saveexec_b32 s4, -1
+; GISEL-GFX11-NEXT: s_delay_alu instid0(VALU_DEP_1) | instid1(SALU_CYCLE_1)
+; GISEL-GFX11-NEXT: v_cndmask_b32_e64 v4, 0, v3, s4
+; GISEL-GFX11-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
+; GISEL-GFX11-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:1 row_mask:0xf bank_mask:0xf
+; GISEL-GFX11-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:2 row_mask:0xf bank_mask:0xf
+; GISEL-GFX11-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
+; GISEL-GFX11-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:4 row_mask:0xf bank_mask:0xf
+; GISEL-GFX11-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:8 row_mask:0xf bank_mask:0xf
+; GISEL-GFX11-NEXT: ds_swizzle_b32 v5, v4 offset:swizzle(BROADCAST,32,15)
+; GISEL-GFX11-NEXT: s_waitcnt lgkmcnt(0)
+; GISEL-GFX11-NEXT: v_max_u32_e32 v4, v4, v5
+; GISEL-GFX11-NEXT: s_delay_alu instid0(VALU_DEP_1)
+; GISEL-GFX11-NEXT: v_readlane_b32 s6, v4, 31
+; GISEL-GFX11-NEXT: s_mov_b32 exec_lo, s4
+; GISEL-GFX11-NEXT: v_dual_mov_b32 v3, 42 :: v_dual_mov_b32 v8, v0
+; GISEL-GFX11-NEXT: v_dual_mov_b32 v9, v1 :: v_dual_mov_b32 v10, v2
+; GISEL-GFX11-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; GISEL-GFX11-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; GISEL-GFX11-NEXT: s_add_u32 s32, s3, s6
+; GISEL-GFX11-NEXT: scratch_store_b32 off, v3, s3
+; GISEL-GFX11-NEXT: s_mov_b32 s32, 0
+; GISEL-GFX11-NEXT: s_mov_b32 exec_lo, -1
+; GISEL-GFX11-NEXT: s_setpc_b64 s[4:5]
+;
+; GISEL-GFX10-LABEL: cs_with_dyn_frame_to_chain:
+; GISEL-GFX10: ; %bb.0:
+; GISEL-GFX10-NEXT: s_getpc_b64 s[100:101]
+; GISEL-GFX10-NEXT: s_mov_b32 s100, s0
+; GISEL-GFX10-NEXT: v_lshl_add_u32 v3, v3, 2, 15
+; GISEL-GFX10-NEXT: s_load_dwordx4 s[100:103], s[100:101], 0x10
+; GISEL-GFX10-NEXT: s_movk_i32 s32, 0x200
+; GISEL-GFX10-NEXT: s_mov_b32 s33, 0
+; GISEL-GFX10-NEXT: v_and_b32_e32 v3, -16, v3
+; GISEL-GFX10-NEXT: s_waitcnt lgkmcnt(0)
+; GISEL-GFX10-NEXT: s_bitset0_b32 s103, 21
+; GISEL-GFX10-NEXT: s_add_u32 s100, s100, s3
+; GISEL-GFX10-NEXT: s_addc_u32 s101, s101, 0
+; GISEL-GFX10-NEXT: s_mov_b32 s3, s32
+; GISEL-GFX10-NEXT: s_or_saveexec_b32 s4, -1
+; GISEL-GFX10-NEXT: v_cndmask_b32_e64 v4, 0, v3, s4
+; GISEL-GFX10-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:1 row_mask:0xf bank_mask:0xf
+; GISEL-GFX10-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:2 row_mask:0xf bank_mask:0xf
+; GISEL-GFX10-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:4 row_mask:0xf bank_mask:0xf
+; GISEL-GFX10-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:8 row_mask:0xf bank_mask:0xf
+; GISEL-GFX10-NEXT: ds_swizzle_b32 v5, v4 offset:swizzle(BROADCAST,32,15)
+; GISEL-GFX10-NEXT: s_waitcnt lgkmcnt(0)
+; GISEL-GFX10-NEXT: v_max_u32_e32 v4, v4, v5
+; GISEL-GFX10-NEXT: v_readlane_b32 s6, v4, 31
+; GISEL-GFX10-NEXT: s_mov_b32 exec_lo, s4
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v3, 42
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v6, s3
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v8, v0
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v9, v1
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v10, v2
+; GISEL-GFX10-NEXT: s_lshl_b32 s6, s6, 5
+; GISEL-GFX10-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; GISEL-GFX10-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; GISEL-GFX10-NEXT: s_mov_b64 s[48:49], s[100:101]
+; GISEL-GFX10-NEXT: s_mov_b64 s[50:51], s[102:103]
+; GISEL-GFX10-NEXT: s_add_u32 s32, s3, s6
+; GISEL-GFX10-NEXT: buffer_store_dword v3, v6, s[100:103], 0 offen
+; GISEL-GFX10-NEXT: s_mov_b32 s32, 0
+; GISEL-GFX10-NEXT: s_mov_b32 exec_lo, -1
+; GISEL-GFX10-NEXT: s_setpc_b64 s[4:5]
+;
+; DAGISEL-GFX11-LABEL: cs_with_dyn_frame_to_chain:
+; DAGISEL-GFX11: ; %bb.0:
+; DAGISEL-GFX11-NEXT: v_lshl_add_u32 v3, v3, 2, 15
+; DAGISEL-GFX11-NEXT: s_mov_b32 s33, 0
+; DAGISEL-GFX11-NEXT: s_mov_b32 s32, 16
+; DAGISEL-GFX11-NEXT: s_delay_alu instid0(VALU_DEP_1)
+; DAGISEL-GFX11-NEXT: v_and_b32_e32 v3, -16, v3
+; DAGISEL-GFX11-NEXT: s_or_saveexec_b32 s3, -1
+; DAGISEL-GFX11-NEXT: s_delay_alu instid0(VALU_DEP_1) | instid1(SALU_CYCLE_1)
+; DAGISEL-GFX11-NEXT: v_cndmask_b32_e64 v4, 0, v3, s3
+; DAGISEL-GFX11-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
+; DAGISEL-GFX11-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:1 row_mask:0xf bank_mask:0xf
+; DAGISEL-GFX11-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:2 row_mask:0xf bank_mask:0xf
+; DAGISEL-GFX11-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
+; DAGISEL-GFX11-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:4 row_mask:0xf bank_mask:0xf
+; DAGISEL-GFX11-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:8 row_mask:0xf bank_mask:0xf
+; DAGISEL-GFX11-NEXT: ds_swizzle_b32 v5, v4 offset:swizzle(BROADCAST,32,15)
+; DAGISEL-GFX11-NEXT: s_waitcnt lgkmcnt(0)
+; DAGISEL-GFX11-NEXT: v_max_u32_e32 v4, v4, v5
+; DAGISEL-GFX11-NEXT: s_delay_alu instid0(VALU_DEP_1)
+; DAGISEL-GFX11-NEXT: v_readlane_b32 s4, v4, 31
+; DAGISEL-GFX11-NEXT: s_mov_b32 exec_lo, s3
+; DAGISEL-GFX11-NEXT: s_mov_b32 s3, s32
+; DAGISEL-GFX11-NEXT: v_dual_mov_b32 v6, 42 :: v_dual_mov_b32 v9, v1
+; DAGISEL-GFX11-NEXT: v_add_nc_u32_e64 v3, s3, s4
+; DAGISEL-GFX11-NEXT: v_mov_b32_e32 v8, v0
+; DAGISEL-GFX11-NEXT: v_mov_b32_e32 v10, v2
+; DAGISEL-GFX11-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; DAGISEL-GFX11-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; DAGISEL-GFX11-NEXT: v_readfirstlane_b32 s32, v3
+; DAGISEL-GFX11-NEXT: scratch_store_b32 off, v6, s3
+; DAGISEL-GFX11-NEXT: s_mov_b32 s32, 0
+; DAGISEL-GFX11-NEXT: s_mov_b32 exec_lo, -1
+; DAGISEL-GFX11-NEXT: s_setpc_b64 s[4:5]
+;
+; DAGISEL-GFX10-LABEL: cs_with_dyn_frame_to_chain:
+; DAGISEL-GFX10: ; %bb.0:
+; DAGISEL-GFX10-NEXT: s_getpc_b64 s[100:101]
+; DAGISEL-GFX10-NEXT: s_mov_b32 s100, s0
+; DAGISEL-GFX10-NEXT: v_lshl_add_u32 v3, v3, 2, 15
+; DAGISEL-GFX10-NEXT: s_load_dwordx4 s[100:103], s[100:101], 0x10
+; DAGISEL-GFX10-NEXT: s_mov_b32 s33, 0
+; DAGISEL-GFX10-NEXT: s_movk_i32 s32, 0x200
+; DAGISEL-GFX10-NEXT: v_and_b32_e32 v3, -16, v3
+; DAGISEL-GFX10-NEXT: s_waitcnt lgkmcnt(0)
+; DAGISEL-GFX10-NEXT: s_bitset0_b32 s103, 21
+; DAGISEL-GFX10-NEXT: s_add_u32 s100, s100, s3
+; DAGISEL-GFX10-NEXT: s_addc_u32 s101, s101, 0
+; DAGISEL-GFX10-NEXT: s_or_saveexec_b32 s3, -1
+; DAGISEL-GFX10-NEXT: v_cndmask_b32_e64 v4, 0, v3, s3
+; DAGISEL-GFX10-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:1 row_mask:0xf bank_mask:0xf
+; DAGISEL-GFX10-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:2 row_mask:0xf bank_mask:0xf
+; DAGISEL-GFX10-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:4 row_mask:0xf bank_mask:0xf
+; DAGISEL-GFX10-NEXT: v_max_u32_dpp v4, v4, v4 row_shr:8 row_mask:0xf bank_mask:0xf
+; DAGISEL-GFX10-NEXT: ds_swizzle_b32 v5, v4 offset:swizzle(BROADCAST,32,15)
+; DAGISEL-GFX10-NEXT: s_waitcnt lgkmcnt(0)
+; DAGISEL-GFX10-NEXT: v_max_u32_e32 v4, v4, v5
+; DAGISEL-GFX10-NEXT: v_readlane_b32 s4, v4, 31
+; DAGISEL-GFX10-NEXT: s_mov_b32 exec_lo, s3
+; DAGISEL-GFX10-NEXT: s_mov_b32 s3, s32
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v6, 42
+; DAGISEL-GFX10-NEXT: v_lshl_add_u32 v3, s4, 5, s3
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v8, v0
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v9, v1
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v10, v2
+; DAGISEL-GFX10-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; DAGISEL-GFX10-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; DAGISEL-GFX10-NEXT: s_mov_b64 s[48:49], s[100:101]
+; DAGISEL-GFX10-NEXT: s_mov_b64 s[50:51], s[102:103]
+; DAGISEL-GFX10-NEXT: v_readfirstlane_b32 s32, v3
+; DAGISEL-GFX10-NEXT: buffer_store_dword v6, off, s[100:103], s3
+; DAGISEL-GFX10-NEXT: s_mov_b32 s32, 0
+; DAGISEL-GFX10-NEXT: s_mov_b32 exec_lo, -1
+; DAGISEL-GFX10-NEXT: s_setpc_b64 s[4:5]
+ %v = alloca i32, i32 %count, addrspace(5)
+ store i32 42, ptr addrspace(5) %v
+ call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr @chain_callee, i32 -1, <3 x i32> inreg %a, <3 x i32> %b, i32 0)
+ unreachable
+}
+
+; Only the block performing the chain call needs to reset SP.
+define amdgpu_cs void @cs_with_frame_to_chain_or_endpgm(<3 x i32> inreg %a, <3 x i32> %b, i32 inreg %x) #0 {
+; GISEL-GFX11-LABEL: cs_with_frame_to_chain_or_endpgm:
+; GISEL-GFX11: ; %bb.0:
+; GISEL-GFX11-NEXT: v_mov_b32_e32 v3, 42
+; GISEL-GFX11-NEXT: s_cmp_ge_u32 s3, 42
+; GISEL-GFX11-NEXT: scratch_store_b32 off, v3, off
+; GISEL-GFX11-NEXT: s_cbranch_scc0 .LBB8_2
+; GISEL-GFX11-NEXT: ; %bb.1: ; %end
+; GISEL-GFX11-NEXT: s_endpgm
+; GISEL-GFX11-NEXT: .LBB8_2: ; %tail
+; GISEL-GFX11-NEXT: v_dual_mov_b32 v8, v0 :: v_dual_mov_b32 v9, v1
+; GISEL-GFX11-NEXT: v_mov_b32_e32 v10, v2
+; GISEL-GFX11-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; GISEL-GFX11-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; GISEL-GFX11-NEXT: s_mov_b32 s32, 0
+; GISEL-GFX11-NEXT: s_mov_b32 exec_lo, -1
+; GISEL-GFX11-NEXT: s_setpc_b64 s[4:5]
+;
+; GISEL-GFX10-LABEL: cs_with_frame_to_chain_or_endpgm:
+; GISEL-GFX10: ; %bb.0:
+; GISEL-GFX10-NEXT: s_getpc_b64 s[100:101]
+; GISEL-GFX10-NEXT: s_mov_b32 s100, s0
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v3, 42
+; GISEL-GFX10-NEXT: s_load_dwordx4 s[100:103], s[100:101], 0x10
+; GISEL-GFX10-NEXT: s_waitcnt lgkmcnt(0)
+; GISEL-GFX10-NEXT: s_bitset0_b32 s103, 21
+; GISEL-GFX10-NEXT: s_add_u32 s100, s100, s4
+; GISEL-GFX10-NEXT: s_addc_u32 s101, s101, 0
+; GISEL-GFX10-NEXT: s_cmp_ge_u32 s3, 42
+; GISEL-GFX10-NEXT: buffer_store_dword v3, off, s[100:103], 0
+; GISEL-GFX10-NEXT: s_cbranch_scc0 .LBB8_2
+; GISEL-GFX10-NEXT: ; %bb.1: ; %end
+; GISEL-GFX10-NEXT: s_endpgm
+; GISEL-GFX10-NEXT: .LBB8_2: ; %tail
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v8, v0
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v9, v1
+; GISEL-GFX10-NEXT: v_mov_b32_e32 v10, v2
+; GISEL-GFX10-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; GISEL-GFX10-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; GISEL-GFX10-NEXT: s_mov_b64 s[48:49], s[100:101]
+; GISEL-GFX10-NEXT: s_mov_b64 s[50:51], s[102:103]
+; GISEL-GFX10-NEXT: s_mov_b32 s32, 0
+; GISEL-GFX10-NEXT: s_mov_b32 exec_lo, -1
+; GISEL-GFX10-NEXT: s_setpc_b64 s[4:5]
+;
+; DAGISEL-GFX11-LABEL: cs_with_frame_to_chain_or_endpgm:
+; DAGISEL-GFX11: ; %bb.0:
+; DAGISEL-GFX11-NEXT: v_mov_b32_e32 v3, 42
+; DAGISEL-GFX11-NEXT: s_cmp_gt_u32 s3, 41
+; DAGISEL-GFX11-NEXT: scratch_store_b32 off, v3, off
+; DAGISEL-GFX11-NEXT: s_cbranch_scc0 .LBB8_2
+; DAGISEL-GFX11-NEXT: ; %bb.1: ; %end
+; DAGISEL-GFX11-NEXT: s_endpgm
+; DAGISEL-GFX11-NEXT: .LBB8_2: ; %tail
+; DAGISEL-GFX11-NEXT: v_dual_mov_b32 v8, v0 :: v_dual_mov_b32 v9, v1
+; DAGISEL-GFX11-NEXT: v_mov_b32_e32 v10, v2
+; DAGISEL-GFX11-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; DAGISEL-GFX11-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; DAGISEL-GFX11-NEXT: s_mov_b32 s32, 0
+; DAGISEL-GFX11-NEXT: s_mov_b32 exec_lo, -1
+; DAGISEL-GFX11-NEXT: s_setpc_b64 s[4:5]
+;
+; DAGISEL-GFX10-LABEL: cs_with_frame_to_chain_or_endpgm:
+; DAGISEL-GFX10: ; %bb.0:
+; DAGISEL-GFX10-NEXT: s_getpc_b64 s[100:101]
+; DAGISEL-GFX10-NEXT: s_mov_b32 s100, s0
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v3, 42
+; DAGISEL-GFX10-NEXT: s_load_dwordx4 s[100:103], s[100:101], 0x10
+; DAGISEL-GFX10-NEXT: s_waitcnt lgkmcnt(0)
+; DAGISEL-GFX10-NEXT: s_bitset0_b32 s103, 21
+; DAGISEL-GFX10-NEXT: s_add_u32 s100, s100, s4
+; DAGISEL-GFX10-NEXT: s_addc_u32 s101, s101, 0
+; DAGISEL-GFX10-NEXT: s_cmp_gt_u32 s3, 41
+; DAGISEL-GFX10-NEXT: buffer_store_dword v3, off, s[100:103], 0
+; DAGISEL-GFX10-NEXT: s_cbranch_scc0 .LBB8_2
+; DAGISEL-GFX10-NEXT: ; %bb.1: ; %end
+; DAGISEL-GFX10-NEXT: s_endpgm
+; DAGISEL-GFX10-NEXT: .LBB8_2: ; %tail
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v8, v0
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v9, v1
+; DAGISEL-GFX10-NEXT: v_mov_b32_e32 v10, v2
+; DAGISEL-GFX10-NEXT: s_mov_b32 s5, chain_callee at abs32@hi
+; DAGISEL-GFX10-NEXT: s_mov_b32 s4, chain_callee at abs32@lo
+; DAGISEL-GFX10-NEXT: s_mov_b64 s[48:49], s[100:101]
+; DAGISEL-GFX10-NEXT: s_mov_b64 s[50:51], s[102:103]
+; DAGISEL-GFX10-NEXT: s_mov_b32 s32, 0
+; DAGISEL-GFX10-NEXT: s_mov_b32 exec_lo, -1
+; DAGISEL-GFX10-NEXT: s_setpc_b64 s[4:5]
+ %v = alloca i32, addrspace(5)
+ store i32 42, ptr addrspace(5) %v
+ %cond = icmp ult i32 %x, 42
+ br i1 %cond, label %tail, label %end
+
+tail:
+ call void(ptr, i32, <3 x i32>, <3 x i32>, i32, ...) @llvm.amdgcn.cs.chain.v3i32(ptr @chain_callee, i32 -1, <3 x i32> inreg %a, <3 x i32> %b, i32 0)
+ unreachable
+
+end:
+ ret void
+}
+
define amdgpu_cs_chain void @chain_to_chain(<3 x i32> inreg %a, <3 x i32> %b) #0 {
; GISEL-GFX11-LABEL: chain_to_chain:
; GISEL-GFX11: ; %bb.0:
diff --git a/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll b/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll
index 9f8e70602a8284..28b61901456628 100644
--- a/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll
+++ b/llvm/test/CodeGen/AMDGPU/dynamic-vgpr-reserve-stack-for-cwsr.ll
@@ -175,6 +175,91 @@ define amdgpu_cs void @with_chain_call() #0 {
unreachable
}
+define amdgpu_cs void @with_chain_call_dyn_local(i32 %count) #0 {
+; CHECK-TRUE16-LABEL: with_chain_call_dyn_local:
+; CHECK-TRUE16: ; %bb.0:
+; CHECK-TRUE16-NEXT: v_lshl_add_u32 v0, v0, 2, 15
+; CHECK-TRUE16-NEXT: s_getreg_b32 s33, hwreg(HW_REG_WAVE_HW_ID2, 8, 2)
+; CHECK-TRUE16-NEXT: s_delay_alu instid0(SALU_CYCLE_1)
+; CHECK-TRUE16-NEXT: s_cmp_lg_u32 0, s33
+; CHECK-TRUE16-NEXT: s_cmovk_i32 s33, 0x1c0
+; CHECK-TRUE16-NEXT: s_cselect_b32 s32, 0x1d0, 16
+; CHECK-TRUE16-NEXT: v_and_b32_e32 v0, -16, v0
+; CHECK-TRUE16-NEXT: s_or_saveexec_b32 s0, -1
+; CHECK-TRUE16-NEXT: s_delay_alu instid0(VALU_DEP_1) | instid1(SALU_CYCLE_1)
+; CHECK-TRUE16-NEXT: v_cndmask_b32_e64 v1, 0, v0, s0
+; CHECK-TRUE16-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
+; CHECK-TRUE16-NEXT: v_max_u32_dpp v1, v1, v1 row_shr:1 row_mask:0xf bank_mask:0xf
+; CHECK-TRUE16-NEXT: v_max_u32_dpp v1, v1, v1 row_shr:2 row_mask:0xf bank_mask:0xf
+; CHECK-TRUE16-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
+; CHECK-TRUE16-NEXT: v_max_u32_dpp v1, v1, v1 row_shr:4 row_mask:0xf bank_mask:0xf
+; CHECK-TRUE16-NEXT: v_max_u32_dpp v1, v1, v1 row_shr:8 row_mask:0xf bank_mask:0xf
+; CHECK-TRUE16-NEXT: ds_swizzle_b32 v2, v1 offset:swizzle(BROADCAST,32,15)
+; CHECK-TRUE16-NEXT: s_wait_dscnt 0x0
+; CHECK-TRUE16-NEXT: v_max_u32_e32 v1, v1, v2
+; CHECK-TRUE16-NEXT: s_delay_alu instid0(VALU_DEP_1)
+; CHECK-TRUE16-NEXT: v_readlane_b32 s1, v1, 31
+; CHECK-TRUE16-NEXT: s_mov_b32 exec_lo, s0
+; CHECK-TRUE16-NEXT: s_mov_b32 s0, s32
+; CHECK-TRUE16-NEXT: v_mov_b16_e32 v0.l, 13
+; CHECK-TRUE16-NEXT: s_wait_alu depctr_sa_sdst(0)
+; CHECK-TRUE16-NEXT: v_add_nc_u32_e64 v3, s0, s1
+; CHECK-TRUE16-NEXT: v_mov_b32_e32 v8, 0
+; CHECK-TRUE16-NEXT: s_mov_b32 s3, chain_callee at abs32@hi
+; CHECK-TRUE16-NEXT: s_mov_b32 s2, chain_callee at abs32@lo
+; CHECK-TRUE16-NEXT: scratch_store_b8 off, v0, s0 scope:SCOPE_SYS
+; CHECK-TRUE16-NEXT: s_wait_storecnt 0x0
+; CHECK-TRUE16-NEXT: s_mov_b32 s0, 0
+; CHECK-TRUE16-NEXT: v_readfirstlane_b32 s32, v3
+; CHECK-TRUE16-NEXT: s_mov_b32 s32, s33
+; CHECK-TRUE16-NEXT: s_mov_b32 exec_lo, -1
+; CHECK-TRUE16-NEXT: s_wait_alu depctr_sa_sdst(0)
+; CHECK-TRUE16-NEXT: s_setpc_b64 s[2:3]
+;
+; CHECK-FAKE16-LABEL: with_chain_call_dyn_local:
+; CHECK-FAKE16: ; %bb.0:
+; CHECK-FAKE16-NEXT: v_lshl_add_u32 v0, v0, 2, 15
+; CHECK-FAKE16-NEXT: s_getreg_b32 s33, hwreg(HW_REG_WAVE_HW_ID2, 8, 2)
+; CHECK-FAKE16-NEXT: s_delay_alu instid0(SALU_CYCLE_1)
+; CHECK-FAKE16-NEXT: s_cmp_lg_u32 0, s33
+; CHECK-FAKE16-NEXT: s_cmovk_i32 s33, 0x1c0
+; CHECK-FAKE16-NEXT: s_cselect_b32 s32, 0x1d0, 16
+; CHECK-FAKE16-NEXT: v_and_b32_e32 v0, -16, v0
+; CHECK-FAKE16-NEXT: s_or_saveexec_b32 s0, -1
+; CHECK-FAKE16-NEXT: s_delay_alu instid0(VALU_DEP_1) | instid1(SALU_CYCLE_1)
+; CHECK-FAKE16-NEXT: v_cndmask_b32_e64 v1, 0, v0, s0
+; CHECK-FAKE16-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
+; CHECK-FAKE16-NEXT: v_max_u32_dpp v1, v1, v1 row_shr:1 row_mask:0xf bank_mask:0xf
+; CHECK-FAKE16-NEXT: v_max_u32_dpp v1, v1, v1 row_shr:2 row_mask:0xf bank_mask:0xf
+; CHECK-FAKE16-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
+; CHECK-FAKE16-NEXT: v_max_u32_dpp v1, v1, v1 row_shr:4 row_mask:0xf bank_mask:0xf
+; CHECK-FAKE16-NEXT: v_max_u32_dpp v1, v1, v1 row_shr:8 row_mask:0xf bank_mask:0xf
+; CHECK-FAKE16-NEXT: ds_swizzle_b32 v2, v1 offset:swizzle(BROADCAST,32,15)
+; CHECK-FAKE16-NEXT: s_wait_dscnt 0x0
+; CHECK-FAKE16-NEXT: v_max_u32_e32 v1, v1, v2
+; CHECK-FAKE16-NEXT: s_delay_alu instid0(VALU_DEP_1)
+; CHECK-FAKE16-NEXT: v_readlane_b32 s1, v1, 31
+; CHECK-FAKE16-NEXT: s_mov_b32 exec_lo, s0
+; CHECK-FAKE16-NEXT: s_mov_b32 s0, s32
+; CHECK-FAKE16-NEXT: v_dual_mov_b32 v3, 13 :: v_dual_mov_b32 v8, 0
+; CHECK-FAKE16-NEXT: s_wait_alu depctr_sa_sdst(0)
+; CHECK-FAKE16-NEXT: v_add_nc_u32_e64 v0, s0, s1
+; CHECK-FAKE16-NEXT: s_mov_b32 s3, chain_callee at abs32@hi
+; CHECK-FAKE16-NEXT: s_mov_b32 s2, chain_callee at abs32@lo
+; CHECK-FAKE16-NEXT: scratch_store_b8 off, v3, s0 scope:SCOPE_SYS
+; CHECK-FAKE16-NEXT: s_wait_storecnt 0x0
+; CHECK-FAKE16-NEXT: s_mov_b32 s0, 0
+; CHECK-FAKE16-NEXT: v_readfirstlane_b32 s32, v0
+; CHECK-FAKE16-NEXT: s_mov_b32 s32, s33
+; CHECK-FAKE16-NEXT: s_mov_b32 exec_lo, -1
+; CHECK-FAKE16-NEXT: s_wait_alu depctr_sa_sdst(0)
+; CHECK-FAKE16-NEXT: s_setpc_b64 s[2:3]
+ %local = alloca i32, i32 %count, addrspace(5)
+ store volatile i8 13, ptr addrspace(5) %local
+ call void(ptr, i32, i32, i32, i32, ...) @llvm.amdgcn.cs.chain(ptr @chain_callee, i32 -1, i32 inreg 0, i32 0, i32 0)
+ unreachable
+}
+
; No local frame - SP doesn't need to be adjusted.
define amdgpu_cs void @with_chain_call_no_local() #0 {
; CHECK-LABEL: with_chain_call_no_local:
>From 0c5fd955e14a40872170c141aaf1d52be8a34356 Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Tue, 27 Oct 2026 16:11:21 +0100
Subject: [PATCH 07/11] Test with assumed ext stack size
---
.../Target/AMDGPU/AMDGPUMCResourceInfo.cpp | 2 +-
.../CodeGen/AMDGPU/amdpal-chain-metadata.ll | 32 +++++++++++++++----
2 files changed, 26 insertions(+), 8 deletions(-)
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
index a33a1d3c8fc05a..8a5e277f2b394f 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp
@@ -372,7 +372,7 @@ void MCResourceInfo::gatherResourceInfo(
if (!Seen.insert(Callee).second)
continue;
- // Chain callees use the same stack frame. Exclude them.
+ // Chain callees use the same stack space. Exclude them.
if (!Callee->isDeclaration() &&
!AMDGPU::isChainCC(Callee->getCallingConv())) {
MCSymbol *CalleeFnSym = TM.getSymbol(&Callee->getFunction());
diff --git a/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll b/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
index d972dd7884902e..5ce284f901ee8f 100644
--- a/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
+++ b/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
@@ -1,7 +1,9 @@
-; RUN: llc -mtriple=amdgpu11.00--amdpal <%s | FileCheck %s
+; RUN: llc -mtriple=amdgpu11.00--amdpal < %s | FileCheck --check-prefixes=CHECK,EXTSTACK0 %s
+; RUN: llc -mtriple=amdgpu12.00--amdpal -amdgpu-assume-external-call-stack-size=48 < %s | FileCheck --check-prefixes=CHECK,EXTSTACK48 %s
; CHECK-LABEL: {{^}}amdgpu_cs_chain_func:
-; CHECK: .set .Lamdgpu_cs_chain_func.private_seg_size, 16{{$}}
+; EXTSTACK0: .set .Lamdgpu_cs_chain_func.private_seg_size, 16{{$}}
+; EXTSTACK48: .set .Lamdgpu_cs_chain_func.private_seg_size, 16+max(48){{$}}
; CHECK-LABEL: {{^}}chain_callee_smaller_stack:
; CHECK: .set .Lchain_callee_smaller_stack.private_seg_size, 36{{$}}
@@ -24,10 +26,17 @@
; CHECK-LABEL: {{^}}cs_to_chain_and_wwf:
; CHECK: .set .Lcs_to_chain_and_wwf.private_seg_size, 12{{$}}
+; Indirect chain calls don't contribute to the stack size.
; CHECK-LABEL: {{^}}chain_indirect_and_wwf:
; CHECK: .set .Lchain_indirect_and_wwf.private_seg_size, 64+max(.Lwwf_alloca.private_seg_size){{$}}
; CHECK: .set .Lchain_indirect_and_wwf.has_indirect_call, 1{{$}}
+; A non-chain indirect call does contribute the assumed external stack size.
+; CHECK-LABEL: {{^}}chain_and_indirect_gfx:
+; EXTSTACK0: .set .Lchain_and_indirect_gfx.private_seg_size, 32{{$}}
+; EXTSTACK48: .set .Lchain_and_indirect_gfx.private_seg_size, 32+max(48){{$}}
+; CHECK: .set .Lchain_and_indirect_gfx.has_indirect_call, 1{{$}}
+
; CHECK-LABEL: .amdgpu_pal_metadata
; CHECK-NEXT: ---
; CHECK-NEXT: amdpal.pipelines:
@@ -43,6 +52,9 @@
; CHECK-LABEL: chain_and_gfx:
; CHECK: .backend_stack_size: 0x20{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x20{{$}}
+; CHECK-LABEL: chain_and_indirect_gfx:
+; CHECK: .backend_stack_size: 0x20{{$}}
+; CHECK: .stack_frame_size_in_bytes: 0x20{{$}}
; CHECK-LABEL: chain_and_wwf:
; CHECK: .backend_stack_size: 0x50{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x50{{$}}
@@ -97,7 +109,7 @@ define amdgpu_cs_chain void @chain_and_wwf(<40 x i32> %v) {
unreachable
}
-define amdgpu_gfx_whole_wave void @wwf_alloca(i1 %active, ptr addrspace(5) %p) {
+define amdgpu_gfx_whole_wave void @wwf_alloca(i1 %active, ptr addrspace(5) %p) norecurse {
%a = alloca [4 x i32], addrspace(5)
store volatile i32 3, ptr addrspace(5) %a
store i32 4, ptr addrspace(5) %p
@@ -113,7 +125,7 @@ define amdgpu_cs_chain void @chain_and_gfx(<40 x i32> %v) {
unreachable
}
-define amdgpu_gfx void @gfx_alloca(ptr addrspace(5) %p) {
+define amdgpu_gfx void @gfx_alloca(ptr addrspace(5) %p) norecurse {
%a = alloca [6 x i32], addrspace(5)
store volatile i32 7, ptr addrspace(5) %a
store i32 8, ptr addrspace(5) %p
@@ -137,14 +149,20 @@ define amdgpu_cs_chain void @chain_indirect_and_wwf(ptr inreg %callee, <40 x i32
unreachable
}
+define amdgpu_cs_chain void @chain_and_indirect_gfx(ptr inreg %fp, <40 x i32> %v) {
+.entry:
+ %a = alloca [5 x i32], addrspace(5)
+ store i32 11, ptr addrspace(5) %a
+ call amdgpu_gfx void %fp(ptr addrspace(5) %a)
+ call void (ptr, i32, {}, <40 x i32>, i32, ...) @llvm.amdgcn.cs.chain.p0.i32.s.v40i32(ptr @amdgpu_cs_chain_func, i32 -1, {} inreg poison, <40 x i32> %v, i32 0)
+ unreachable
+}
+
define amdgpu_cs_chain_preserve void @amdgpu_cs_chain_preserve_func() {
.entry:
ret void
}
-declare void @llvm.amdgcn.call.whole.wave(ptr, ...)
-declare void @llvm.amdgcn.cs.chain.p0.i32.s.v40i32(ptr, i32, {}, <40 x i32>, i32 immarg, ...)
-
declare amdgpu_gfx void @use(...)
!amdgpu.pal.metadata.msgpack = !{!0}
>From 9617bdb0a846ead7ae4b01356e841dd6cc2dabed Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Wed, 28 Oct 2026 09:27:52 +0100
Subject: [PATCH 08/11] Document that we can't reference caller's stack
---
llvm/docs/AMDGPUUsage.md | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/llvm/docs/AMDGPUUsage.md b/llvm/docs/AMDGPUUsage.md
index ada491098486a3..3b02e0e92d5eb8 100644
--- a/llvm/docs/AMDGPUUsage.md
+++ b/llvm/docs/AMDGPUUsage.md
@@ -3477,7 +3477,8 @@ The AMDGPU backend supports the following calling conventions:
Values in scalar registers as well as v0-v7 are not preserved.
Values in VGPRs starting at v8 are not preserved for the active lanes, but must be saved by the callee for inactive lanes when using WWM (a notable exception is when the llvm.amdgcn.init.whole.wave intrinsic is used in the function - in this case the backend assumes that there are no inactive lanes upon entry; any inactive lanes that need to be preserved must be explicitly present in the IR).
- Chain functions receive a stack pointer from their caller (in s32), similar to `amdgpu_gfx` functions.
+ Chain functions receive a stack pointer from their caller (in s32), similar to `amdgpu_gfx` functions. This points to the bottom of the stack.
+ Referencing values on the caller's stack is undefined behaviour.
If needed, the frame pointer is s33 and the base pointer is s34.
Calls to `amdgpu_gfx` functions are allowed and behave like they do in `amdgpu_cs` functions.
>From ae35701e0d2e0f81a653d8ad21938a06144b67d7 Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Wed, 28 Oct 2026 10:41:23 +0100
Subject: [PATCH 09/11] Move docs to md instead of rst
---
llvm/docs/AMDGPUUsage.md | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/llvm/docs/AMDGPUUsage.md b/llvm/docs/AMDGPUUsage.md
index 3b02e0e92d5eb8..c6963d32a9b6cf 100644
--- a/llvm/docs/AMDGPUUsage.md
+++ b/llvm/docs/AMDGPUUsage.md
@@ -16667,7 +16667,12 @@ within a map that has been added by the same *vendor-name*.
- Number of SGPRs used by the shader.
* - ".stack_frame_size_in_bytes"
- integer
- - Amount of stack size used by the shader.
+ - Amount of stack size used by the shader itself, not including the stack used by any of its callees.
+* - ".backend_stack_size"
+ - integer
+ - Amount of stack size used by the shader, including the stack used by its known callees.
+ Chain callees are excluded, since they reuse the caller's stack frame.
+ Indirect calls and recursion do not contribute.
* - ".shader_subtype"
- string
- Shader subtype/kind.
>From 1961971ee84f0963d59e04a59663b5f69afdb9ab Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Wed, 28 Oct 2026 12:21:50 +0100
Subject: [PATCH 10/11] More tests and minor fixes
---
.../Target/AMDGPU/Utils/AMDGPUPALMetadata.h | 2 +-
.../CodeGen/AMDGPU/amdpal-chain-metadata.ll | 18 +++++++++++++++++-
2 files changed, 18 insertions(+), 2 deletions(-)
diff --git a/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.h b/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.h
index e619d140fd8395..6e64df993f8ff2 100644
--- a/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.h
+++ b/llvm/lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.h
@@ -108,7 +108,7 @@ class AMDGPUPALMetadata {
void setFunctionStackFrameSize(StringRef FnName, unsigned Val);
// Set the backend stack size metadata, including the frames of its known
- // calles. Recursion and indirect/external calls must be handled by the
+ // callees. Recursion and indirect/external calls must be handled by the
// consumer.
void setFunctionBackendStackSize(StringRef FnName, const MCExpr *Val);
diff --git a/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll b/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
index 37e438c0e17838..ec25c56f203a08 100644
--- a/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
+++ b/llvm/test/CodeGen/AMDGPU/amdpal-chain-metadata.ll
@@ -26,7 +26,6 @@
; CHECK-LABEL: {{^}}cs_to_chain_and_wwf:
; CHECK: .set .Lcs_to_chain_and_wwf.private_seg_size, 12{{$}}
-; Indirect chain calls don't contribute to the stack size.
; Indirect chain calls don't contribute to the stack size.
; CHECK-LABEL: {{^}}chain_indirect_chain_and_wwf:
; CHECK: .set .Lchain_indirect_chain_and_wwf.private_seg_size, 64+max(.Lwwf_callee_alloca.private_seg_size){{$}}
@@ -54,6 +53,10 @@
; EXTSTACK0: .set .Lchain_own_and_callee_stack.private_seg_size, 32+max(.Lwwf_no_local_stack_to_gfx_with_stack.private_seg_size){{$}}
; EXTSTACK48: .set .Lchain_own_and_callee_stack.private_seg_size, 32+max(48, .Lwwf_no_local_stack_to_gfx_with_stack.private_seg_size){{$}}
+; CHECK-LABEL: {{^}}chain_realign_stack:
+; EXTSTACK0: .set .Lchain_realign_stack.private_seg_size, 256+max(.Lgfx_stack_only.private_seg_size){{$}}
+; EXTSTACK48: .set .Lchain_realign_stack.private_seg_size, 256+max(48, .Lgfx_stack_only.private_seg_size){{$}}
+
; CHECK-LABEL: .amdgpu_pal_metadata
; CHECK-NEXT: ---
; CHECK-NEXT: amdpal.pipelines:
@@ -94,6 +97,11 @@
; EXTSTACK0: .backend_stack_size: 0x44{{$}}
; EXTSTACK48: .backend_stack_size: 0x60{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x20{{$}}
+; CHECK-LABEL: chain_realign_stack:
+; EXTSTACK0: .backend_stack_size: 0x114{{$}}
+; EXTSTACK48: .backend_stack_size: 0x130{{$}}
+; FIXME: stack_frame_size_in_bytes would do well to include the realignment padding too...
+; CHECK: .stack_frame_size_in_bytes: 0x80{{$}}
; CHECK-LABEL: gfx_alloca:
; CHECK: .backend_stack_size: 0x1c{{$}}
; CHECK: .stack_frame_size_in_bytes: 0x1c{{$}}
@@ -221,6 +229,14 @@ define amdgpu_cs_chain void @chain_own_and_callee_stack() {
ret void
}
+define amdgpu_cs_chain void @chain_realign_stack() {
+.entry:
+ %a = alloca i32, align 128, addrspace(5)
+ store volatile i32 13, ptr addrspace(5) %a
+ call amdgpu_gfx void @gfx_stack_only()
+ ret void
+}
+
declare amdgpu_gfx void @use(...)
!amdgpu.pal.metadata.msgpack = !{!0}
>From 421fd90f6449fdbe11057fb99b4c62c02d22fbbe Mon Sep 17 00:00:00 2001
From: Diana Picus <diana-magda.picus at amd.com>
Date: Mon, 16 Nov 2026 14:02:42 +0100
Subject: [PATCH 11/11] in bytes
---
llvm/docs/AMDGPUUsage.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/docs/AMDGPUUsage.md b/llvm/docs/AMDGPUUsage.md
index 198ce3c7b26d1c..f7158adce27d05 100644
--- a/llvm/docs/AMDGPUUsage.md
+++ b/llvm/docs/AMDGPUUsage.md
@@ -16715,7 +16715,7 @@ within a map that has been added by the same *vendor-name*.
- Amount of stack size used by the shader itself, not including the stack used by any of its callees.
* - ".backend_stack_size"
- integer
- - Amount of stack size used by the shader, including the stack used by its known callees.
+ - Amount of stack size in bytes used by the shader, including the stack used by its known callees.
Chain callees are excluded, since they reuse the caller's stack frame.
Indirect calls and recursion do not contribute.
* - ".shader_subtype"
More information about the llvm-branch-commits
mailing list