LLVM  4.0.0
ProfileSummaryInfo.h
Go to the documentation of this file.
1 //===- llvm/Analysis/ProfileSummaryInfo.h - profile summary ---*- 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 file contains a pass that provides access to profile summary
11 // information.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_ANALYSIS_PROFILE_SUMMARY_INFO_H
16 #define LLVM_ANALYSIS_PROFILE_SUMMARY_INFO_H
17 
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/SmallSet.h"
21 #include "llvm/IR/Function.h"
22 #include "llvm/IR/Instructions.h"
23 #include "llvm/IR/PassManager.h"
24 #include "llvm/IR/ProfileSummary.h"
25 #include "llvm/IR/ValueHandle.h"
26 #include "llvm/Pass.h"
27 #include <memory>
28 
29 namespace llvm {
30 class BasicBlock;
31 class BlockFrequencyInfo;
32 class ProfileSummary;
33 /// \brief Analysis providing profile information.
34 ///
35 /// This is an immutable analysis pass that provides ability to query global
36 /// (program-level) profile information. The main APIs are isHotCount and
37 /// isColdCount that tells whether a given profile count is considered hot/cold
38 /// based on the profile summary. This also provides convenience methods to
39 /// check whether a function is hot or cold.
40 
41 // FIXME: Provide convenience methods to determine hotness/coldness of other IR
42 // units. This would require making this depend on BFI.
44 private:
45  Module &M;
46  std::unique_ptr<ProfileSummary> Summary;
47  void computeSummary();
48  void computeThresholds();
49  // Count thresholds to answer isHotCount and isColdCount queries.
50  Optional<uint64_t> HotCountThreshold, ColdCountThreshold;
51 
52 public:
53  ProfileSummaryInfo(Module &M) : M(M) {}
55  : M(Arg.M), Summary(std::move(Arg.Summary)) {}
56  /// \brief Returns true if \p F has hot function entry.
57  bool isFunctionEntryHot(const Function *F);
58  /// \brief Returns true if \p F has cold function entry.
59  bool isFunctionEntryCold(const Function *F);
60  /// \brief Returns true if \p F is a hot function.
61  bool isHotCount(uint64_t C);
62  /// \brief Returns true if count \p C is considered cold.
63  bool isColdCount(uint64_t C);
64  /// \brief Returns true if BasicBlock \p B is considered hot.
65  bool isHotBB(const BasicBlock *B, BlockFrequencyInfo *BFI);
66 };
67 
68 /// An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
70  std::unique_ptr<ProfileSummaryInfo> PSI;
71 
72 public:
73  static char ID;
75 
77  return &*PSI;
78  }
79 
80  bool doInitialization(Module &M) override;
81  bool doFinalization(Module &M) override;
82  void getAnalysisUsage(AnalysisUsage &AU) const override {
83  AU.setPreservesAll();
84  }
85 };
86 
87 /// An analysis pass based on the new PM to deliver ProfileSummaryInfo.
89  : public AnalysisInfoMixin<ProfileSummaryAnalysis> {
90 public:
92 
94 
95 private:
97  static AnalysisKey Key;
98 };
99 
100 /// \brief Printer pass that uses \c ProfileSummaryAnalysis.
102  : public PassInfoMixin<ProfileSummaryPrinterPass> {
103  raw_ostream &OS;
104 
105 public:
106  explicit ProfileSummaryPrinterPass(raw_ostream &OS) : OS(OS) {}
108 };
109 
110 } // end namespace llvm
111 
112 #endif
Various leaf nodes.
Definition: ISDOpcodes.h:60
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
bool isColdCount(uint64_t C)
Returns true if count C is considered cold.
Analysis providing profile information.
bool isHotCount(uint64_t C)
Returns true if F is a hot function.
bool isFunctionEntryCold(const Function *F)
Returns true if F has cold function entry.
Result run(Module &M, ModuleAnalysisManager &)
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
bool isHotBB(const BasicBlock *B, BlockFrequencyInfo *BFI)
Returns true if BasicBlock B is considered hot.
#define F(x, y, z)
Definition: MD5.cpp:51
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:311
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
bool doInitialization(Module &M) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
An analysis pass based on the new PM to deliver ProfileSummaryInfo.
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:328
Represent the analysis usage information of a pass.
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
ImmutablePass class - This class is used to provide information that does not need to be run...
Definition: Pass.h:266
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
void setPreservesAll()
Set by analyses that do not transform their input at all.
ProfileSummaryInfo(ProfileSummaryInfo &&Arg)
Printer pass that uses ProfileSummaryAnalysis.
bool isFunctionEntryHot(const Function *F)
Returns true if F has hot function entry.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
A container for analyses that lazily runs them and caches their results.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
This header defines various interfaces for pass management in LLVM.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:64