AMDGPU: Remove wrapper only call limitation

[arsenm]

Summary

This seems to only have overridden cold handling, which we probably
shouldn't do. As far as I can tell the wrapper library functions are still inlined as appropriate.

[aeubanks]

I suppose doing some benchmarking would be ideal, but this makes sense, I can't imagine why these sorts of functions wouldn't be inlined other than attributes like coldcc/noinline.

[aeubanks]

is this good to go?

[arsenm]

3d397091591fca4aa16153bba22f031218bee47d

llvm/lib/Target/AMDGPU/AMDGPUInline.cpp

for (Value *PtrArg : CB.args()) {
     }
   }
   if (AllocaSize)
     Thres += ArgAllocaCost;
 
   return (unsigned)Thres;
 }
 
-// Check if call is just a wrapper around another call.
-// In this case we only have call and ret instructions.
-static bool isWrapperOnlyCall(CallBase &CB) {
-  Function *Callee = CB.getCalledFunction();
-  if (!Callee || Callee->size() != 1)
-    return false;
-  const BasicBlock &BB = Callee->getEntryBlock();
-  if (const Instruction *I = BB.getFirstNonPHI()) {
-    if (!isa<CallInst>(I)) {
-      return false;
-    }
-    if (isa<ReturnInst>(*std::next(I->getIterator()))) {
-      LLVM_DEBUG(dbgs() << "    Wrapper only call detected: "
-                        << Callee->getName() << '\n');
-      return true;
-    }
-  }
-  return false;
-}
-
 InlineCost AMDGPUInliner::getInlineCost(CallBase &CB) {
   Function *Callee = CB.getCalledFunction();
   Function *Caller = CB.getCaller();
 
   if (!Callee || Callee->isDeclaration())
     return llvm::InlineCost::getNever("undefined callee");
 
   if (CB.isNoInline())
     return llvm::InlineCost::getNever("noinline");
 
   TargetTransformInfo &TTI = TTIWP->getTTI(*Callee);
   if (!TTI.areInlineCompatible(Caller, Callee))
     return llvm::InlineCost::getNever("incompatible");
 
   if (CB.hasFnAttr(Attribute::AlwaysInline)) {
     auto IsViable = isInlineViable(*Callee);
     if (IsViable.isSuccess())
       return llvm::InlineCost::getAlways("alwaysinline viable");
     return llvm::InlineCost::getNever(IsViable.getFailureReason());
   }
 
-  if (isWrapperOnlyCall(CB))
-    return llvm::InlineCost::getAlways("wrapper-only call");
-
   InlineParams LocalParams = Params;
   LocalParams.DefaultThreshold = (int)getInlineThreshold(CB);
   bool RemarksEnabled = false;
   const auto &BBs = Caller->getBasicBlockList();
   if (!BBs.empty()) {
     auto DI = OptimizationRemark(DEBUG_TYPE, "", DebugLoc(), &BBs.front());
     if (DI.isEnabled())
       RemarksEnabled = true;

llvm/test/CodeGen/AMDGPU/amdgpu-inline.ll

if.then:
   %div = fdiv float 2.000000e+00, %tmp1
   store float %div, float addrspace(5)* %p2, align 4
   br label %if.end
 
 if.end:
   ret void
 }
 
-define coldcc float @sin_wrapper(float %x) {
+define float @sin_wrapper(float %x) {
 bb:
   %call = tail call float @_Z3sinf(float %x)
   ret float %call
 }
 
 define void @foo_noinline(float addrspace(5)* nocapture %p) #0 {
 entry:
   %tmp1 = load float, float addrspace(5)* %p, align 4
entry:
   call coldcc void @foo_private_ptr(float addrspace(5)* %arrayidx7)
   %arrayidx8 = getelementptr inbounds [64 x float], [64 x float] addrspace(5)* %pvt_arr, i32 0, i32 1
   %arrayidx9 = getelementptr inbounds [64 x float], [64 x float] addrspace(5)* %pvt_arr, i32 0, i32 2
   call coldcc void @foo_private_ptr2(float addrspace(5)* %arrayidx8, float addrspace(5)* %arrayidx9)
   call void @foo_noinline(float addrspace(5)* %arrayidx7)
   %and = and i32 %tid, %n
   %arrayidx11 = getelementptr inbounds [64 x float], [64 x float] addrspace(5)* %pvt_arr, i32 0, i32 %and
   %tmp12 = load float, float addrspace(5)* %arrayidx11, align 4
-  %c2 = call coldcc float @sin_wrapper(float %tmp12)
+  %c2 = call float @sin_wrapper(float %tmp12)
   store float %c2, float addrspace(5)* %arrayidx7, align 4
   %xor = xor i32 %tid, %n
   %arrayidx16 = getelementptr inbounds [64 x float], [64 x float] addrspace(5)* %pvt_arr, i32 0, i32 %xor
   %tmp16 = load float, float addrspace(5)* %arrayidx16, align 4
   store float %tmp16, float addrspace(1)* %arrayidx, align 4
   ret void
 }