Coverage Report

Created: 2018-11-16 02:38

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Analysis/LazyBranchProbabilityInfo.h
Line
Count
Source (jump to first uncovered line)
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
  class LazyBranchProbabilityInfo {
58
  public:
59
    LazyBranchProbabilityInfo(const Function *F, const LoopInfo *LI,
60
                              const TargetLibraryInfo *TLI)
61
5.60M
        : Calculated(false), F(F), LI(LI), TLI(TLI) {}
62
63
    /// Retrieve the BPI with the branch probabilities computed.
64
229
    BranchProbabilityInfo &getCalculated() {
65
229
      if (!Calculated) {
66
229
        assert(F && LI && "call setAnalysis");
67
229
        BPI.calculate(*F, *LI, TLI);
68
229
        Calculated = true;
69
229
      }
70
229
      return BPI;
71
229
    }
72
73
0
    const BranchProbabilityInfo &getCalculated() const {
74
0
      return const_cast<LazyBranchProbabilityInfo *>(this)->getCalculated();
75
0
    }
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
197
  BranchProbabilityInfo &getBPI() { return LBPI->getCalculated(); }
94
95
  /// Compute and return the branch probabilities.
96
0
  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
197
  static BranchProbabilityInfo &getBPI(LazyBranchProbabilityInfoPass *P) {
120
197
    return P->getBPI();
121
197
  }
122
};
123
}
124
#endif