[AMDGPU][GlobalISel] Shaders can only call amdgpu_gfx

[rovka]

Summary

SelectionDAG does not allow calls:

• to shaders
• from shaders to functions with calling conventions other than amdgpu_gfx

This patch essentially copies that code into GlobalISel and enables one
of the existing SelectionDAG tests for GlobalISel as well (with a couple
of FIXMEs not tackled in this patch).

It also removes an existing test that was added in
https://reviews.llvm.org/D117479
citing llvm-reduce's penchant for replacing calls to intrinsics with
calls to undef/null (while keeping the default, C calling convention).
That sounds like an important use case, but maybe a better solution for
that problem would be to teach llvm-reduce to replace the whole call
with an undef/null. (Since intrinsics often don't get lowered to calls
at all, replacing an intrinsic with a call would increase complexity rather
than reduce it.)

[arsenm]

That sounds like an important use case, but maybe a better solution for
that problem would be to teach llvm-reduce to replace the whole call
with an undef/null.

No, because that would delete the call entirely which is a much more substantial change.

I'd lean towards just removing this artificial restriction / error altogether before regressing this. Passing undefined inputs seems fine, we could have a lint check for this instead.

llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call.ll

5295

This shouldn't be dropped

[nhaehnle]

llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call.ll

5295

Do you have a better idea? We can't meaningfully support calls to C calling convention from shaders...

[arsenm]

llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call.ll

5295

What this was doing and passing undef to missing inputs

[nhaehnle]

llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call.ll

5295

Okay fair enough.

[rovka]

Ok, thanks for clarifying, I'll send a patch for that then :)

llvm/lib/Target/AMDGPU/AMDGPUCallLowering.cpp

if (Info.IsMustTailCall && !CanTailCallOpt) {
     LLVM_DEBUG(dbgs() << "Failed to lower musttail call as tail call\n");
     return false;
   }
 
   Info.IsTailCall = CanTailCallOpt;
   if (CanTailCallOpt)
     return lowerTailCall(MIRBuilder, Info, OutArgs);
 
+  if (AMDGPU::isShader(Info.CallConv)) {
+    // Note the issue is with the CC of the called function, not of the call
+    // itself.
+    return false;
+  }
+
+  if (AMDGPU::isShader(MF.getFunction().getCallingConv()) &&
+      Info.CallConv != CallingConv::AMDGPU_Gfx) {
+    // Only allow calls with specific calling conventions.
+    return false;
+  }
+
   // Find out which ABI gets to decide where things go.
   CCAssignFn *AssignFnFixed;
   CCAssignFn *AssignFnVarArg;
   std::tie(AssignFnFixed, AssignFnVarArg) =
       getAssignFnsForCC(Info.CallConv, TLI);
 
   MIRBuilder.buildInstr(AMDGPU::ADJCALLSTACKUP)
     .addImm(0)

llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call.ll

call void @external_void_func_8xv5f32(
       <5 x float> <float 3.0, float 3.0, float 3.0, float 3.0, float 3.0>,
       <5 x float> <float 4.0, float 4.0, float 4.0, float 4.0, float 4.0>,
       <5 x float> <float 5.0, float 5.0, float 5.0, float 5.0, float 5.0>,
       <5 x float> <float 6.0, float 7.0, float 8.0, float 9.0, float 10.0>,
       <5 x float> <float 11.0, float 12.0, float 13.0, float 14.0, float 15.0>)
   ret void
 }
 
-define amdgpu_ps void @amdgpu_ps_call_default_cc() {
-  ; CHECK-LABEL: name: amdgpu_ps_call_default_cc
-  ; CHECK: bb.1.main_body:
-  ; CHECK-NEXT:   [[C:%[0-9]+]]:_(p0) = G_CONSTANT i64 0
-  ; CHECK-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $scc
-  ; CHECK-NEXT:   [[DEF:%[0-9]+]]:_(p4) = G_IMPLICIT_DEF
-  ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(p4) = COPY [[DEF]](p4)
-  ; CHECK-NEXT:   [[C1:%[0-9]+]]:_(p4) = G_CONSTANT i64 0
-  ; CHECK-NEXT:   [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 0
-  ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:_(p4) = COPY [[C1]](p4)
-  ; CHECK-NEXT:   [[DEF1:%[0-9]+]]:_(s64) = G_IMPLICIT_DEF
-  ; CHECK-NEXT:   [[DEF2:%[0-9]+]]:_(s32) = G_IMPLICIT_DEF
-  ; CHECK-NEXT:   [[COPY2:%[0-9]+]]:_(s32) = COPY [[DEF2]](s32)
-  ; CHECK-NEXT:   [[COPY3:%[0-9]+]]:_(s32) = COPY [[DEF2]](s32)
-  ; CHECK-NEXT:   [[COPY4:%[0-9]+]]:_(s32) = COPY [[DEF2]](s32)
-  ; CHECK-NEXT:   [[COPY5:%[0-9]+]]:_(s32) = COPY [[DEF2]](s32)
-  ; CHECK-NEXT:   [[COPY6:%[0-9]+]]:_(<4 x s32>) = COPY $private_rsrc_reg
-  ; CHECK-NEXT:   $sgpr0_sgpr1_sgpr2_sgpr3 = COPY [[COPY6]](<4 x s32>)
-  ; CHECK-NEXT:   $sgpr4_sgpr5 = COPY [[DEF]](p4)
-  ; CHECK-NEXT:   $sgpr6_sgpr7 = COPY [[COPY]](p4)
-  ; CHECK-NEXT:   $sgpr8_sgpr9 = COPY [[COPY1]](p4)
-  ; CHECK-NEXT:   $sgpr10_sgpr11 = COPY [[DEF1]](s64)
-  ; CHECK-NEXT:   $sgpr12 = COPY [[DEF2]](s32)
-  ; CHECK-NEXT:   $sgpr13 = COPY [[COPY2]](s32)
-  ; CHECK-NEXT:   $sgpr14 = COPY [[COPY3]](s32)
-  ; CHECK-NEXT:   $sgpr15 = COPY [[COPY4]](s32)
-  ; CHECK-NEXT:   $vgpr31 = COPY [[COPY5]](s32)
-  ; CHECK-NEXT:   $sgpr30_sgpr31 = G_SI_CALL [[C]](p0), 0, csr_amdgpu, implicit $sgpr0_sgpr1_sgpr2_sgpr3, implicit $sgpr4_sgpr5, implicit $sgpr6_sgpr7, implicit $sgpr8_sgpr9, implicit $sgpr10_sgpr11, implicit $sgpr12, implicit $sgpr13, implicit $sgpr14, implicit $sgpr15, implicit $vgpr31
-  ; CHECK-NEXT:   ADJCALLSTACKDOWN 0, 0, implicit-def $scc
-  ; CHECK-NEXT:   S_ENDPGM 0
-main_body:
-  call void null()
-  ret void
-}
-
 attributes #0 = { nounwind }
 attributes #1 = { nounwind readnone }
 attributes #2 = { nounwind noinline }

llvm/test/CodeGen/AMDGPU/unsupported-calls.ll

+; RUN: not llc -march=amdgcn -mtriple=armgcn-- -mcpu=gfx1100 -tailcallopt -global-isel=1 -global-isel-abort=0 < %s 2>&1 | FileCheck -check-prefix=GISEL %s
 ; RUN: not llc -march=amdgcn -mtriple=amdgcn-mesa-mesa3d -tailcallopt < %s 2>&1 | FileCheck --check-prefix=GCN %s
 ; RUN: not llc -march=amdgcn -mtriple=amdgcn--amdpal -tailcallopt < %s 2>&1 | FileCheck --check-prefix=GCN %s
 ; RUN: not llc -march=r600 -mtriple=r600-- -mcpu=cypress -tailcallopt < %s 2>&1 | FileCheck -check-prefix=R600 %s
 
+; FIXME: Remove -global-isel-abort=0 when global isel can handle these.
+
 declare i32 @external_function(i32) nounwind
 
+; GISEL-NOT: error
 ; GCN-NOT: error
 ; R600: in function test_call_external{{.*}}: unsupported call to function external_function
 define amdgpu_kernel void @test_call_external(ptr addrspace(1) %out, ptr addrspace(1) %in) {
   %b_ptr = getelementptr i32, ptr addrspace(1) %in, i32 1
   %a = load i32, ptr addrspace(1) %in
   %b = load i32, ptr addrspace(1) %b_ptr
   %c = call i32 @external_function(i32 %b) nounwind
   %result = add i32 %a, %c
   store i32 %result, ptr addrspace(1) %out
   ret void
 }
 
 define i32 @defined_function(i32 %x) nounwind noinline {
   %y = add i32 %x, 8
   ret i32 %y
 }
 
+; GISEL-NOT: error
 ; GCN-NOT: error
 ; R600: in function test_call{{.*}}: unsupported call to function defined_function
 define amdgpu_kernel void @test_call(ptr addrspace(1) %out, ptr addrspace(1) %in) {
   %b_ptr = getelementptr i32, ptr addrspace(1) %in, i32 1
   %a = load i32, ptr addrspace(1) %in
   %b = load i32, ptr addrspace(1) %b_ptr
   %c = call i32 @defined_function(i32 %b) nounwind
   %result = add i32 %a, %c
   store i32 %result, ptr addrspace(1) %out
   ret void
 }
 
+; FIXME: GISEL
 ; GCN: error: <unknown>:0:0: in function test_tail_call i32 (ptr addrspace(1), ptr addrspace(1)): unsupported required tail call to function defined_function
 ; R600: in function test_tail_call{{.*}}: unsupported call to function defined_function
 define i32 @test_tail_call(ptr addrspace(1) %out, ptr addrspace(1) %in) {
   %b_ptr = getelementptr i32, ptr addrspace(1) %in, i32 1
   %a = load i32, ptr addrspace(1) %in
   %b = load i32, ptr addrspace(1) %b_ptr
   %c = tail call i32 @defined_function(i32 %b)
   ret i32 %c
 }
 
 declare void @external.varargs(i32, double, i64, ...)
 
+; GISEL: error: <unknown>:0:0: in function test_call_varargs void (): unsupported call to variadic function external.varargs
 ; GCN: error: <unknown>:0:0: in function test_call_varargs void (): unsupported call to variadic function external.varargs
 ; R600: in function test_call_varargs{{.*}}: unsupported call to function external.varargs
 define void @test_call_varargs() {
   call void (i32, double, i64, ...) @external.varargs(i32 42, double 1.0, i64 12, i8 3, i16 1, i32 4, float 1.0, double 2.0)
   ret void
 }
 
 declare i32 @extern_variadic(...)
 
+; FIXME: GISEL
 ; GCN: in function test_tail_call_bitcast_extern_variadic{{.*}}: unsupported required tail call to function extern_variadic
 ; R600: in function test_tail_call_bitcast_extern_variadic{{.*}}: unsupported call to function extern_variadic
 define i32 @test_tail_call_bitcast_extern_variadic(<4 x float> %arg0, <4 x float> %arg1, i32 %arg2) {
   %add = fadd <4 x float> %arg0, %arg1
   %call = tail call i32 @extern_variadic(<4 x float> %add)
   ret i32 %call
 }
 
+; GISEL: in function test_c_call_from_shader i32 (): unsupported calling convention for call from graphics shader of function defined_function
 ; GCN: :0:0: in function test_c_call_from_shader i32 (): unsupported calling convention for call from graphics shader of function defined_function
 ; R600: in function test_c_call{{.*}}: unsupported call to function defined_function
 define amdgpu_ps i32 @test_c_call_from_shader() {
   %call = call i32 @defined_function(i32 0)
   ret i32 %call
 }
 
+; GISEL-NOT: in function test_gfx_call{{.*}}unsupported
 ; GCN-NOT: in function test_gfx_call{{.*}}unsupported
 ; R600: in function test_gfx_call{{.*}}: unsupported call to function defined_function
 define amdgpu_ps i32 @test_gfx_call_from_shader() {
   %call = call amdgpu_gfx i32 @defined_function(i32 0)
   ret i32 %call
 }