[AMDGPU][Verifier] Mark calls to entry functions as invalid in the IR verifier

shiltian · shiltian · commit fab4fdde2a7e · 2025-04-09T10:02:17.000-04:00
For AMDGPU, calls to entry functions are invalid. Previously, due to certain limitations, this restriction was not enforced by the IR verifier. These limitations have now been resolved, enabling us to enforce this check. Adding target-dependent checks directly into the IR verifier is not ideal. However, a cleaner solution, such as a dedicated target-dependent IR verifier, is underway (e.g., #123609). Once that or similar code is merged, we can move this check accordingly.
diff --git a/llvm/include/llvm/IR/CallingConv.h b/llvm/include/llvm/IR/CallingConv.h
@@ -290,6 +290,26 @@ namespace CallingConv {
 
 } // end namespace CallingConv
 
+/// \return true if the calling convention allows the function to be called
+/// directly or indirectly via a call-like instruction.
+constexpr bool isCallableCC(CallingConv::ID CC) {
+  switch (CC) {
+  case CallingConv::AMDGPU_CS_Chain:
+  case CallingConv::AMDGPU_CS_ChainPreserve:
+  case CallingConv::AMDGPU_CS:
+  case CallingConv::AMDGPU_ES:
+  case CallingConv::AMDGPU_GS:
+  case CallingConv::AMDGPU_HS:
+  case CallingConv::AMDGPU_KERNEL:
+  case CallingConv::AMDGPU_LS:
+  case CallingConv::AMDGPU_PS:
+  case CallingConv::AMDGPU_VS:
+    return false;
+  default:
+    return true;
+  }
+}
+
 } // end namespace llvm
 
 #endif // LLVM_IR_CALLINGCONV_H
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
@@ -3598,14 +3598,8 @@ void Verifier::visitCallBase(CallBase &Call) {
     Check(Callee->getValueType() == FTy,
           "Intrinsic called with incompatible signature", Call);
 
-  // Disallow calls to functions with the amdgpu_cs_chain[_preserve] calling
-  // convention.
-  auto CC = Call.getCallingConv();
-  Check(CC != CallingConv::AMDGPU_CS_Chain &&
-            CC != CallingConv::AMDGPU_CS_ChainPreserve,
-        "Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions "
-        "not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.",
-        Call);
+  // Verify if the calling convention of the callee is callable.
+  Check(isCallableCC(Call.getCallingConv()), "Callee is not callable", Call);
 
   // Disallow passing/returning values with alignment higher than we can
   // represent.
diff --git a/llvm/test/CodeGen/AMDGPU/attributor-flatscratchinit.ll b/llvm/test/CodeGen/AMDGPU/attributor-flatscratchinit.ll
@@ -849,21 +849,6 @@ define amdgpu_kernel void @calls_intrin_ascast_cc_kernel(ptr addrspace(3) %ptr)
   ret void
 }
 
-define amdgpu_kernel void @call_calls_intrin_ascast_cc_kernel(ptr addrspace(3) %ptr) {
-; GFX9-LABEL: define amdgpu_kernel void @call_calls_intrin_ascast_cc_kernel(
-; GFX9-SAME: ptr addrspace(3) [[PTR:%.*]]) #[[ATTR1]] {
-; GFX9-NEXT:    call void @calls_intrin_ascast_cc_kernel(ptr addrspace(3) [[PTR]])
-; GFX9-NEXT:    ret void
-;
-; GFX10-LABEL: define amdgpu_kernel void @call_calls_intrin_ascast_cc_kernel(
-; GFX10-SAME: ptr addrspace(3) [[PTR:%.*]]) #[[ATTR1]] {
-; GFX10-NEXT:    call void @calls_intrin_ascast_cc_kernel(ptr addrspace(3) [[PTR]])
-; GFX10-NEXT:    ret void
-;
-  call void @calls_intrin_ascast_cc_kernel(ptr addrspace(3) %ptr)
-  ret void
-}
-
 define amdgpu_kernel void @with_inline_asm() {
 ; GFX9-LABEL: define amdgpu_kernel void @with_inline_asm(
 ; GFX9-SAME: ) #[[ATTR3]] {
diff --git a/llvm/test/CodeGen/AMDGPU/call-to-kernel-undefined.ll b/llvm/test/CodeGen/AMDGPU/call-to-kernel-undefined.ll
diff --git a/llvm/test/CodeGen/AMDGPU/call-to-kernel.ll b/llvm/test/CodeGen/AMDGPU/call-to-kernel.ll
diff --git a/llvm/test/Verifier/amdgpu-cc.ll b/llvm/test/Verifier/amdgpu-cc.ll
@@ -217,26 +217,3 @@ define amdgpu_cs_chain_preserve void @preallocated_cc_amdgpu_cs_chain_preserve(p
 define amdgpu_cs_chain_preserve void @inalloca_cc_amdgpu_cs_chain_preserve(ptr inalloca(i32) %ptr) {
   ret void
 }
-
-declare amdgpu_cs_chain void @amdgpu_cs_chain_call_target()
-declare amdgpu_cs_chain_preserve void @amdgpu_cs_chain_preserve_call_target()
-
-define amdgpu_cs_chain void @cant_call_amdgpu_cs_chain_functions(ptr %f) {
-  ; CHECK: Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.
-  ; CHECK-NEXT: call amdgpu_cs_chain
-  call amdgpu_cs_chain void @amdgpu_cs_chain_call_target()
-
-  ; CHECK: Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.
-  ; CHECK-NEXT: call amdgpu_cs_chain_preserve
-  call amdgpu_cs_chain_preserve void @amdgpu_cs_chain_preserve_call_target()
-
-  ; CHECK: Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.
-  ; CHECK-NEXT: call amdgpu_cs_chain
-  call amdgpu_cs_chain void %f()
-
-  ; CHECK: Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.
-  ; CHECK-NEXT: call amdgpu_cs_chain
-  call amdgpu_cs_chain_preserve void %f()
-
-  ret void
-}
diff --git a/llvm/test/Verifier/call-to-non-callable-functions.ll b/llvm/test/Verifier/call-to-non-callable-functions.ll
@@ -0,0 +1,181 @@
+; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
+
+declare amdgpu_cs void @callee_cs()
+
+declare amdgpu_cs_chain void @callee_cs_chain()
+
+declare amdgpu_cs_chain_preserve void @callee_cs_chain_preserve()
+
+declare amdgpu_es void @callee_es()
+
+declare amdgpu_gs void @callee_gs()
+
+declare amdgpu_hs void @callee_hs()
+
+declare amdgpu_kernel void @callee_kernel()
+
+declare amdgpu_ls void @callee_ls()
+
+declare amdgpu_ps void @callee_ps()
+
+declare amdgpu_vs void @callee_vs()
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_cs_chain void @callee_cs_chain()
+define amdgpu_cs_chain void @caller_cs_chain() {
+entry:
+  call amdgpu_cs_chain void @callee_cs_chain()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_cs_chain_preserve void @callee_cs_chain_preserve()
+define amdgpu_cs_chain_preserve void @caller_cs_chain_preserve() {
+entry:
+  call amdgpu_cs_chain_preserve void @callee_cs_chain_preserve()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_kernel void @callee_kernel()
+define amdgpu_kernel void @caller_kernel() {
+entry:
+  call amdgpu_kernel void @callee_kernel()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_vs void @callee_vs()
+define amdgpu_vs void @caller_vs() {
+entry:
+  call amdgpu_vs void @callee_vs()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_gs void @callee_gs()
+define amdgpu_gs void @caller_gs() {
+entry:
+  call amdgpu_gs void @callee_gs()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_ps void @callee_ps()
+define amdgpu_ps void @caller_ps() {
+entry:
+  call amdgpu_ps void @callee_ps()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_cs void @callee_cs()
+define amdgpu_cs void @caller_cs() {
+entry:
+  call amdgpu_cs void @callee_cs()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_es void @callee_es()
+define amdgpu_es void @caller_es() {
+entry:
+  call amdgpu_es void @callee_es()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_hs void @callee_hs()
+define amdgpu_hs void @caller_hs() {
+entry:
+  call amdgpu_hs void @callee_hs()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_ls void @callee_ls()
+define amdgpu_ls void @caller_ls() {
+entry:
+  call amdgpu_ls void @callee_ls()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_cs_chain void %func()
+define amdgpu_cs_chain void @indirect_caller_cs_chain(ptr %func) {
+entry:
+  call amdgpu_cs_chain void %func()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_cs_chain_preserve void %func()
+define amdgpu_cs_chain_preserve void @indirect_caller_cs_chain_preserve(ptr %func) {
+entry:
+  call amdgpu_cs_chain_preserve void %func()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_kernel void %func()
+define void @indirect_caller_kernel(ptr %func) {
+entry:
+  call amdgpu_kernel void %func()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_vs void %func()
+define void @indirect_caller_vs(ptr %func) {
+entry:
+  call amdgpu_vs void %func()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_gs void %func()
+define void @indirect_caller_gs(ptr %func) {
+entry:
+  call amdgpu_gs void %func()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_ps void %func()
+define void @indirect_caller_ps(ptr %func) {
+entry:
+  call amdgpu_ps void %func()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_cs void %func()
+define void @indirect_caller_cs(ptr %func) {
+entry:
+  call amdgpu_cs void %func()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_es void %func()
+define void @indirect_caller_es(ptr %func) {
+entry:
+  call amdgpu_es void %func()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_hs void %func()
+define void @indirect_caller_hs(ptr %func) {
+entry:
+  call amdgpu_hs void %func()
+  ret void
+}
+
+; CHECK: Callee is not callable
+; CHECK-NEXT: call amdgpu_ls void %func()
+define void @indirect_caller_ls(ptr %func) {
+entry:
+  call amdgpu_ls void %func()
+  ret void
+}
