AMDGPU: Directly annotate functions if they have calls

[arsenm]

Summary

Currently we infer whether the flat-scratch-init kernel input should
be enabled based on calls. Move this handling, so we can decide if the
full set of ABI inputs is needed in kernels. Ideally we would have an
analysis of some sort, rather than the function attributes.

[rampitec]

LGTM

[arsenm]

ccc6e780c8fa769fc503f193d27a1ef356f6355d

llvm/lib/Target/AMDGPU/AMDGPUAnnotateKernelFeatures.cpp

bool AMDGPUAnnotateKernelFeatures::addFeatureAttributes(Function &F) {
   if (NeedQueuePtr) {
     F.addFnAttr("amdgpu-queue-ptr");
     Changed = true;
   }
 
   // TODO: We could refine this to captured pointers that could possibly be
   // accessed by flat instructions. For now this is mostly a poor way of
   // estimating whether there are calls before argument lowering.
-  if (HasFlat && !IsFunc && HaveCall) {
-    F.addFnAttr("amdgpu-flat-scratch");
+  if (!IsFunc && HaveCall) {
+    F.addFnAttr("amdgpu-calls");
     Changed = true;
   }
 
   return Changed;
 }
 
 bool AMDGPUAnnotateKernelFeatures::runOnSCC(CallGraphSCC &SCC) {
   bool Changed = false;

llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.cpp

: AMDGPUMachineFunction(MF),
     GDSSize(0) {
   const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
   const Function &F = MF.getFunction();
   FlatWorkGroupSizes = ST.getFlatWorkGroupSizes(F);
   WavesPerEU = ST.getWavesPerEU(F);
 
   Occupancy = ST.computeOccupancy(MF, getLDSSize());
   CallingConv::ID CC = F.getCallingConv();
+  const MachineFrameInfo &FrameInfo = MF.getFrameInfo();
+
+  // FIXME: Should have analysis or something rather than attribute to detect
+  // calls.
+  bool HasCalls = FrameInfo.hasCalls() || F.hasFnAttribute("amdgpu-calls");
 
   if (CC == CallingConv::AMDGPU_KERNEL || CC == CallingConv::SPIR_KERNEL) {
     if (!F.arg_empty())
       KernargSegmentPtr = true;
     WorkGroupIDX = true;
     WorkItemIDX = true;
   } else if (CC == CallingConv::AMDGPU_PS) {
     PSInputAddr = AMDGPU::getInitialPSInputAddr(F);
if (F.hasFnAttribute("amdgpu-work-item-id-x"))
     WorkItemIDX = true;
 
   if (F.hasFnAttribute("amdgpu-work-item-id-y"))
     WorkItemIDY = true;
 
   if (F.hasFnAttribute("amdgpu-work-item-id-z"))
     WorkItemIDZ = true;
 
-  const MachineFrameInfo &FrameInfo = MF.getFrameInfo();
   bool HasStackObjects = FrameInfo.hasStackObjects();
 
   if (isEntryFunction()) {
     // X, XY, and XYZ are the only supported combinations, so make sure Y is
     // enabled if Z is.
     if (WorkItemIDZ)
       WorkItemIDY = true;
 
auto hasNonSpillStackObjects = [&]() {
                 OE = FrameInfo.getObjectIndexEnd(); OI != OE; ++OI)
         if (!FrameInfo.isSpillSlotObjectIndex(OI))
           return true;
       // All stack objects are spill slots.
       return false;
     };
     // TODO: This could be refined a lot. The attribute is a poor way of
     // detecting calls that may require it before argument lowering.
-    if (hasNonSpillStackObjects() || F.hasFnAttribute("amdgpu-flat-scratch"))
+    if (HasCalls || hasNonSpillStackObjects())
       FlatScratchInit = true;
   }
 
   Attribute A = F.getFnAttribute("amdgpu-git-ptr-high");
   StringRef S = A.getValueAsString();
   if (!S.empty())
     S.consumeInteger(0, GITPtrHigh);
 

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

 ; HSA: attributes #11 = { nounwind "target-cpu"="fiji" "uniform-work-group-size"="false" }
 ; 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-flat-scratch" "uniform-work-group-size"="false" }
+; HSA: attributes #19 = { nounwind "amdgpu-calls" "uniform-work-group-size"="false" }

llvm/test/CodeGen/AMDGPU/uniform-work-group-attribute-missing.ll

-; RUN: opt -S -mtriple=amdgcn-amd- -amdgpu-annotate-kernel-features %s | FileCheck %s 
+; RUN: opt -S -mtriple=amdgcn-amd- -amdgpu-annotate-kernel-features %s | FileCheck %s
 
 ; If the kernel does not have the uniform-work-group-attribute, set both callee and caller as false
 
 ; CHECK: define void @foo() #[[FOO:[0-9]+]] {
 define void @foo() #0 {
   ret void
 }
 
-; CHECK: define amdgpu_kernel void @kernel1() #[[FOO]] {
+; CHECK: define amdgpu_kernel void @kernel1() #[[KERNEL1:[0-9]+]] {
 define amdgpu_kernel void @kernel1() #1 {
   call void @foo()
   ret void
 }
 
 attributes #0 = { "uniform-work-group-size"="true" }
 
 ; CHECK: attributes #[[FOO]] = { "uniform-work-group-size"="false" }
+; CHECK: attributes #[[KERNEL1]] = { "amdgpu-calls" "uniform-work-group-size"="false" }

llvm/test/CodeGen/AMDGPU/uniform-work-group-nested-function-calls.ll

-; RUN: opt -S -mtriple=amdgcn-amd- -amdgpu-annotate-kernel-features %s | FileCheck %s 
+; RUN: opt -S -mtriple=amdgcn-amd- -amdgpu-annotate-kernel-features %s | FileCheck %s
 
 ; Test to verify if the attribute gets propagated across nested function calls
 
 ; CHECK: define void @func1() #[[FUNC:[0-9]+]] {
 define void @func1() #0 {
   ret void
 }
 
 ; CHECK: define void @func2() #[[FUNC]] {
 define void @func2() #1 {
   call void @func1()
   ret void
 }
 
-; CHECK: define amdgpu_kernel void @kernel3() #[[FUNC:[0-9]+]] {
+; CHECK: define amdgpu_kernel void @kernel3() #[[KERNEL:[0-9]+]] {
 define amdgpu_kernel void @kernel3() #2 {
   call void @func2()
   ret void
 }
 
 attributes #2 = { "uniform-work-group-size"="true" }
 
 ; CHECK: attributes #[[FUNC]] = { "uniform-work-group-size"="true" }
+; CHECK: attributes #[[KERNEL]] = { "amdgpu-calls" "uniform-work-group-size"="true" }

llvm/test/CodeGen/AMDGPU/uniform-work-group-prevent-attribute-propagation.ll

-; RUN: opt -S -mtriple=amdgcn-amd- -amdgpu-annotate-kernel-features %s | FileCheck %s 
+; RUN: opt -S -mtriple=amdgcn-amd- -amdgpu-annotate-kernel-features %s | FileCheck %s
 
 ; Two kernels with different values of the uniform-work-group-attribute call the same function
 
 ; CHECK: define void @func() #[[FUNC:[0-9]+]] {
 define void @func() #0 {
   ret void
 }
 
 ; CHECK: define amdgpu_kernel void @kernel1() #[[KERNEL1:[0-9]+]] {
 define amdgpu_kernel void @kernel1() #1 {
   call void @func()
   ret void
 }
 
-; CHECK: define amdgpu_kernel void @kernel2() #[[FUNC]] {
+; CHECK: define amdgpu_kernel void @kernel2() #[[KERNEL2:[0-9]+]] {
 define amdgpu_kernel void @kernel2() #2 {
   call void @func()
   ret void
 }
 
 attributes #1 = { "uniform-work-group-size"="true" }
 
 ; CHECK: attributes #[[FUNC]] = { "uniform-work-group-size"="false" }
-; CHECK: attributes #[[KERNEL1]] = { "uniform-work-group-size"="true" }
+; CHECK: attributes #[[KERNEL1]] = { "amdgpu-calls" "uniform-work-group-size"="true" }
+; CHECK: attributes #[[KERNEL2]] = { "amdgpu-calls" "uniform-work-group-size"="false" }

llvm/test/CodeGen/AMDGPU/uniform-work-group-propagate-attribute.ll

-; RUN: opt -S -mtriple=amdgcn-amd- -amdgpu-annotate-kernel-features %s | FileCheck %s 
+; RUN: opt -S -mtriple=amdgcn-amd- -amdgpu-annotate-kernel-features %s | FileCheck %s
 
 ; Propagate the uniform-work-group-attribute from the kernel to callee if it doesn't have it
 ; CHECK: define void @func() #[[FUNC:[0-9]+]] {
 define void @func() #0 {
   ret void
 }
 
 ; CHECK: define amdgpu_kernel void @kernel1() #[[KERNEL1:[0-9]+]] {
define amdgpu_kernel void @kernel2() #2 {
   ret void
 }
 
 attributes #0 = { nounwind }
 attributes #1 = { "uniform-work-group-size"="false" }
 attributes #2 = { "uniform-work-group-size"="true" }
 
 ; CHECK: attributes #[[FUNC]] = { nounwind "uniform-work-group-size"="false" }
-; CHECK: attributes #[[KERNEL1]] = { "uniform-work-group-size"="false" }
-; CHECK: attributes #[[KERNEL2]] = { "uniform-work-group-size"="true" }
+; CHECK: attributes #[[KERNEL1]] = { "amdgpu-calls" "uniform-work-group-size"="false" }
+; CHECK: attributes #[[KERNEL2]] = { "amdgpu-calls" "uniform-work-group-size"="true" }

llvm/test/CodeGen/AMDGPU/uniform-work-group-recursion-test.ll

-; RUN: opt -S -mtriple=amdgcn-amd- -amdgpu-annotate-kernel-features %s | FileCheck %s 
+; RUN: opt -S -mtriple=amdgcn-amd- -amdgpu-annotate-kernel-features %s | FileCheck %s
 
 ; Test to ensure recursive functions exhibit proper behaviour
 ; Test to generate fibonacci numbers
 
 ; CHECK: define i32 @fib(i32 %n) #[[FIB:[0-9]+]] {
 define i32 @fib(i32 %n) #0 {
   %cmp1 = icmp eq i32 %n, 0
   br i1 %cmp1, label %exit, label %cont1
cont2:
   %retval = add i32 %fibm1, %fibm2
 
   ret i32 %retval
 
 exit:
   ret i32 1
 }
 
-; CHECK: define amdgpu_kernel void @kernel(i32 addrspace(1)* %m) #[[FIB]] {
+; CHECK: define amdgpu_kernel void @kernel(i32 addrspace(1)* %m) #[[KERNEL:[0-9]+]] {
 define amdgpu_kernel void @kernel(i32 addrspace(1)* %m) #1 {
   %r = call i32 @fib(i32 5)
   store i32 %r, i32 addrspace(1)* %m
   ret void
 }
 
 attributes #1 = { "uniform-work-group-size"="true" }
 
 ; CHECK: attributes #[[FIB]] = { "uniform-work-group-size"="true" }
+; CHECK: attributes #[[KERNEL]] = { "amdgpu-calls" "uniform-work-group-size"="true" }

llvm/test/CodeGen/AMDGPU/uniform-work-group-test.ll

 define amdgpu_kernel void @kernel3() #0 {
   call void @func2()
   call void @func3()
   ret void
 }
 
 attributes #0 = { "uniform-work-group-size"="false" }
 
-; CHECK: attributes #[[FUNC]] = { "amdgpu-flat-scratch" "uniform-work-group-size"="false" }
+; CHECK: attributes #[[FUNC]] = { "amdgpu-calls" "uniform-work-group-size"="false" }