LLVM  6.0.0svn
InlineSimple.cpp
Go to the documentation of this file.
1 //===- InlineSimple.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 // This file implements bottom-up inlining of functions into callees.
11 //
12 //===----------------------------------------------------------------------===//
13 
20 #include "llvm/IR/CallSite.h"
21 #include "llvm/IR/CallingConv.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/IR/Instructions.h"
24 #include "llvm/IR/IntrinsicInst.h"
25 #include "llvm/IR/Module.h"
26 #include "llvm/IR/Type.h"
27 #include "llvm/Transforms/IPO.h"
29 
30 using namespace llvm;
31 
32 #define DEBUG_TYPE "inline"
33 
34 namespace {
35 
36 /// \brief Actual inliner pass implementation.
37 ///
38 /// The common implementation of the inlining logic is shared between this
39 /// inliner pass and the always inliner pass. The two passes use different cost
40 /// analyses to determine when to inline.
41 class SimpleInliner : public LegacyInlinerBase {
42 
43  InlineParams Params;
44 
45 public:
46  SimpleInliner() : LegacyInlinerBase(ID), Params(llvm::getInlineParams()) {
48  }
49 
50  explicit SimpleInliner(InlineParams Params)
51  : LegacyInlinerBase(ID), Params(std::move(Params)) {
53  }
54 
55  static char ID; // Pass identification, replacement for typeid
56 
57  InlineCost getInlineCost(CallSite CS) override {
58  Function *Callee = CS.getCalledFunction();
59  TargetTransformInfo &TTI = TTIWP->getTTI(*Callee);
60  std::function<AssumptionCache &(Function &)> GetAssumptionCache =
61  [&](Function &F) -> AssumptionCache & {
62  return ACT->getAssumptionCache(F);
63  };
64  return llvm::getInlineCost(CS, Params, TTI, GetAssumptionCache,
65  /*GetBFI=*/None, PSI);
66  }
67 
68  bool runOnSCC(CallGraphSCC &SCC) override;
69  void getAnalysisUsage(AnalysisUsage &AU) const override;
70 
71 private:
73 
74 };
75 
76 } // end anonymous namespace
77 
78 char SimpleInliner::ID = 0;
79 INITIALIZE_PASS_BEGIN(SimpleInliner, "inline", "Function Integration/Inlining",
80  false, false)
86 INITIALIZE_PASS_END(SimpleInliner, "inline", "Function Integration/Inlining",
87  false, false)
88 
89 Pass *llvm::createFunctionInliningPass() { return new SimpleInliner(); }
90 
92  return new SimpleInliner(llvm::getInlineParams(Threshold));
93 }
94 
96  unsigned SizeOptLevel,
97  bool DisableInlineHotCallSite) {
98  auto Param = llvm::getInlineParams(OptLevel, SizeOptLevel);
99  if (DisableInlineHotCallSite)
100  Param.HotCallSiteThreshold = 0;
101  return new SimpleInliner(Param);
102 }
103 
105  return new SimpleInliner(Params);
106 }
107 
108 bool SimpleInliner::runOnSCC(CallGraphSCC &SCC) {
109  TTIWP = &getAnalysis<TargetTransformInfoWrapperPass>();
110  return LegacyInlinerBase::runOnSCC(SCC);
111 }
112 
113 void SimpleInliner::getAnalysisUsage(AnalysisUsage &AU) const {
116 }
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:81
Thresholds to tune inline cost analysis.
Definition: InlineCost.h:123
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Function Integration Inlining
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void initializeSimpleInlinerPass(PassRegistry &)
An immutable pass that tracks lazily created AssumptionCache objects.
A cache of .assume calls within a function.
Represents the cost of inlining a function.
Definition: InlineCost.h:64
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:424
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
This class contains all of the helper code which is used to perform the inlining operations that do n...
Definition: Inliner.h:31
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
#define F(x, y, z)
Definition: MD5.cpp:55
inline
void getAnalysisUsage(AnalysisUsage &Info) const override
For this class, we declare that we require and preserve the call graph.
Definition: Inliner.cpp:91
Wrapper pass for TargetTransformInfo.
The ModulePass which wraps up a CallGraph and the logic to build it.
Definition: CallGraph.h:318
Represent the analysis usage information of a pass.
INITIALIZE_PASS_BEGIN(SimpleInliner, "inline", "Function Integration/Inlining", false, false) INITIALIZE_PASS_END(SimpleInliner
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)
Get an InlineCost object representing the cost of inlining this callsite.
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.
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:104
static int const Threshold
TODO: Write a new FunctionPass AliasAnalysis so that it can keep a cache.
Pass * createFunctionInliningPass()
createFunctionInliningPass - Return a new pass object that uses a heuristic to inline direct function...
CallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on.
This pass exposes codegen information to IR-level passes.