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/Analysis/TargetTransformInfo.h"
     18 #include "llvm/Transforms/Utils/ImportedFunctionsInliningStatistics.h"
     19 
     20 namespace llvm {
     21 class AssumptionCacheTracker;
     22 class CallSite;
     23 class DataLayout;
     24 class InlineCost;
     25 class OptimizationRemarkEmitter;
     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   /// Remove now-dead linkonce functions at the end of processing to avoid
     48   /// breaking the SCC traversal.
     49   bool doFinalization(CallGraph &CG) override;
     50 
     51   /// This method must be implemented by the subclass to determine the cost of
     52   /// inlining the specified call site.  If the cost returned is greater than
     53   /// the current inline threshold, the call site is not inlined.
     54   virtual InlineCost getInlineCost(CallSite CS) = 0;
     55 
     56   /// Remove dead functions.
     57   ///
     58   /// This also includes a hack in the form of the 'AlwaysInlineOnly' flag
     59   /// which restricts it to deleting functions with an 'AlwaysInline'
     60   /// attribute. This is useful for the InlineAlways pass that only wants to
     61   /// deal with that subset of the functions.
     62   bool removeDeadFunctions(CallGraph &CG, bool AlwaysInlineOnly = false);
     63 
     64   /// This function performs the main work of the pass.  The default of
     65   /// Inlinter::runOnSCC() calls skipSCC() before calling this method, but
     66   /// derived classes which cannot be skipped can override that method and call
     67   /// this function unconditionally.
     68   bool inlineCalls(CallGraphSCC &SCC);
     69 
     70 private:
     71   // Insert @llvm.lifetime intrinsics.
     72   bool InsertLifetime;
     73 
     74 protected:
     75   AssumptionCacheTracker *ACT;
     76   ProfileSummaryInfo *PSI;
     77   ImportedFunctionsInliningStatistics ImportedFunctionsStats;
     78 };
     79 
     80 /// The inliner pass for the new pass manager.
     81 ///
     82 /// This pass wires together the inlining utilities and the inline cost
     83 /// analysis into a CGSCC pass. It considers every call in every function in
     84 /// the SCC and tries to inline if profitable. It can be tuned with a number of
     85 /// parameters to control what cost model is used and what tradeoffs are made
     86 /// when making the decision.
     87 ///
     88 /// It should be noted that the legacy inliners do considerably more than this
     89 /// inliner pass does. They provide logic for manually merging allocas, and
     90 /// doing considerable DCE including the DCE of dead functions. This pass makes
     91 /// every attempt to be simpler. DCE of functions requires complex reasoning
     92 /// about comdat groups, etc. Instead, it is expected that other more focused
     93 /// passes be composed to achieve the same end result.
     94 class InlinerPass : public PassInfoMixin<InlinerPass> {
     95 public:
     96   InlinerPass(InlineParams Params = getInlineParams())
     97       : Params(std::move(Params)) {}
     98 
     99   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
    100                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
    101 
    102 private:
    103   InlineParams Params;
    104 };
    105 
    106 } // End llvm namespace
    107 
    108 #endif
    109