LCOV - code coverage report
Current view: top level - include/llvm/Transforms/IPO - Inliner.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 3 3 100.0 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       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       15440 : 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        1322 : class InlinerPass : public PassInfoMixin<InlinerPass> {
      95             : public:
      96             :   InlinerPass(InlineParams Params = getInlineParams())
      97         160 :       : 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

Generated by: LCOV version 1.13