AMDGPU: Don't error on calls to constexpr casts of functions

[rampitec]

LGTM

[scott.linder]

I still don't understand exactly when a call is indirect, but when an argument is cast this still seems to fail:

%foo = type opaque

define i64 @bar(i64 addrspace(1)* %p) {
  ret i64 1
}

define void @test_cast_to_opaque(%foo addrspace(1)* %out) {
  %1 = call i64 bitcast (i64 (i64 addrspace(1)*)* @bar to i64 (%foo addrspace(1)*)*)(%foo addrspace(1)* %out)
  ret void
}

gives:

error: <unknown>:0:0: in function test_cast_to_opaque void (%foo addrspace(1)*): unsupported indirect call to function bar

test/CodeGen/AMDGPU/promote-alloca-bitcast-function.ll

9

Maybe rename these without the crash_?

[arsenm]

In D51795#1227811, @scott.linder wrote:

I still don't understand exactly when a call is indirect, but when an argument is cast this still seems to fail:

If the function pointer is a variable, not a constant. Your example works for me with this patch

[scott.linder]

Sorry; I just checked again and llc had not been rebulit for some reason. I deleted it and ran the build again and that example does compile fine.

[scott.linder]

I still see asserts related to bitcasted function calls, but I haven't gotten to the bottom of why; an example:

%struct.foo = type { i64, i64, i64, [104 x i8], [1 x i8] }
%struct.pluto = type opaque

define void @wombat() {
bb:
  call void bitcast (void (%struct.foo addrspace(1)*, i64, i32, i32)* @barney to void (%struct.foo addrspace(1)*, %struct.pluto addrspace(1)*, i32, i32)*)(%struct.foo addrspace(1)* undef, %struct.pluto addrspace(1)* undef, i32 4, i32 4)
  ret void
}

define void @barney(%struct.foo addrspace(1)* nocapture %arg, i64 %arg1, i32 %arg2, i32 %arg3) {
bb:
  ret void
}

Results in:

llc: llvm/lib/Target/AMDGPU/AMDGPUArgumentUsageInfo.h:164: const llvm::AMDGPUFunctionArgInfo &llvm::AMDGPUArgumentUsageInfo::lookupFuncArgInfo(const llvm::Function &) const: Assertion `F.isDeclaration()' failed.
Stack dump:
0.      Program arguments: llvm/bin/llc -march=amdgcn -mcpu=gfx900 meta.ll 
1.      Running pass 'CallGraph Pass Manager' on module 'meta.ll'.
2.      Running pass 'AMDGPU DAG->DAG Pattern Instruction Selection' on function '@wombat'
...
#9 0x0000000000bc6ae5 llvm::AMDGPUArgumentUsageInfo::lookupFuncArgInfo(llvm::Function const&) const llvm/lib/Target/AMDGPU/AMDGPUArgumentUsageInfo.h:0:7
#10 0x0000000000b8c78f llvm::SITargetLowering::passSpecialInputs(llvm::TargetLowering::CallLoweringInfo&, llvm::CCState&, llvm::SIMachineFunctionInfo const&, llvm::SmallVectorImpl<std::pair<unsigned int, llvm::SDValue> >&, llvm::SmallVectorImpl<llvm::SDValue>&, llvm::SDValue) const llvm/lib/Target/AMDGPU/SIISelLowering.cpp:2204:32
#11 0x0000000000b8f055 llvm::SITargetLowering::LowerCall(llvm::TargetLowering::CallLoweringInfo&, llvm::SmallVectorImpl<llvm::SDValue>&) const llvm/lib/Target/AMDGPU/SIISelLowering.cpp:2573:8
...

However, the following gets past lowering fine:

%struct.foo = type { i64, i64, i64, [104 x i8], [1 x i8] }
%struct.pluto = type opaque

define void @wombat() {
bb:
  call void bitcast (void (%struct.foo addrspace(1)*, i64, i32, i32)* @barney to void (%struct.foo addrspace(1)*, %struct.pluto addrspace(1)*, i32, i32)*)(%struct.foo addrspace(1)* undef, %struct.pluto addrspace(1)* undef, i32 4, i32 4)
  ret void
}

declare void @barney(%struct.foo addrspace(1)* nocapture %arg, i64 %arg1, i32 %arg2, i32 %arg3)

[scott.linder]

Seems to be related to the order; this succeeds:

%struct.foo = type { i64, i64, i64, [104 x i8], [1 x i8] }
%struct.pluto = type opaque

define void @barney(%struct.foo addrspace(1)* nocapture %arg, i64 %arg1, i32 %arg2, i32 %arg3) {
bb:
  ret void
}

define void @wombat() {
bb:
  call void bitcast (void (%struct.foo addrspace(1)*, i64, i32, i32)* @barney to void (%struct.foo addrspace(1)*, %struct.pluto addrspace(1)*, i32, i32)*)(%struct.foo addrspace(1)* undef, %struct.pluto addrspace(1)* undef, i32 4, i32 4)
  ret void
}

It seems like if SelectionDAGBuilder does LowerCall for the caller before it does LowerFormalArguments for the callee we fail in SITargetLowering::passSpecialInputs because we have not filled in ArgInfoMap for the callee yet. Without the bitcast is this dependency somehow enforced?

[scott.linder]

It looks like to make this change we need to update CallGraph as well; it currently just uses .getCalledFunction(), so the graph doesn't have the edge created by the bitcasted call.

[scott.linder]

This patch requires changes to CallGraph, and doesn't address inlining through bitcasts. I think https://reviews.llvm.org/D52741 can supercede it, and if we still want to make those changes to CallGraph they can be done independently.

[arsenm]

This is totally obsolete

lib/Target/AMDGPU/SIISelLowering.cpp

void SITargetLowering::passSpecialInputs(
     SmallVectorImpl<std::pair<unsigned, SDValue>> &RegsToPass,
     SmallVectorImpl<SDValue> &MemOpChains,
     SDValue Chain) const {
   // If we don't have a call site, this was a call inserted by
   // legalization. These can never use special inputs.
   if (!CLI.CS)
     return;
 
-  const Function *CalleeFunc = CLI.CS.getCalledFunction();
-  assert(CalleeFunc);
+  const Function *CalleeFunc
+    = dyn_cast<Function>(CLI.CS.getCalledValue()->stripPointerCasts());
+  if (!CalleeFunc)
+    return;
+
 
   SelectionDAG &DAG = CLI.DAG;
   const SDLoc &DL = CLI.DL;
 
   const SIRegisterInfo *TRI = Subtarget->getRegisterInfo();
 
   auto &ArgUsageInfo =
     DAG.getPass()->getAnalysis<AMDGPUArgumentUsageInfo>();
SDValue SITargetLowering::LowerCall(CallLoweringInfo &CLI,
   if (IsVarArg) {
     return lowerUnhandledCall(CLI, InVals,
                               "unsupported call to variadic function ");
   }
 
   if (!CLI.CS.getInstruction())
     report_fatal_error("unsupported libcall legalization");
 
-  if (!CLI.CS.getCalledFunction()) {
+  const Value *CalleeVal = CLI.CS.getCalledValue()->stripPointerCasts();
+  if (!isa<Function>(CalleeVal)) {
     return lowerUnhandledCall(CLI, InVals,
+                              isa<Constant>(CalleeVal) ?
+                              "unsupported call to constant " :
                               "unsupported indirect call to function ");
   }
 
   if (IsTailCall && MF.getTarget().Options.GuaranteedTailCallOpt) {
     return lowerUnhandledCall(CLI, InVals,
                               "unsupported required tail call to function ");
   }
 

test/CodeGen/AMDGPU/call-constexpr.ll

+; RUN: llc -mtriple=amdgcn-amd-amdhsa -verify-machineinstrs < %s | FileCheck -check-prefix=GCN %s
+
+define i32 @ret_i32() #0 {
+  ret i32 4
+}
+
+; GCN-LABEL: {{^}}test_bitcast_return_type:
+; GCN: s_getpc_b64
+; GCN: s_add_u32 s{{[0-9]+}}, s{{[0-9]+}}, ret_i32@rel32@lo+4
+; GCN: s_addc_u32 s{{[0-9]+}}, s{{[0-9]+}}, ret_i32@rel32@hi+4
+; GCN: s_swappc_b64
+define amdgpu_kernel void @test_bitcast_return_type() #0 {
+  %val = call float bitcast (i32()* @ret_i32 to float()*)()
+  %op = fadd float %val, 1.0
+  store volatile float %op, float addrspace(1)* undef
+  ret void
+}
+
+; GCN-LABEL: {{^}}use_workitem_id_x:
+; GCN: s_waitcnt
+; GCN-NEXT: v_add_i32_e32 v0, vcc, v0, v1
+; GCN-NEXT: s_setpc_b64
+define i32 @use_workitem_id_x(i32 %arg0) #0 {
+  %id = call i32 @llvm.amdgcn.workitem.id.x()
+  %op = add i32 %id, %arg0
+  ret i32 %op
+}
+
+; GCN-LABEL: {{^}}test_bitcast_use_workitem_id_x:
+; GCN: v_mov_b32_e32 v1, v0
+; GCN: s_getpc_b64
+; GCN: s_add_u32 s{{[0-9]+}}, s{{[0-9]+}}, use_workitem_id_x@rel32@lo+4
+; GCN: s_addc_u32 s{{[0-9]+}}, s{{[0-9]+}}, use_workitem_id_x@rel32@hi+4
+; GCN: v_mov_b32_e32 v0, 9
+; GCN: s_swappc_b64
+; GCN: v_add_f32_e32
+define amdgpu_kernel void @test_bitcast_use_workitem_id_x() #0 {
+  %val = call float bitcast (i32(i32)* @use_workitem_id_x to float(i32)*)(i32 9)
+  %op = fadd float %val, 1.0
+  store volatile float %op, float addrspace(1)* undef
+  ret void
+}
+
+declare i32 @extern_variadic(...)
+
+; GCN-LABEL: {{^}}test_tail_call_bitcast_extern_variadic:
+; GCN: v_add_f32_e32 v0,
+; GCN: v_add_f32_e32 v1,
+; GCN: v_add_f32_e32 v2,
+; GCN: v_add_f32_e32 v3,
+; GCN: s_getpc_b64
+; GCN: s_add_u32 s{{[0-9]+}}, s{{[0-9]+}}, extern_variadic@rel32@lo+4
+; GCN: s_addc_u32 s{{[0-9]+}}, s{{[0-9]+}}, extern_variadic@rel32@hi+4
+; GCN: s_setpc_b64
+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
+}
+
+declare i32 @llvm.amdgcn.workitem.id.x() #1
+
+attributes #0 = { nounwind noinline }
+attributes #1 = { nounwind readnone speculatable }

test/CodeGen/AMDGPU/promote-alloca-bitcast-function.ll

-; RUN: not llc -march=amdgcn < %s 2>&1 | FileCheck %s
-
-; FIXME: Error is misleading because it's not an indirect call.
-
-; CHECK: error: <unknown>:0:0: in function crash_call_constexpr_cast void (): unsupported indirect call to function foo
+; RUN: opt -data-layout=A5 -S -mtriple=amdgcn-unknown-unknown -amdgpu-promote-alloca -disable-promote-alloca-to-vector < %s | FileCheck %s
 
 ; Make sure that AMDGPUPromoteAlloca doesn't crash if the called
 ; function is a constantexpr cast of a function.
 
 declare void @foo(float addrspace(5)*) #0
 declare void @foo.varargs(...) #0
 
-; XCHECK: in function crash_call_constexpr_cast{{.*}}: unsupported call to function foo
+; CHECK-LABEL: @crash_call_constexpr_cast(
+; CHECK: alloca
+; CHECK: call void
 define amdgpu_kernel void @crash_call_constexpr_cast() #0 {
   %alloca = alloca i32, addrspace(5)
   call void bitcast (void (float addrspace(5)*)* @foo to void (i32 addrspace(5)*)*)(i32 addrspace(5)* %alloca) #0
   ret void
 }
 
-; XCHECK: in function crash_call_constexpr_cast{{.*}}: unsupported call to function foo.varargs
+; CHECK-LABEL: @crash_call_constexpr_cast_varargs(
+; CHECK: alloca
+; CHECK: call void
 define amdgpu_kernel void @crash_call_constexpr_cast_varargs() #0 {
   %alloca = alloca i32, addrspace(5)
   call void bitcast (void (...)* @foo.varargs to void (i32 addrspace(5)*)*)(i32 addrspace(5)* %alloca) #0
   ret void
 }
 
 attributes #0 = { nounwind }

test/CodeGen/AMDGPU/unsupported-calls.ll

 
 ; 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(...)
-
-; GCN: in function test_tail_call_bitcast_extern_variadic{{.*}}: unsupported indirect 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 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_call_from_shader i32 (): unsupported call from graphics shader of function defined_function
 ; R600: in function test_call{{.*}}: unsupported call to function defined_function
 define amdgpu_ps i32 @test_call_from_shader() {
   %call = call 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>
+; GCN: error: <unknown>:0:0: in function test_call_absolute void (): unsupported call to constant <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
 }