[AMDGPU] Remove error check for indirect calls and add missing queue-ptr

[madhur13490]

Summary

This patch removes -fixed-abi check for indirect calls
and also adds queue-ptr which is required for indirect calls to work.

[madhur13490]

llvm/lib/Target/AMDGPU/SIISelLowering.cpp

2961

Calling specific attention to this:
For AMDPAL, do we want indirect functions to work *only* when -fixed-abi is provided?
What are the cases for which we want to error out?

[arsenm]

llvm/test/CodeGen/AMDGPU/check-simple-indirect-call.ll

2

Should use a concrete subtarget

4

Should just merge this into the existing indirect call test

[madhur13490]

keep tests alone as discussed offline and add explicit subtarget to test

[madhur13490]

remove new test and merge in existing one

[arsenm]

llvm/test/CodeGen/AMDGPU/simple-indirect-call.ll

42–44 ↗

(On Diff #338586)

Why bother with the alloca/addrspacecast? This ends up getting optimized to LDS anyway

[madhur13490]

llvm/test/CodeGen/AMDGPU/simple-indirect-call.ll

42–44 ↗

(On Diff #338586)

specifically denote typical sequence of instructions generated by frontend

[arsenm]

llvm/test/CodeGen/AMDGPU/simple-indirect-call.ll

42–44 ↗

(On Diff #338586)

What the frontend initially emits is less important unless we for some reason would break it. This should use the minimum IR to exercise the feature

[madhur13490]

llvm/test/CodeGen/AMDGPU/simple-indirect-call.ll

42–44 ↗

(On Diff #338586)

But we have many tests which covers minimum IR. We don't have any which covers typical pattern generated by frontend.

[arsenm]

llvm/test/CodeGen/AMDGPU/simple-indirect-call.ll

42–44 ↗

(On Diff #338586)

But this isn't what you are testing. The IR should be the minimum set required to reproduce the issue you are attempting to fix

llvm/lib/Target/AMDGPU/AMDGPUAnnotateKernelFeatures.cpp

 
 namespace {
 static constexpr StringLiteral ImplicitAttrNames[] = {
     // X ids unnecessarily propagated to kernels.
     "amdgpu-work-item-id-x",  "amdgpu-work-item-id-y",
     "amdgpu-work-item-id-z",  "amdgpu-work-group-id-x",
     "amdgpu-work-group-id-y", "amdgpu-work-group-id-z",
     "amdgpu-dispatch-ptr",    "amdgpu-dispatch-id",
-    "amdgpu-implicitarg-ptr"};
+    "amdgpu-queue-ptr",       "amdgpu-implicitarg-ptr"};
 
 class AMDGPUAnnotateKernelFeatures : public CallGraphSCCPass {
 private:
   const TargetMachine *TM = nullptr;
   SmallVector<CallGraphNode*, 8> NodeList;
 
   bool addFeatureAttributes(Function &F);
   bool processUniformWorkGroupAttribute();

llvm/lib/Target/AMDGPU/SIISelLowering.cpp

SDValue SITargetLowering::LowerCall(CallLoweringInfo &CLI,
   if (IsVarArg) {
     return lowerUnhandledCall(CLI, InVals,
                               "unsupported call to variadic function ");
   }
 
   if (!CLI.CB)
     report_fatal_error("unsupported libcall legalization");
 
-  if (!AMDGPUTargetMachine::EnableFixedFunctionABI &&
-      !CLI.CB->getCalledFunction() && CallConv != CallingConv::AMDGPU_Gfx) {
-    return lowerUnhandledCall(CLI, InVals,
-                              "unsupported indirect call to function ");
-  }
-
   if (IsTailCall && MF.getTarget().Options.GuaranteedTailCallOpt) {
     return lowerUnhandledCall(CLI, InVals,
                               "unsupported required tail call to function ");
   }
 
   if (AMDGPU::isShader(CallConv)) {
     // Note the issue is with the CC of the called function, not of the call
     // itself.

llvm/test/CodeGen/AMDGPU/annotate-kernel-features-hsa-call.ll

 ; HSA: attributes #12 = { nounwind "target-cpu"="gfx900" "uniform-work-group-size"="false" }
 ; HSA: attributes #13 = { nounwind "amdgpu-queue-ptr" "target-cpu"="gfx900" "uniform-work-group-size"="false" }
 ; HSA: attributes #14 = { nounwind "amdgpu-kernarg-segment-ptr" "target-cpu"="fiji" "uniform-work-group-size"="false" }
 ; HSA: attributes #15 = { nounwind "amdgpu-implicitarg-ptr" "target-cpu"="fiji" }
 ; HSA: attributes #16 = { nounwind "amdgpu-implicitarg-ptr" "target-cpu"="fiji" "uniform-work-group-size"="false" }
 ; HSA: attributes #17 = { nounwind "uniform-work-group-size"="false" }
 ; HSA: attributes #18 = { nounwind }
 ; HSA: attributes #19 = { nounwind "amdgpu-calls" "uniform-work-group-size"="false" }
-; HSA: attributes #20 = { nounwind "amdgpu-dispatch-id" "amdgpu-dispatch-ptr" "amdgpu-implicitarg-ptr" "amdgpu-work-group-id-x" "amdgpu-work-group-id-y" "amdgpu-work-group-id-z" "amdgpu-work-item-id-x" "amdgpu-work-item-id-y" "amdgpu-work-item-id-z" "target-cpu"="fiji" }
+; HSA: attributes #20 = { nounwind "amdgpu-dispatch-id" "amdgpu-dispatch-ptr" "amdgpu-implicitarg-ptr" "amdgpu-queue-ptr" "amdgpu-work-group-id-x" "amdgpu-work-group-id-y" "amdgpu-work-group-id-z" "amdgpu-work-item-id-x" "amdgpu-work-item-id-y" "amdgpu-work-item-id-z" "target-cpu"="fiji" }

llvm/test/CodeGen/AMDGPU/call-constant.ll

 ; RUN: llc -global-isel=0 -amdgpu-fixed-function-abi=0 -mtriple=amdgcn-amd-amdhsa < %s | FileCheck -check-prefixes=GCN,SDAG %s
 ; RUN: llc -global-isel=1 -amdgpu-fixed-function-abi=1 -mtriple=amdgcn-amd-amdhsa < %s | FileCheck -check-prefixes=GCN,GISEL %s
 
 ; FIXME: Emitting unnecessary flat_scratch setup
 
 ; GCN-LABEL: {{^}}test_call_undef:
-; SDAG: s_mov_b32 flat_scratch_lo, s11
-; SDAG: s_add_u32 s10, s10, s15
+; SDAG: s_mov_b32 flat_scratch_lo, s13
+; SDAG: s_add_u32 s12, s12, s17
 ; SDAG: s_lshr_b32
 ; GCN: s_endpgm
 define amdgpu_kernel void @test_call_undef() #0 {
   %val = call i32 undef(i32 1)
   %op = add i32 %val, 1
   store volatile i32 %op, i32 addrspace(1)* undef
   ret void
 }
 
 ; GCN-LABEL: {{^}}test_tail_call_undef:
 ; SDAG: s_waitcnt
 ; SDAG-NEXT: .Lfunc_end
 
 ; GISEL: s_swappc_b64 s{{\[[0-9]+:[0-9]+\]}}, s{{\[[0-9]+:[0-9]+\]}}
 define i32 @test_tail_call_undef() #0 {
   %call = tail call i32 undef(i32 1)
   ret i32 %call
 }
 
 ; GCN-LABEL: {{^}}test_call_null:
-; SDAG: s_mov_b32 flat_scratch_lo, s11
-; SDAG: s_add_u32 s10, s10, s15
+; SDAG: s_mov_b32 flat_scratch_lo, s13
+; SDAG: s_add_u32 s12, s12, s17
 ; SDAG: s_lshr_b32
 
 ; GISEL: s_swappc_b64 s{{\[[0-9]+:[0-9]+\]}}, 0{{$}}
 ; GCN: s_endpgm
 define amdgpu_kernel void @test_call_null() #0 {
   %val = call i32 null(i32 1)
   %op = add i32 %val, 1
   store volatile i32 %op, i32 addrspace(1)* null

llvm/test/CodeGen/AMDGPU/check-simple-indirect-call.ll

+; RUN: llc -mtriple=amdgcn-amd-amdhsa -mcpu=gfx900 < %s | FileCheck -check-prefix=GFX9 %s
+
+; GFX9-LABEL: {{^}}indirect:
+define internal void @indirect() {
+    ret void
+}
+
+; GFX9-LABEL: {{^}}test_simple_indirect_call:
+; GFX9:  s_add_u32 flat_scratch_lo, s12, s17
+; GFX9-NEXT:  s_addc_u32 flat_scratch_hi, s13, 0
+; GFX9-NEXT:  s_mov_b32 s13, s15
+; GFX9-NEXT:  s_mov_b32 s12, s14
+; GFX9-NEXT:  s_load_dwordx2 s[14:15], s[4:5], 0x4
+; GFX9-NEXT:  s_add_u32 s0, s0, s17
+; GFX9-NEXT:  s_addc_u32 s1, s1, 0
+; GFX9-NEXT:  s_mov_b32 s32, 0
+; GFX9-NEXT:  s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:  s_lshr_b32 s14, s14, 16
+; GFX9-NEXT:  s_mul_i32 s14, s14, s15
+; GFX9-NEXT:  v_mul_lo_u32 v3, s14, v0
+; GFX9-NEXT:  s_getpc_b64 s[18:19]
+; GFX9-NEXT:  s_add_u32 s18, s18, indirect@rel32@lo+4
+; GFX9-NEXT:  s_addc_u32 s19, s19, indirect@rel32@hi+12
+; GFX9-NEXT:  s_mov_b32 s14, s16
+; GFX9-NEXT:  v_mad_u32_u24 v3, v1, s15, v3
+; GFX9-NEXT:  v_add_lshl_u32 v5, v3, v2, 3
+; GFX9-NEXT:  v_mov_b32_e32 v3, s18
+; GFX9-NEXT:  v_lshlrev_b32_e32 v2, 20, v2
+; GFX9-NEXT:  v_lshlrev_b32_e32 v1, 10, v1
+; GFX9-NEXT:  v_mov_b32_e32 v4, s19
+; GFX9-NEXT:  v_or3_b32 v0, v0, v1, v2
+; GFX9-NEXT:  ds_write_b64 v5, v[3:4]
+; GFX9-NEXT:  s_swappc_b64 s[30:31], s[18:19]
+; GFX9-NEXT:  s_endpgm
+define amdgpu_kernel void @test_simple_indirect_call() {
+    %fptr = alloca void()*, addrspace (5)
+    %fptr.cast = addrspacecast void()* addrspace(5)* %fptr to void()**
+    store void()* @indirect, void()** %fptr.cast
+    %fp = load void()*, void()** %fptr.cast
+    call void %fp()
+    ret void
+}
+

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

 ; GCN: in function test_tail_call_bitcast_extern_variadic{{.*}}: unsupported call to variadic 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 bitcast (i32 (...)* @extern_variadic to i32 (<4 x float>)*)(<4 x float> %add)
   ret i32 %call
 }
 
-; GCN: :0:0: in function test_indirect_call void (void ()*): unsupported indirect call to function <unknown>
-; R600: in function test_indirect_call{{.*}}: unsupported call to function <unknown>
-define void @test_indirect_call(void()* %fptr) {
-  call void %fptr()
-  ret void
-}
-
 ; 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
 }
 
 ; 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
 }
 
-; FIXME: Bad error message
-; GCN: error: <unknown>:0:0: in function test_call_absolute void (): unsupported indirect call to function <unknown>
-; R600: error: <unknown>:0:0: in function test_call_absolute void (): unsupported call to function <unknown>
-define amdgpu_kernel void @test_call_absolute() #0 {
-  %val = call i32 inttoptr (i64 1234 to i32(i32)*) (i32 1)
-  %op = add i32 %val, 1
-  store volatile i32 %op, i32 addrspace(1)* undef
-  ret void
-}