Line data Source code
1 : //===- BlockFrequencyInfo.h - Block Frequency Analysis ----------*- 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 : // Loops should be simplified before this analysis.
11 : //
12 : //===----------------------------------------------------------------------===//
13 :
14 : #ifndef LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H
15 : #define LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H
16 :
17 : #include "llvm/ADT/Optional.h"
18 : #include "llvm/IR/PassManager.h"
19 : #include "llvm/Pass.h"
20 : #include "llvm/Support/BlockFrequency.h"
21 : #include <cstdint>
22 : #include <memory>
23 :
24 : namespace llvm {
25 :
26 : class BasicBlock;
27 : class BranchProbabilityInfo;
28 : class Function;
29 : class LoopInfo;
30 : class Module;
31 : class raw_ostream;
32 : template <class BlockT> class BlockFrequencyInfoImpl;
33 :
34 : enum PGOViewCountsType { PGOVCT_None, PGOVCT_Graph, PGOVCT_Text };
35 :
36 : /// BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to
37 : /// estimate IR basic block frequencies.
38 385246 : class BlockFrequencyInfo {
39 : using ImplType = BlockFrequencyInfoImpl<BasicBlock>;
40 :
41 : std::unique_ptr<ImplType> BFI;
42 :
43 : public:
44 : BlockFrequencyInfo();
45 : BlockFrequencyInfo(const Function &F, const BranchProbabilityInfo &BPI,
46 : const LoopInfo &LI);
47 : BlockFrequencyInfo(const BlockFrequencyInfo &) = delete;
48 : BlockFrequencyInfo &operator=(const BlockFrequencyInfo &) = delete;
49 : BlockFrequencyInfo(BlockFrequencyInfo &&Arg);
50 : BlockFrequencyInfo &operator=(BlockFrequencyInfo &&RHS);
51 : ~BlockFrequencyInfo();
52 :
53 : /// Handle invalidation explicitly.
54 : bool invalidate(Function &F, const PreservedAnalyses &PA,
55 : FunctionAnalysisManager::Invalidator &);
56 :
57 : const Function *getFunction() const;
58 : const BranchProbabilityInfo *getBPI() const;
59 : void view() const;
60 :
61 : /// getblockFreq - Return block frequency. Return 0 if we don't have the
62 : /// information. Please note that initial frequency is equal to ENTRY_FREQ. It
63 : /// means that we should not rely on the value itself, but only on the
64 : /// comparison to the other block frequencies. We do this to avoid using of
65 : /// floating points.
66 : BlockFrequency getBlockFreq(const BasicBlock *BB) const;
67 :
68 : /// Returns the estimated profile count of \p BB.
69 : /// This computes the relative block frequency of \p BB and multiplies it by
70 : /// the enclosing function's count (if available) and returns the value.
71 : Optional<uint64_t> getBlockProfileCount(const BasicBlock *BB) const;
72 :
73 : /// Returns the estimated profile count of \p Freq.
74 : /// This uses the frequency \p Freq and multiplies it by
75 : /// the enclosing function's count (if available) and returns the value.
76 : Optional<uint64_t> getProfileCountFromFreq(uint64_t Freq) const;
77 :
78 : /// Returns true if \p BB is an irreducible loop header
79 : /// block. Otherwise false.
80 : bool isIrrLoopHeader(const BasicBlock *BB);
81 :
82 : // Set the frequency of the given basic block.
83 : void setBlockFreq(const BasicBlock *BB, uint64_t Freq);
84 :
85 : /// Set the frequency of \p ReferenceBB to \p Freq and scale the frequencies
86 : /// of the blocks in \p BlocksToScale such that their frequencies relative
87 : /// to \p ReferenceBB remain unchanged.
88 : void setBlockFreqAndScale(const BasicBlock *ReferenceBB, uint64_t Freq,
89 : SmallPtrSetImpl<BasicBlock *> &BlocksToScale);
90 :
91 : /// calculate - compute block frequency info for the given function.
92 : void calculate(const Function &F, const BranchProbabilityInfo &BPI,
93 : const LoopInfo &LI);
94 :
95 : // Print the block frequency Freq to OS using the current functions entry
96 : // frequency to convert freq into a relative decimal form.
97 : raw_ostream &printBlockFreq(raw_ostream &OS, const BlockFrequency Freq) const;
98 :
99 : // Convenience method that attempts to look up the frequency associated with
100 : // BB and print it to OS.
101 : raw_ostream &printBlockFreq(raw_ostream &OS, const BasicBlock *BB) const;
102 :
103 : uint64_t getEntryFreq() const;
104 : void releaseMemory();
105 : void print(raw_ostream &OS) const;
106 : };
107 :
108 : /// Analysis pass which computes \c BlockFrequencyInfo.
109 : class BlockFrequencyAnalysis
110 : : public AnalysisInfoMixin<BlockFrequencyAnalysis> {
111 : friend AnalysisInfoMixin<BlockFrequencyAnalysis>;
112 :
113 : static AnalysisKey Key;
114 :
115 : public:
116 : /// Provide the result type for this analysis pass.
117 : using Result = BlockFrequencyInfo;
118 :
119 : /// Run the analysis pass over a function and produce BFI.
120 : Result run(Function &F, FunctionAnalysisManager &AM);
121 : };
122 :
123 : /// Printer pass for the \c BlockFrequencyInfo results.
124 : class BlockFrequencyPrinterPass
125 : : public PassInfoMixin<BlockFrequencyPrinterPass> {
126 : raw_ostream &OS;
127 :
128 : public:
129 13 : explicit BlockFrequencyPrinterPass(raw_ostream &OS) : OS(OS) {}
130 :
131 : PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
132 : };
133 :
134 : /// Legacy analysis pass which computes \c BlockFrequencyInfo.
135 68078 : class BlockFrequencyInfoWrapperPass : public FunctionPass {
136 : BlockFrequencyInfo BFI;
137 :
138 : public:
139 : static char ID;
140 :
141 : BlockFrequencyInfoWrapperPass();
142 : ~BlockFrequencyInfoWrapperPass() override;
143 :
144 264253 : BlockFrequencyInfo &getBFI() { return BFI; }
145 : const BlockFrequencyInfo &getBFI() const { return BFI; }
146 :
147 : void getAnalysisUsage(AnalysisUsage &AU) const override;
148 :
149 : bool runOnFunction(Function &F) override;
150 : void releaseMemory() override;
151 : void print(raw_ostream &OS, const Module *M) const override;
152 : };
153 :
154 : } // end namespace llvm
155 :
156 : #endif // LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H
|
