Home | History | Annotate | Download | only in IPO 
      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 
    100   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
    101                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
    102 
    103 private:
    104   InlineParams Params;
    105 };
    106 
    107 } // end namespace llvm
    108 
    109 #endif // LLVM_TRANSFORMS_IPO_INLINER_H
    110