1 //===- DomPrinter.cpp - DOT printer for the dominance trees ------------===//
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 defines '-dot-dom' and '-dot-postdom' analysis passes, which emit
11 // a dom.<fnname>.dot or postdom.<fnname>.dot file for each function in the
12 // program, with a graph of the dominance/postdominance tree of that
13 // function.
14 //
15 // There are also passes available to directly call dotty ('-view-dom' or
16 // '-view-postdom'). By appending '-only' like '-dot-dom-only' only the
17 // names of the bbs are printed, but the content is hidden.
18 //
19 //===----------------------------------------------------------------------===//
20
21 #include "llvm/Analysis/DomPrinter.h"
22 #include "llvm/Analysis/DOTGraphTraitsPass.h"
23 #include "llvm/Analysis/PostDominators.h"
24
25 using namespace llvm;
26
27 namespace llvm {
28 template<>
29 struct DOTGraphTraits<DomTreeNode*> : public DefaultDOTGraphTraits {
30
DOTGraphTraitsllvm::DOTGraphTraits31 DOTGraphTraits (bool isSimple=false)
32 : DefaultDOTGraphTraits(isSimple) {}
33
getNodeLabelllvm::DOTGraphTraits34 std::string getNodeLabel(DomTreeNode *Node, DomTreeNode *Graph) {
35
36 BasicBlock *BB = Node->getBlock();
37
38 if (!BB)
39 return "Post dominance root node";
40
41
42 if (isSimple())
43 return DOTGraphTraits<const Function*>
44 ::getSimpleNodeLabel(BB, BB->getParent());
45 else
46 return DOTGraphTraits<const Function*>
47 ::getCompleteNodeLabel(BB, BB->getParent());
48 }
49 };
50
51 template<>
52 struct DOTGraphTraits<DominatorTree*> : public DOTGraphTraits<DomTreeNode*> {
53
DOTGraphTraitsllvm::DOTGraphTraits54 DOTGraphTraits (bool isSimple=false)
55 : DOTGraphTraits<DomTreeNode*>(isSimple) {}
56
getGraphNamellvm::DOTGraphTraits57 static std::string getGraphName(DominatorTree *DT) {
58 return "Dominator tree";
59 }
60
getNodeLabelllvm::DOTGraphTraits61 std::string getNodeLabel(DomTreeNode *Node, DominatorTree *G) {
62 return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode());
63 }
64 };
65
66 template<>
67 struct DOTGraphTraits<PostDominatorTree*>
68 : public DOTGraphTraits<DomTreeNode*> {
69
DOTGraphTraitsllvm::DOTGraphTraits70 DOTGraphTraits (bool isSimple=false)
71 : DOTGraphTraits<DomTreeNode*>(isSimple) {}
72
getGraphNamellvm::DOTGraphTraits73 static std::string getGraphName(PostDominatorTree *DT) {
74 return "Post dominator tree";
75 }
76
getNodeLabelllvm::DOTGraphTraits77 std::string getNodeLabel(DomTreeNode *Node, PostDominatorTree *G ) {
78 return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode());
79 }
80 };
81 }
82
viewGraph(const Twine & Name,const Twine & Title)83 void DominatorTree::viewGraph(const Twine &Name, const Twine &Title) {
84 #ifndef NDEBUG
85 ViewGraph(this, Name, false, Title);
86 #else
87 errs() << "DomTree dump not available, build with DEBUG\n";
88 #endif // NDEBUG
89 }
90
viewGraph()91 void DominatorTree::viewGraph() {
92 #ifndef NDEBUG
93 this->viewGraph("domtree", "Dominator Tree for function");
94 #else
95 errs() << "DomTree dump not available, build with DEBUG\n";
96 #endif // NDEBUG
97 }
98
99 namespace {
100 struct DominatorTreeWrapperPassAnalysisGraphTraits {
getGraph__anone97640ac0111::DominatorTreeWrapperPassAnalysisGraphTraits101 static DominatorTree *getGraph(DominatorTreeWrapperPass *DTWP) {
102 return &DTWP->getDomTree();
103 }
104 };
105
106 struct DomViewer : public DOTGraphTraitsViewer<
107 DominatorTreeWrapperPass, false, DominatorTree *,
108 DominatorTreeWrapperPassAnalysisGraphTraits> {
109 static char ID;
DomViewer__anone97640ac0111::DomViewer110 DomViewer()
111 : DOTGraphTraitsViewer<DominatorTreeWrapperPass, false, DominatorTree *,
112 DominatorTreeWrapperPassAnalysisGraphTraits>(
113 "dom", ID) {
114 initializeDomViewerPass(*PassRegistry::getPassRegistry());
115 }
116 };
117
118 struct DomOnlyViewer : public DOTGraphTraitsViewer<
119 DominatorTreeWrapperPass, true, DominatorTree *,
120 DominatorTreeWrapperPassAnalysisGraphTraits> {
121 static char ID;
DomOnlyViewer__anone97640ac0111::DomOnlyViewer122 DomOnlyViewer()
123 : DOTGraphTraitsViewer<DominatorTreeWrapperPass, true, DominatorTree *,
124 DominatorTreeWrapperPassAnalysisGraphTraits>(
125 "domonly", ID) {
126 initializeDomOnlyViewerPass(*PassRegistry::getPassRegistry());
127 }
128 };
129
130 struct PostDominatorTreeWrapperPassAnalysisGraphTraits {
getGraph__anone97640ac0111::PostDominatorTreeWrapperPassAnalysisGraphTraits131 static PostDominatorTree *getGraph(PostDominatorTreeWrapperPass *PDTWP) {
132 return &PDTWP->getPostDomTree();
133 }
134 };
135
136 struct PostDomViewer : public DOTGraphTraitsViewer<
137 PostDominatorTreeWrapperPass, false,
138 PostDominatorTree *,
139 PostDominatorTreeWrapperPassAnalysisGraphTraits> {
140 static char ID;
PostDomViewer__anone97640ac0111::PostDomViewer141 PostDomViewer() :
142 DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, false,
143 PostDominatorTree *,
144 PostDominatorTreeWrapperPassAnalysisGraphTraits>(
145 "postdom", ID){
146 initializePostDomViewerPass(*PassRegistry::getPassRegistry());
147 }
148 };
149
150 struct PostDomOnlyViewer : public DOTGraphTraitsViewer<
151 PostDominatorTreeWrapperPass, true,
152 PostDominatorTree *,
153 PostDominatorTreeWrapperPassAnalysisGraphTraits> {
154 static char ID;
PostDomOnlyViewer__anone97640ac0111::PostDomOnlyViewer155 PostDomOnlyViewer() :
156 DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, true,
157 PostDominatorTree *,
158 PostDominatorTreeWrapperPassAnalysisGraphTraits>(
159 "postdomonly", ID){
160 initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry());
161 }
162 };
163 } // end anonymous namespace
164
165 char DomViewer::ID = 0;
166 INITIALIZE_PASS(DomViewer, "view-dom",
167 "View dominance tree of function", false, false)
168
169 char DomOnlyViewer::ID = 0;
170 INITIALIZE_PASS(DomOnlyViewer, "view-dom-only",
171 "View dominance tree of function (with no function bodies)",
172 false, false)
173
174 char PostDomViewer::ID = 0;
175 INITIALIZE_PASS(PostDomViewer, "view-postdom",
176 "View postdominance tree of function", false, false)
177
178 char PostDomOnlyViewer::ID = 0;
179 INITIALIZE_PASS(PostDomOnlyViewer, "view-postdom-only",
180 "View postdominance tree of function "
181 "(with no function bodies)",
182 false, false)
183
184 namespace {
185 struct DomPrinter : public DOTGraphTraitsPrinter<
186 DominatorTreeWrapperPass, false, DominatorTree *,
187 DominatorTreeWrapperPassAnalysisGraphTraits> {
188 static char ID;
DomPrinter__anone97640ac0211::DomPrinter189 DomPrinter()
190 : DOTGraphTraitsPrinter<DominatorTreeWrapperPass, false, DominatorTree *,
191 DominatorTreeWrapperPassAnalysisGraphTraits>(
192 "dom", ID) {
193 initializeDomPrinterPass(*PassRegistry::getPassRegistry());
194 }
195 };
196
197 struct DomOnlyPrinter : public DOTGraphTraitsPrinter<
198 DominatorTreeWrapperPass, true, DominatorTree *,
199 DominatorTreeWrapperPassAnalysisGraphTraits> {
200 static char ID;
DomOnlyPrinter__anone97640ac0211::DomOnlyPrinter201 DomOnlyPrinter()
202 : DOTGraphTraitsPrinter<DominatorTreeWrapperPass, true, DominatorTree *,
203 DominatorTreeWrapperPassAnalysisGraphTraits>(
204 "domonly", ID) {
205 initializeDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
206 }
207 };
208
209 struct PostDomPrinter
210 : public DOTGraphTraitsPrinter<
211 PostDominatorTreeWrapperPass, false,
212 PostDominatorTree *,
213 PostDominatorTreeWrapperPassAnalysisGraphTraits> {
214 static char ID;
PostDomPrinter__anone97640ac0211::PostDomPrinter215 PostDomPrinter() :
216 DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, false,
217 PostDominatorTree *,
218 PostDominatorTreeWrapperPassAnalysisGraphTraits>(
219 "postdom", ID) {
220 initializePostDomPrinterPass(*PassRegistry::getPassRegistry());
221 }
222 };
223
224 struct PostDomOnlyPrinter
225 : public DOTGraphTraitsPrinter<
226 PostDominatorTreeWrapperPass, true,
227 PostDominatorTree *,
228 PostDominatorTreeWrapperPassAnalysisGraphTraits> {
229 static char ID;
PostDomOnlyPrinter__anone97640ac0211::PostDomOnlyPrinter230 PostDomOnlyPrinter() :
231 DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, true,
232 PostDominatorTree *,
233 PostDominatorTreeWrapperPassAnalysisGraphTraits>(
234 "postdomonly", ID) {
235 initializePostDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
236 }
237 };
238 } // end anonymous namespace
239
240
241
242 char DomPrinter::ID = 0;
243 INITIALIZE_PASS(DomPrinter, "dot-dom",
244 "Print dominance tree of function to 'dot' file",
245 false, false)
246
247 char DomOnlyPrinter::ID = 0;
248 INITIALIZE_PASS(DomOnlyPrinter, "dot-dom-only",
249 "Print dominance tree of function to 'dot' file "
250 "(with no function bodies)",
251 false, false)
252
253 char PostDomPrinter::ID = 0;
254 INITIALIZE_PASS(PostDomPrinter, "dot-postdom",
255 "Print postdominance tree of function to 'dot' file",
256 false, false)
257
258 char PostDomOnlyPrinter::ID = 0;
259 INITIALIZE_PASS(PostDomOnlyPrinter, "dot-postdom-only",
260 "Print postdominance tree of function to 'dot' file "
261 "(with no function bodies)",
262 false, false)
263
264 // Create methods available outside of this file, to use them
265 // "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by
266 // the link time optimization.
267
createDomPrinterPass()268 FunctionPass *llvm::createDomPrinterPass() {
269 return new DomPrinter();
270 }
271
createDomOnlyPrinterPass()272 FunctionPass *llvm::createDomOnlyPrinterPass() {
273 return new DomOnlyPrinter();
274 }
275
createDomViewerPass()276 FunctionPass *llvm::createDomViewerPass() {
277 return new DomViewer();
278 }
279
createDomOnlyViewerPass()280 FunctionPass *llvm::createDomOnlyViewerPass() {
281 return new DomOnlyViewer();
282 }
283
createPostDomPrinterPass()284 FunctionPass *llvm::createPostDomPrinterPass() {
285 return new PostDomPrinter();
286 }
287
createPostDomOnlyPrinterPass()288 FunctionPass *llvm::createPostDomOnlyPrinterPass() {
289 return new PostDomOnlyPrinter();
290 }
291
createPostDomViewerPass()292 FunctionPass *llvm::createPostDomViewerPass() {
293 return new PostDomViewer();
294 }
295
createPostDomOnlyViewerPass()296 FunctionPass *llvm::createPostDomOnlyViewerPass() {
297 return new PostDomOnlyViewer();
298 }
299