Coverage Report

Created: 2019-03-22 08:08

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