LLVM  8.0.0svn
AMDGPUInline.cpp
Go to the documentation of this file.
1 //===- AMDGPUInline.cpp - Code to perform simple function inlining --------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 /// \file
11 /// This is AMDGPU specific replacement of the standard inliner.
12 /// The main purpose is to account for the fact that calls not only expensive
13 /// on the AMDGPU, but much more expensive if a private memory pointer is
14 /// passed to a function as an argument. In this situation, we are unable to
15 /// eliminate private memory in the caller unless inlined and end up with slow
16 /// and expensive scratch access. Thus, we boost the inline threshold for such
17 /// functions here.
18 ///
19 //===----------------------------------------------------------------------===//
20 
21 
22 #include "AMDGPU.h"
23 #include "llvm/Transforms/IPO.h"
29 #include "llvm/IR/CallSite.h"
30 #include "llvm/IR/DataLayout.h"
31 #include "llvm/IR/Instructions.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/IR/Type.h"
35 #include "llvm/Support/Debug.h"
37 
38 using namespace llvm;
39 
40 #define DEBUG_TYPE "inline"
41 
42 static cl::opt<int>
43 ArgAllocaCost("amdgpu-inline-arg-alloca-cost", cl::Hidden, cl::init(2200),
44  cl::desc("Cost of alloca argument"));
45 
46 // If the amount of scratch memory to eliminate exceeds our ability to allocate
47 // it into registers we gain nothing by aggressively inlining functions for that
48 // heuristic.
49 static cl::opt<unsigned>
50 ArgAllocaCutoff("amdgpu-inline-arg-alloca-cutoff", cl::Hidden, cl::init(256),
51  cl::desc("Maximum alloca size to use for inline cost"));
52 
53 namespace {
54 
55 class AMDGPUInliner : public LegacyInlinerBase {
56 
57 public:
58  AMDGPUInliner() : LegacyInlinerBase(ID) {
60  Params = getInlineParams();
61  }
62 
63  static char ID; // Pass identification, replacement for typeid
64 
65  unsigned getInlineThreshold(CallSite CS) const;
66 
67  InlineCost getInlineCost(CallSite CS) override;
68 
69  bool runOnSCC(CallGraphSCC &SCC) override;
70 
71  void getAnalysisUsage(AnalysisUsage &AU) const override;
72 
73 private:
75 
76  InlineParams Params;
77 };
78 
79 } // end anonymous namespace
80 
81 char AMDGPUInliner::ID = 0;
82 INITIALIZE_PASS_BEGIN(AMDGPUInliner, "amdgpu-inline",
83  "AMDGPU Function Integration/Inlining", false, false)
89 INITIALIZE_PASS_END(AMDGPUInliner, "amdgpu-inline",
90  "AMDGPU Function Integration/Inlining", false, false)
91 
92 Pass *llvm::createAMDGPUFunctionInliningPass() { return new AMDGPUInliner(); }
93 
94 bool AMDGPUInliner::runOnSCC(CallGraphSCC &SCC) {
95  TTIWP = &getAnalysis<TargetTransformInfoWrapperPass>();
96  return LegacyInlinerBase::runOnSCC(SCC);
97 }
98 
99 void AMDGPUInliner::getAnalysisUsage(AnalysisUsage &AU) const {
102 }
103 
104 unsigned AMDGPUInliner::getInlineThreshold(CallSite CS) const {
105  int Thres = Params.DefaultThreshold;
106 
107  Function *Caller = CS.getCaller();
108  // Listen to the inlinehint attribute when it would increase the threshold
109  // and the caller does not need to minimize its size.
111  bool InlineHint = Callee && !Callee->isDeclaration() &&
112  Callee->hasFnAttribute(Attribute::InlineHint);
113  if (InlineHint && Params.HintThreshold && Params.HintThreshold > Thres
114  && !Caller->hasFnAttribute(Attribute::MinSize))
115  Thres = Params.HintThreshold.getValue();
116 
117  const DataLayout &DL = Caller->getParent()->getDataLayout();
118  if (!Callee)
119  return (unsigned)Thres;
120 
121  // If we have a pointer to private array passed into a function
122  // it will not be optimized out, leaving scratch usage.
123  // Increase the inline threshold to allow inliniting in this case.
124  uint64_t AllocaSize = 0;
126  for (Value *PtrArg : CS.args()) {
127  Type *Ty = PtrArg->getType();
128  if (!Ty->isPointerTy() ||
130  continue;
131  PtrArg = GetUnderlyingObject(PtrArg, DL);
132  if (const AllocaInst *AI = dyn_cast<AllocaInst>(PtrArg)) {
133  if (!AI->isStaticAlloca() || !AIVisited.insert(AI).second)
134  continue;
135  AllocaSize += DL.getTypeAllocSize(AI->getAllocatedType());
136  // If the amount of stack memory is excessive we will not be able
137  // to get rid of the scratch anyway, bail out.
138  if (AllocaSize > ArgAllocaCutoff) {
139  AllocaSize = 0;
140  break;
141  }
142  }
143  }
144  if (AllocaSize)
145  Thres += ArgAllocaCost;
146 
147  return (unsigned)Thres;
148 }
149 
150 // Check if call is just a wrapper around another call.
151 // In this case we only have call and ret instructions.
152 static bool isWrapperOnlyCall(CallSite CS) {
154  if (!Callee || Callee->size() != 1)
155  return false;
156  const BasicBlock &BB = Callee->getEntryBlock();
157  if (const Instruction *I = BB.getFirstNonPHI()) {
158  if (!isa<CallInst>(I)) {
159  return false;
160  }
161  if (isa<ReturnInst>(*std::next(I->getIterator()))) {
162  LLVM_DEBUG(dbgs() << " Wrapper only call detected: "
163  << Callee->getName() << '\n');
164  return true;
165  }
166  }
167  return false;
168 }
169 
172  Function *Caller = CS.getCaller();
173  TargetTransformInfo &TTI = TTIWP->getTTI(*Callee);
174 
175  if (!Callee || Callee->isDeclaration())
176  return llvm::InlineCost::getNever("undefined callee");
177 
178  if (CS.isNoInline())
179  return llvm::InlineCost::getNever("noinline");
180 
181  if (!TTI.areInlineCompatible(Caller, Callee))
182  return llvm::InlineCost::getNever("incompatible");
183 
184  if (CS.hasFnAttr(Attribute::AlwaysInline)) {
185  if (isInlineViable(*Callee))
186  return llvm::InlineCost::getAlways("alwaysinline viable");
187  return llvm::InlineCost::getNever("alwaysinline unviable");
188  }
189 
190  if (isWrapperOnlyCall(CS))
191  return llvm::InlineCost::getAlways("wrapper-only call");
192 
193  InlineParams LocalParams = Params;
194  LocalParams.DefaultThreshold = (int)getInlineThreshold(CS);
195  bool RemarksEnabled = false;
196  const auto &BBs = Caller->getBasicBlockList();
197  if (!BBs.empty()) {
198  auto DI = OptimizationRemark(DEBUG_TYPE, "", DebugLoc(), &BBs.front());
199  if (DI.isEnabled())
200  RemarksEnabled = true;
201  }
202 
203  OptimizationRemarkEmitter ORE(Caller);
204  std::function<AssumptionCache &(Function &)> GetAssumptionCache =
205  [this](Function &F) -> AssumptionCache & {
206  return ACT->getAssumptionCache(F);
207  };
208 
209  return llvm::getInlineCost(CS, Callee, LocalParams, TTI, GetAssumptionCache,
210  None, PSI, RemarksEnabled ? &ORE : nullptr);
211 }
size_t size() const
Definition: Function.h:661
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:81
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
Thresholds to tune inline cost analysis.
Definition: InlineCost.h:154
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
This class represents lattice values for constants.
Definition: AllocatorList.h:24
#define DEBUG_TYPE
An immutable pass that tracks lazily created AssumptionCache objects.
iterator_range< IterTy > args() const
Definition: CallSite.h:215
A cache of @llvm.assume calls within a function.
Address space for private memory.
Definition: AMDGPU.h:257
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:321
A debug info location.
Definition: DebugLoc.h:34
F(f)
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:503
static bool isWrapperOnlyCall(CallSite CS)
Represents the cost of inlining a function.
Definition: InlineCost.h:64
bool isNoInline() const
Return true if the call should not be inlined.
Definition: CallSite.h:438
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:51
bool runOnSCC(CallGraphSCC &SCC) override
Main run interface method, this implements the interface required by the Pass class.
Definition: Inliner.cpp:491
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:365
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
Pass * createAMDGPUFunctionInliningPass()
This class contains all of the helper code which is used to perform the inlining operations that do n...
Definition: Inliner.h:31
amdgpu AMDGPU Function Integration Inlining
bool isInlineViable(Function &Callee)
Minimal filter to detect invalid constructs for inlining.
void initializeAMDGPUInlinerPass(PassRegistry &)
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
static cl::opt< unsigned > ArgAllocaCutoff("amdgpu-inline-arg-alloca-cutoff", cl::Hidden, cl::init(256), cl::desc("Maximum alloca size to use for inline cost"))
static InlineCost getAlways(const char *Reason)
Definition: InlineCost.h:92
amdgpu Simplify well known AMD library false Value * Callee
const BasicBlock & getEntryBlock() const
Definition: Function.h:640
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:419
void getAnalysisUsage(AnalysisUsage &Info) const override
For this class, we declare that we require and preserve the call graph.
Definition: Inliner.cpp:132
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:190
Wrapper pass for TargetTransformInfo.
The ModulePass which wraps up a CallGraph and the logic to build it.
Definition: CallGraph.h:324
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
bool hasFnAttr(Attribute::AttrKind Kind) const
Return true if this function has the given attribute.
Definition: CallSite.h:362
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:224
amdgpu inline
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:371
Diagnostic information for applied optimization remarks.
Represent the analysis usage information of a pass.
Value * GetUnderlyingObject(Value *V, const DataLayout &DL, unsigned MaxLookup=6)
This method strips off any GEP address adjustments and pointer casts from the specified value...
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
InlineCost getInlineCost(CallSite CS, const InlineParams &Params, TargetTransformInfo &CalleeTTI, std::function< AssumptionCache &(Function &)> &GetAssumptionCache, Optional< function_ref< BlockFrequencyInfo &(Function &)>> GetBFI, ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE=nullptr)
Get an InlineCost object representing the cost of inlining this callsite.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:418
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
InlineParams getInlineParams()
Generate the parameters to tune the inline cost analysis based only on the commandline options...
Module.h This file contains the declarations for the Module class.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:428
FunTy * getCaller() const
Return the caller function for this call site.
Definition: CallSite.h:267
static InlineCost getNever(const char *Reason)
Definition: InlineCost.h:95
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:215
bool areInlineCompatible(const Function *Caller, const Function *Callee) const
#define I(x, y, z)
Definition: MD5.cpp:58
const BasicBlockListType & getBasicBlockList() const
Get the underlying elements of the Function...
Definition: Function.h:633
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:206
static cl::opt< int > ArgAllocaCost("amdgpu-inline-arg-alloca-cost", cl::Hidden, cl::init(2200), cl::desc("Cost of alloca argument"))
FunTy * getCalledFunction() const
Return the function being called if this is a direct call, otherwise return null (if it&#39;s an indirect...
Definition: CallSite.h:107
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:566
INITIALIZE_PASS_BEGIN(AMDGPUInliner, "amdgpu-inline", "AMDGPU Function Integration/Inlining", false, false) INITIALIZE_PASS_END(AMDGPUInliner
LLVM Value Representation.
Definition: Value.h:73
CallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on.
This pass exposes codegen information to IR-level passes.
#define LLVM_DEBUG(X)
Definition: Debug.h:123
The optimization diagnostic interface.
int DefaultThreshold
The default threshold to start with for a callee.
Definition: InlineCost.h:156
an instruction to allocate memory on the stack
Definition: Instructions.h:60