LLVM  13.0.0git
MachineBlockFrequencyInfo.cpp
Go to the documentation of this file.
1 //===- MachineBlockFrequencyInfo.cpp - MBB Frequency Analysis -------------===//
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 // Loops should be simplified before this analysis.
10 //
11 //===----------------------------------------------------------------------===//
12 
14 #include "llvm/ADT/DenseMap.h"
15 #include "llvm/ADT/None.h"
16 #include "llvm/ADT/iterator.h"
22 #include "llvm/InitializePasses.h"
23 #include "llvm/Pass.h"
26 #include <string>
27 
28 using namespace llvm;
29 
30 #define DEBUG_TYPE "machine-block-freq"
31 
32 namespace llvm {
34  "view-machine-block-freq-propagation-dags", cl::Hidden,
35  cl::desc("Pop up a window to show a dag displaying how machine block "
36  "frequencies propagate through the CFG."),
37  cl::values(clEnumValN(GVDT_None, "none", "do not display graphs."),
38  clEnumValN(GVDT_Fraction, "fraction",
39  "display a graph using the "
40  "fractional block frequency representation."),
41  clEnumValN(GVDT_Integer, "integer",
42  "display a graph using the raw "
43  "integer fractional block frequency representation."),
44  clEnumValN(GVDT_Count, "count", "display a graph using the real "
45  "profile count if available.")));
46 
47 // Similar option above, but used to control BFI display only after MBP pass
49  "view-block-layout-with-bfi", cl::Hidden,
50  cl::desc(
51  "Pop up a window to show a dag displaying MBP layout and associated "
52  "block frequencies of the CFG."),
53  cl::values(clEnumValN(GVDT_None, "none", "do not display graphs."),
54  clEnumValN(GVDT_Fraction, "fraction",
55  "display a graph using the "
56  "fractional block frequency representation."),
57  clEnumValN(GVDT_Integer, "integer",
58  "display a graph using the raw "
59  "integer fractional block frequency representation."),
60  clEnumValN(GVDT_Count, "count",
61  "display a graph using the real "
62  "profile count if available.")));
63 
64 // Command line option to specify the name of the function for CFG dump
65 // Defined in Analysis/BlockFrequencyInfo.cpp: -view-bfi-func-name=
67 
68 // Command line option to specify hot frequency threshold.
69 // Defined in Analysis/BlockFrequencyInfo.cpp: -view-hot-freq-perc=
71 
73  "print-machine-bfi", cl::init(false), cl::Hidden,
74  cl::desc("Print the machine block frequency info."));
75 
76 // Command line option to specify the name of the function for block frequency
77 // dump. Defined in Analysis/BlockFrequencyInfo.cpp.
79 } // namespace llvm
80 
81 static GVDAGType getGVDT() {
84 
86 }
87 
88 namespace llvm {
89 
90 template <> struct GraphTraits<MachineBlockFrequencyInfo *> {
91  using NodeRef = const MachineBasicBlock *;
94 
96  return &G->getFunction()->front();
97  }
98 
100  return N->succ_begin();
101  }
102 
103  static ChildIteratorType child_end(const NodeRef N) { return N->succ_end(); }
104 
106  return nodes_iterator(G->getFunction()->begin());
107  }
108 
110  return nodes_iterator(G->getFunction()->end());
111  }
112 };
113 
117 
118 template <>
120  : public MBFIDOTGraphTraitsBase {
121  const MachineFunction *CurFunc = nullptr;
123 
124  explicit DOTGraphTraits(bool isSimple = false)
126 
127  std::string getNodeLabel(const MachineBasicBlock *Node,
128  const MachineBlockFrequencyInfo *Graph) {
129  int layout_order = -1;
130  // Attach additional ordering information if 'isSimple' is false.
131  if (!isSimple()) {
132  const MachineFunction *F = Node->getParent();
133  if (!CurFunc || F != CurFunc) {
134  if (CurFunc)
135  LayoutOrderMap.clear();
136 
137  CurFunc = F;
138  int O = 0;
139  for (auto MBI = F->begin(); MBI != F->end(); ++MBI, ++O) {
140  LayoutOrderMap[&*MBI] = O;
141  }
142  }
143  layout_order = LayoutOrderMap[Node];
144  }
145  return MBFIDOTGraphTraitsBase::getNodeLabel(Node, Graph, getGVDT(),
146  layout_order);
147  }
148 
149  std::string getNodeAttributes(const MachineBasicBlock *Node,
150  const MachineBlockFrequencyInfo *Graph) {
153  }
154 
155  std::string getEdgeAttributes(const MachineBasicBlock *Node, EdgeIter EI,
156  const MachineBlockFrequencyInfo *MBFI) {
158  Node, EI, MBFI, MBFI->getMBPI(), ViewHotFreqPercent);
159  }
160 };
161 
162 } // end namespace llvm
163 
165  "Machine Block Frequency Analysis", true, true)
169  "Machine Block Frequency Analysis", true, true)
170 
171 char MachineBlockFrequencyInfo::ID = 0;
172 
176 }
177 
182  calculate(F, MBPI, MLI);
183 }
184 
186 
190  AU.setPreservesAll();
192 }
193 
195  const MachineFunction &F, const MachineBranchProbabilityInfo &MBPI,
196  const MachineLoopInfo &MLI) {
197  if (!MBFI)
198  MBFI.reset(new ImplType);
199  MBFI->calculate(F, MBPI, MLI);
201  (ViewBlockFreqFuncName.empty() ||
202  F.getName().equals(ViewBlockFreqFuncName))) {
203  view("MachineBlockFrequencyDAGS." + F.getName());
204  }
205  if (PrintMachineBlockFreq &&
206  (PrintBlockFreqFuncName.empty() ||
207  F.getName().equals(PrintBlockFreqFuncName))) {
208  MBFI->print(dbgs());
209  }
210 }
211 
214  getAnalysis<MachineBranchProbabilityInfo>();
215  MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();
216  calculate(F, MBPI, MLI);
217  return false;
218 }
219 
221 
222 /// Pop up a ghostview window with the current block frequency propagation
223 /// rendered using dot.
225  // This code is only for debugging.
226  ViewGraph(const_cast<MachineBlockFrequencyInfo *>(this), Name, isSimple);
227 }
228 
231  return MBFI ? MBFI->getBlockFreq(MBB) : 0;
232 }
233 
235  const MachineBasicBlock *MBB) const {
236  const Function &F = MBFI->getFunction()->getFunction();
237  return MBFI ? MBFI->getBlockProfileCount(F, MBB) : None;
238 }
239 
242  const Function &F = MBFI->getFunction()->getFunction();
243  return MBFI ? MBFI->getProfileCountFromFreq(F, Freq) : None;
244 }
245 
247  const MachineBasicBlock *MBB) const {
248  assert(MBFI && "Expected analysis to be available");
249  return MBFI->isIrrLoopHeader(MBB);
250 }
251 
253  const MachineBasicBlock &NewPredecessor,
254  const MachineBasicBlock &NewSuccessor,
255  const MachineBranchProbabilityInfo &MBPI) {
256  assert(MBFI && "Expected analysis to be available");
257  auto NewSuccFreq = MBFI->getBlockFreq(&NewPredecessor) *
258  MBPI.getEdgeProbability(&NewPredecessor, &NewSuccessor);
259 
260  MBFI->setBlockFreq(&NewSuccessor, NewSuccFreq.getFrequency());
261 }
262 
264  return MBFI ? MBFI->getFunction() : nullptr;
265 }
266 
268  return MBFI ? &MBFI->getBPI() : nullptr;
269 }
270 
271 raw_ostream &
273  const BlockFrequency Freq) const {
274  return MBFI ? MBFI->printBlockFreq(OS, Freq) : OS;
275 }
276 
277 raw_ostream &
279  const MachineBasicBlock *MBB) const {
280  return MBFI ? MBFI->printBlockFreq(OS, MBB) : OS;
281 }
282 
284  return MBFI ? MBFI->getEntryFreq() : 0;
285 }
llvm
Definition: AllocatorList.h:23
llvm::ViewHotFreqPercent
cl::opt< unsigned > ViewHotFreqPercent("view-hot-freq-percent", cl::init(10), cl::Hidden, cl::desc("An integer in percent used to specify " "the hot blocks/edges to be displayed " "in red: a block or edge whose frequency " "is no less than the max frequency of the " "function multiplied by this percent."))
Definition: MachineBlockFrequencyInfo.cpp:70
llvm::DOTGraphTraits< MachineBlockFrequencyInfo * >::getEdgeAttributes
std::string getEdgeAttributes(const MachineBasicBlock *Node, EdgeIter EI, const MachineBlockFrequencyInfo *MBFI)
Definition: MachineBlockFrequencyInfo.cpp:155
llvm::MachineBlockFrequencyInfo::getBlockProfileCount
Optional< uint64_t > getBlockProfileCount(const MachineBasicBlock *MBB) const
Definition: MachineBlockFrequencyInfo.cpp:234
llvm::MachineBlockFrequencyInfo::getProfileCountFromFreq
Optional< uint64_t > getProfileCountFromFreq(uint64_t Freq) const
Definition: MachineBlockFrequencyInfo.cpp:241
llvm::Function
Definition: Function.h:61
Pass.h
llvm::DOTGraphTraits< MachineBlockFrequencyInfo * >::getNodeLabel
std::string getNodeLabel(const MachineBasicBlock *Node, const MachineBlockFrequencyInfo *Graph)
Definition: MachineBlockFrequencyInfo.cpp:127
llvm::GraphTraits< MachineBlockFrequencyInfo * >::ChildIteratorType
MachineBasicBlock::const_succ_iterator ChildIteratorType
Definition: MachineBlockFrequencyInfo.cpp:92
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
MachineBasicBlock.h
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::PrintMachineBlockFreq
static cl::opt< bool > PrintMachineBlockFreq("print-machine-bfi", cl::init(false), cl::Hidden, cl::desc("Print the machine block frequency info."))
llvm::MachineBlockFrequencyInfo::view
void view(const Twine &Name, bool isSimple=true) const
Pop up a ghostview window with the current block frequency propagation rendered using dot.
Definition: MachineBlockFrequencyInfo.cpp:224
DenseMap.h
llvm::Optional< uint64_t >
llvm::GraphTraits< MachineBlockFrequencyInfo * >::getEntryNode
static NodeRef getEntryNode(const MachineBlockFrequencyInfo *G)
Definition: MachineBlockFrequencyInfo.cpp:95
DEBUG_TYPE
#define DEBUG_TYPE
Definition: MachineBlockFrequencyInfo.cpp:30
Analysis
Machine Block Frequency Analysis
Definition: MachineBlockFrequencyInfo.cpp:169
llvm::ViewGraph
void ViewGraph(const GraphType &G, const Twine &Name, bool ShortNames=false, const Twine &Title="", GraphProgram::Name Program=GraphProgram::DOT)
ViewGraph - Emit a dot graph, run 'dot', run gv on the postscript file, then cleanup.
Definition: GraphWriter.h:375
llvm::MachineBlockFrequencyInfo::getBlockFreq
BlockFrequency getBlockFreq(const MachineBasicBlock *MBB) const
getblockFreq - Return block frequency.
Definition: MachineBlockFrequencyInfo.cpp:230
llvm::MachineFunctionPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
Definition: MachineFunctionPass.cpp:102
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::MachineLoopInfo
Definition: MachineLoopInfo.h:90
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
llvm::BFIDOTGraphTraitsBase::getNodeLabel
std::string getNodeLabel(NodeRef Node, const BlockFrequencyInfoT *Graph, GVDAGType GType, int layout_order=-1)
Definition: BlockFrequencyInfoImpl.h:1527
CommandLine.h
llvm::GVDT_Fraction
@ GVDT_Fraction
Definition: BlockFrequencyInfoImpl.h:1479
BlockFrequencyInfoImpl.h
MachineLoopInfo.h
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
llvm::MachineBlockFrequencyInfo
MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic b...
Definition: MachineBlockFrequencyInfo.h:33
llvm::MachineBranchProbabilityInfo
Definition: MachineBranchProbabilityInfo.h:24
llvm::ViewMachineBlockFreqPropagationDAG
static cl::opt< GVDAGType > ViewMachineBlockFreqPropagationDAG("view-machine-block-freq-propagation-dags", cl::Hidden, cl::desc("Pop up a window to show a dag displaying how machine block " "frequencies propagate through the CFG."), cl::values(clEnumValN(GVDT_None, "none", "do not display graphs."), clEnumValN(GVDT_Fraction, "fraction", "display a graph using the " "fractional block frequency representation."), clEnumValN(GVDT_Integer, "integer", "display a graph using the raw " "integer fractional block frequency representation."), clEnumValN(GVDT_Count, "count", "display a graph using the real " "profile count if available.")))
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::MachineBlockFrequencyInfo::calculate
void calculate(const MachineFunction &F, const MachineBranchProbabilityInfo &MBPI, const MachineLoopInfo &MLI)
calculate - compute block frequency info for the given function.
Definition: MachineBlockFrequencyInfo.cpp:194
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:50
llvm::PrintBlockFreqFuncName
cl::opt< std::string > PrintBlockFreqFuncName("print-bfi-func-name", cl::Hidden, cl::desc("The option to specify the name of the function " "whose block frequency info is printed."))
Definition: MachineBlockFrequencyInfo.cpp:78
llvm::BFIDOTGraphTraitsBase::getEdgeAttributes
std::string getEdgeAttributes(NodeRef Node, EdgeIter EI, const BlockFrequencyInfoT *BFI, const BranchProbabilityInfoT *BPI, unsigned HotPercentThreshold=0)
Definition: BlockFrequencyInfoImpl.h:1558
llvm::GraphTraits< MachineBlockFrequencyInfo * >::nodes_begin
static nodes_iterator nodes_begin(const MachineBlockFrequencyInfo *G)
Definition: MachineBlockFrequencyInfo.cpp:105
llvm::None
const NoneType None
Definition: None.h:23
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
llvm::DOTGraphTraits
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot...
Definition: DOTGraphTraits.h:161
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
llvm::pointer_iterator
Definition: iterator.h:320
llvm::cl::opt
Definition: CommandLine.h:1422
llvm::MachineBlockFrequencyInfo::releaseMemory
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
Definition: MachineBlockFrequencyInfo.cpp:220
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:132
llvm::MachineBlockFrequencyInfo::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: MachineBlockFrequencyInfo.cpp:187
llvm::BlockFrequency
Definition: BlockFrequency.h:24
llvm::cl::values
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:699
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::clear
void clear()
Definition: DenseMap.h:111
llvm::ViewBlockLayoutWithBFI
cl::opt< GVDAGType > ViewBlockLayoutWithBFI("view-block-layout-with-bfi", cl::Hidden, cl::desc("Pop up a window to show a dag displaying MBP layout and associated " "block frequencies of the CFG."), cl::values(clEnumValN(GVDT_None, "none", "do not display graphs."), clEnumValN(GVDT_Fraction, "fraction", "display a graph using the " "fractional block frequency representation."), clEnumValN(GVDT_Integer, "integer", "display a graph using the raw " "integer fractional block frequency representation."), clEnumValN(GVDT_Count, "count", "display a graph using the real " "profile count if available.")))
Definition: MachineBlockPlacement.cpp:203
llvm::MachineBlockFrequencyInfo::onEdgeSplit
void onEdgeSplit(const MachineBasicBlock &NewPredecessor, const MachineBasicBlock &NewSuccessor, const MachineBranchProbabilityInfo &MBPI)
incrementally calculate block frequencies when we split edges, to avoid full CFG traversal.
Definition: MachineBlockFrequencyInfo.cpp:252
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
llvm::DenseMap
Definition: DenseMap.h:714
iterator.h
true
Machine Block Frequency true
Definition: MachineBlockFrequencyInfo.cpp:169
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
llvm::MachineBlockFrequencyInfo::~MachineBlockFrequencyInfo
~MachineBlockFrequencyInfo() override
llvm::DOTGraphTraits< MachineBlockFrequencyInfo * >::getNodeAttributes
std::string getNodeAttributes(const MachineBasicBlock *Node, const MachineBlockFrequencyInfo *Graph)
Definition: MachineBlockFrequencyInfo.cpp:149
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
MachineBranchProbabilityInfo.h
llvm::GraphTraits< MachineBlockFrequencyInfo * >::child_begin
static ChildIteratorType child_begin(const NodeRef N)
Definition: MachineBlockFrequencyInfo.cpp:99
llvm::BFIDOTGraphTraitsBase::EdgeIter
typename GTraits::ChildIteratorType EdgeIter
Definition: BlockFrequencyInfoImpl.h:1485
llvm::MachineBlockFrequencyInfo::getFunction
const MachineFunction * getFunction() const
Definition: MachineBlockFrequencyInfo.cpp:263
llvm::MachineBranchProbabilityInfo::getEdgeProbability
BranchProbability getEdgeProbability(const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const
Definition: MachineBranchProbabilityInfo.cpp:58
llvm::DOTGraphTraits< MachineBlockFrequencyInfo * >::LayoutOrderMap
DenseMap< const MachineBasicBlock *, int > LayoutOrderMap
Definition: MachineBlockFrequencyInfo.cpp:122
llvm::GVDT_Integer
@ GVDT_Integer
Definition: BlockFrequencyInfoImpl.h:1479
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::BFIDOTGraphTraitsBase::getNodeAttributes
std::string getNodeAttributes(NodeRef Node, const BlockFrequencyInfoT *Graph, unsigned HotPercentThreshold=0)
Definition: BlockFrequencyInfoImpl.h:1497
None.h
llvm::MachineBlockFrequencyInfo::MachineBlockFrequencyInfo
MachineBlockFrequencyInfo()
Definition: MachineBlockFrequencyInfo.cpp:173
clEnumValN
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:674
llvm::MachineBlockFrequencyInfo::printBlockFreq
raw_ostream & printBlockFreq(raw_ostream &OS, const BlockFrequency Freq) const
Definition: MachineBlockFrequencyInfo.cpp:272
llvm::DOTGraphTraits< MachineBlockFrequencyInfo * >::DOTGraphTraits
DOTGraphTraits(bool isSimple=false)
Definition: MachineBlockFrequencyInfo.cpp:124
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
GraphWriter.h
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::BFIDOTGraphTraitsBase
Definition: BlockFrequencyInfoImpl.h:1482
isSimple
static bool isSimple(Instruction *I)
Definition: SLPVectorizer.cpp:524
llvm::GVDT_Count
@ GVDT_Count
Definition: BlockFrequencyInfoImpl.h:1479
llvm::GraphTraits< MachineBlockFrequencyInfo * >::nodes_end
static nodes_iterator nodes_end(const MachineBlockFrequencyInfo *G)
Definition: MachineBlockFrequencyInfo.cpp:109
llvm::getGVDT
static GVDAGType getGVDT()
Definition: BlockFrequencyInfo.cpp:94
Machine
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:365
llvm::GVDT_None
@ GVDT_None
Definition: BlockFrequencyInfoImpl.h:1479
N
#define N
llvm::MachineBlockFrequencyInfo::getMBPI
const MachineBranchProbabilityInfo * getMBPI() const
Definition: MachineBlockFrequencyInfo.cpp:267
llvm::MachineBasicBlock::const_succ_iterator
std::vector< MachineBasicBlock * >::const_iterator const_succ_iterator
Definition: MachineBasicBlock.h:307
llvm::BlockFrequencyInfoImpl
Shared implementation for block frequency analysis.
Definition: BlockFrequencyInfo.h:31
llvm::MachineBlockFrequencyInfo::isIrrLoopHeader
bool isIrrLoopHeader(const MachineBasicBlock *MBB) const
Definition: MachineBlockFrequencyInfo.cpp:246
llvm::ViewBlockFreqFuncName
cl::opt< std::string > ViewBlockFreqFuncName("view-bfi-func-name", cl::Hidden, cl::desc("The option to specify " "the name of the function " "whose CFG will be displayed."))
Definition: MachineBlockFrequencyInfo.cpp:66
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::GraphTraits
Definition: GraphTraits.h:35
llvm::cl::desc
Definition: CommandLine.h:414
llvm::MachineBlockFrequencyInfo::runOnMachineFunction
bool runOnMachineFunction(MachineFunction &F) override
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
Definition: MachineBlockFrequencyInfo.cpp:212
llvm::initializeMachineBlockFrequencyInfoPass
void initializeMachineBlockFrequencyInfoPass(PassRegistry &)
MachineFunction.h
llvm::MachineBlockFrequencyInfo::getEntryFreq
uint64_t getEntryFreq() const
Divide a block's BlockFrequency::getFrequency() value by this value to obtain the entry block - relat...
Definition: MachineBlockFrequencyInfo.cpp:283
llvm::GraphTraits< MachineBlockFrequencyInfo * >::child_end
static ChildIteratorType child_end(const NodeRef N)
Definition: MachineBlockFrequencyInfo.cpp:103
InitializePasses.h
MachineBlockFrequencyInfo.h
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(MachineBlockFrequencyInfo, DEBUG_TYPE, "Machine Block Frequency Analysis", true, true) INITIALIZE_PASS_END(MachineBlockFrequencyInfo
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38
llvm::GVDAGType
GVDAGType
Definition: BlockFrequencyInfoImpl.h:1479