Line data    Source code

       1             : //===- LazyBranchProbabilityInfo.h - Lazy Branch Probability ----*- 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             : // This is an alternative analysis pass to BranchProbabilityInfoWrapperPass.
      11             : // The difference is that with this pass the branch probabilities are not
      12             : // computed when the analysis pass is executed but rather when the BPI results
      13             : // is explicitly requested by the analysis client.
      14             : //
      15             : //===----------------------------------------------------------------------===//
      16             : 
      17             : #ifndef LLVM_ANALYSIS_LAZYBRANCHPROBABILITYINFO_H
      18             : #define LLVM_ANALYSIS_LAZYBRANCHPROBABILITYINFO_H
      19             : 
      20             : #include "llvm/Analysis/BranchProbabilityInfo.h"
      21             : #include "llvm/Pass.h"
      22             : 
      23             : namespace llvm {
      24             : class AnalysisUsage;
      25             : class Function;
      26             : class LoopInfo;
      27             : class TargetLibraryInfo;
      28             : 
      29             : /// This is an alternative analysis pass to
      30             : /// BranchProbabilityInfoWrapperPass.  The difference is that with this pass the
      31             : /// branch probabilities are not computed when the analysis pass is executed but
      32             : /// rather when the BPI results is explicitly requested by the analysis client.
      33             : ///
      34             : /// There are some additional requirements for any client pass that wants to use
      35             : /// the analysis:
      36             : ///
      37             : /// 1. The pass needs to initialize dependent passes with:
      38             : ///
      39             : ///   INITIALIZE_PASS_DEPENDENCY(LazyBPIPass)
      40             : ///
      41             : /// 2. Similarly, getAnalysisUsage should call:
      42             : ///
      43             : ///   LazyBranchProbabilityInfoPass::getLazyBPIAnalysisUsage(AU)
      44             : ///
      45             : /// 3. The computed BPI should be requested with
      46             : ///    getAnalysis<LazyBranchProbabilityInfoPass>().getBPI() before LoopInfo
      47             : ///    could be invalidated for example by changing the CFG.
      48             : ///
      49             : /// Note that it is expected that we wouldn't need this functionality for the
      50             : /// new PM since with the new PM, analyses are executed on demand.
      51             : class LazyBranchProbabilityInfoPass : public FunctionPass {
      52             : 
      53             :   /// Wraps a BPI to allow lazy computation of the branch probabilities.
      54             :   ///
      55             :   /// A pass that only conditionally uses BPI can uncondtionally require the
      56             :   /// analysis without paying for the overhead if BPI doesn't end up being used.
      57      468603 :   class LazyBranchProbabilityInfo {
      58             :   public:
      59             :     LazyBranchProbabilityInfo(const Function *F, const LoopInfo *LI,
      60             :                               const TargetLibraryInfo *TLI)
      61           0 :         : Calculated(false), F(F), LI(LI), TLI(TLI) {}
      62             : 
      63             :     /// Retrieve the BPI with the branch probabilities computed.
      64             :     BranchProbabilityInfo &getCalculated() {
      65         241 :       if (!Calculated) {
      66             :         assert(F && LI && "call setAnalysis");
      67         241 :         BPI.calculate(*F, *LI, TLI);
      68         241 :         Calculated = true;
      69             :       }
      70         241 :       return BPI;
      71             :     }
      72             : 
      73             :     const BranchProbabilityInfo &getCalculated() const {
      74             :       return const_cast<LazyBranchProbabilityInfo *>(this)->getCalculated();
      75             :     }
      76             : 
      77             :   private:
      78             :     BranchProbabilityInfo BPI;
      79             :     bool Calculated;
      80             :     const Function *F;
      81             :     const LoopInfo *LI;
      82             :     const TargetLibraryInfo *TLI;
      83             :   };
      84             : 
      85             :   std::unique_ptr<LazyBranchProbabilityInfo> LBPI;
      86             : 
      87             : public:
      88             :   static char ID;
      89             : 
      90             :   LazyBranchProbabilityInfoPass();
      91             : 
      92             :   /// Compute and return the branch probabilities.
      93         209 :   BranchProbabilityInfo &getBPI() { return LBPI->getCalculated(); }
      94             : 
      95             :   /// Compute and return the branch probabilities.
      96             :   const BranchProbabilityInfo &getBPI() const { return LBPI->getCalculated(); }
      97             : 
      98             :   void getAnalysisUsage(AnalysisUsage &AU) const override;
      99             : 
     100             :   /// Helper for client passes to set up the analysis usage on behalf of this
     101             :   /// pass.
     102             :   static void getLazyBPIAnalysisUsage(AnalysisUsage &AU);
     103             : 
     104             :   bool runOnFunction(Function &F) override;
     105             :   void releaseMemory() override;
     106             :   void print(raw_ostream &OS, const Module *M) const override;
     107             : };
     108             : 
     109             : /// Helper for client passes to initialize dependent passes for LBPI.
     110             : void initializeLazyBPIPassPass(PassRegistry &Registry);
     111             : 
     112             : /// Simple trait class that provides a mapping between BPI passes and the
     113             : /// corresponding BPInfo.
     114             : template <typename PassT> struct BPIPassTrait {
     115             :   static PassT &getBPI(PassT *P) { return *P; }
     116             : };
     117             : 
     118             : template <> struct BPIPassTrait<LazyBranchProbabilityInfoPass> {
     119             :   static BranchProbabilityInfo &getBPI(LazyBranchProbabilityInfoPass *P) {
     120         209 :     return P->getBPI();
     121             :   }
     122             : };
     123             : }
     124             : #endif