contrib/llvm/include/llvm/Transforms/IPO/Inliner.h

   1 //===- Inliner.h - Inliner pass and infrastructure --------------*- C++ -*-===//
   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 #ifndef LLVM_TRANSFORMS_IPO_INLINER_H
  11 #define LLVM_TRANSFORMS_IPO_INLINER_H
  12
  13 #include "llvm/Analysis/CGSCCPassManager.h"
  14 #include "llvm/Analysis/CallGraphSCCPass.h"
  15 #include "llvm/Analysis/InlineCost.h"
  16 #include "llvm/Analysis/LazyCallGraph.h"
  17 #include "llvm/IR/CallSite.h"
  18 #include "llvm/IR/PassManager.h"
  19 #include "llvm/Transforms/Utils/ImportedFunctionsInliningStatistics.h"
  20 #include <utility>
  21
  22 namespace llvm {
  23
  24 class AssumptionCacheTracker;
  25 class CallGraph;
  26 class ProfileSummaryInfo;
  27
  28 /// This class contains all of the helper code which is used to perform the
  29 /// inlining operations that do not depend on the policy. It contains the core
  30 /// bottom-up inlining infrastructure that specific inliner passes use.
  31 struct LegacyInlinerBase : public CallGraphSCCPass {
  32   explicit LegacyInlinerBase(char &ID);
  33   explicit LegacyInlinerBase(char &ID, bool InsertLifetime);
  34
  35   /// For this class, we declare that we require and preserve the call graph.
  36   /// If the derived class implements this method, it should always explicitly
  37   /// call the implementation here.
  38   void getAnalysisUsage(AnalysisUsage &Info) const override;
  39
  40   bool doInitialization(CallGraph &CG) override;
  41
  42   /// Main run interface method, this implements the interface required by the
  43   /// Pass class.
  44   bool runOnSCC(CallGraphSCC &SCC) override;
  45
  46   using llvm::Pass::doFinalization;
  47
  48   /// Remove now-dead linkonce functions at the end of processing to avoid
  49   /// breaking the SCC traversal.
  50   bool doFinalization(CallGraph &CG) override;
  51
  52   /// This method must be implemented by the subclass to determine the cost of
  53   /// inlining the specified call site.  If the cost returned is greater than
  54   /// the current inline threshold, the call site is not inlined.
  55   virtual InlineCost getInlineCost(CallSite CS) = 0;
  56
  57   /// Remove dead functions.
  58   ///
  59   /// This also includes a hack in the form of the 'AlwaysInlineOnly' flag
  60   /// which restricts it to deleting functions with an 'AlwaysInline'
  61   /// attribute. This is useful for the InlineAlways pass that only wants to
  62   /// deal with that subset of the functions.
  63   bool removeDeadFunctions(CallGraph &CG, bool AlwaysInlineOnly = false);
  64
  65   /// This function performs the main work of the pass.  The default of
  66   /// Inlinter::runOnSCC() calls skipSCC() before calling this method, but
  67   /// derived classes which cannot be skipped can override that method and call
  68   /// this function unconditionally.
  69   bool inlineCalls(CallGraphSCC &SCC);
  70
  71 private:
  72   // Insert @llvm.lifetime intrinsics.
  73   bool InsertLifetime = true;
  74
  75 protected:
  76   AssumptionCacheTracker *ACT;
  77   ProfileSummaryInfo *PSI;
  78   ImportedFunctionsInliningStatistics ImportedFunctionsStats;
  79 };
  80
  81 /// The inliner pass for the new pass manager.
  82 ///
  83 /// This pass wires together the inlining utilities and the inline cost
  84 /// analysis into a CGSCC pass. It considers every call in every function in
  85 /// the SCC and tries to inline if profitable. It can be tuned with a number of
  86 /// parameters to control what cost model is used and what tradeoffs are made
  87 /// when making the decision.
  88 ///
  89 /// It should be noted that the legacy inliners do considerably more than this
  90 /// inliner pass does. They provide logic for manually merging allocas, and
  91 /// doing considerable DCE including the DCE of dead functions. This pass makes
  92 /// every attempt to be simpler. DCE of functions requires complex reasoning
  93 /// about comdat groups, etc. Instead, it is expected that other more focused
  94 /// passes be composed to achieve the same end result.
  95 class InlinerPass : public PassInfoMixin<InlinerPass> {
  96 public:
  97   InlinerPass(InlineParams Params = getInlineParams())
  98       : Params(std::move(Params)) {}
  99   ~InlinerPass();
 100   InlinerPass(InlinerPass &&Arg)
 101       : Params(std::move(Arg.Params)),
 102         ImportedFunctionsStats(std::move(Arg.ImportedFunctionsStats)) {}
 103
 104   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
 105                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
 106
 107 private:
 108   InlineParams Params;
 109   std::unique_ptr<ImportedFunctionsInliningStatistics> ImportedFunctionsStats;
 110 };
 111
 112 } // end namespace llvm
 113
 114 #endif // LLVM_TRANSFORMS_IPO_INLINER_H