/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/lib/Analysis/DomPrinter.cpp
Line | Count | Source (jump to first uncovered line) |
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 | | |
31 | | DOTGraphTraits (bool isSimple=false) |
32 | 0 | : DefaultDOTGraphTraits(isSimple) {} |
33 | | |
34 | 0 | std::string getNodeLabel(DomTreeNode *Node, DomTreeNode *Graph) { |
35 | 0 |
|
36 | 0 | BasicBlock *BB = Node->getBlock(); |
37 | 0 |
|
38 | 0 | if (!BB) |
39 | 0 | return "Post dominance root node"; |
40 | 0 |
|
41 | 0 |
|
42 | 0 | if (0 isSimple()0 ) |
43 | 0 | return DOTGraphTraits<const Function*> |
44 | 0 | ::getSimpleNodeLabel(BB, BB->getParent()); |
45 | 0 | else |
46 | 0 | return DOTGraphTraits<const Function*> |
47 | 0 | ::getCompleteNodeLabel(BB, BB->getParent()); |
48 | 0 | } |
49 | | }; |
50 | | |
51 | | template<> |
52 | | struct DOTGraphTraits<DominatorTree*> : public DOTGraphTraits<DomTreeNode*> { |
53 | | |
54 | | DOTGraphTraits (bool isSimple=false) |
55 | 0 | : DOTGraphTraits<DomTreeNode*>(isSimple) {} |
56 | | |
57 | 0 | static std::string getGraphName(DominatorTree *DT) { |
58 | 0 | return "Dominator tree"; |
59 | 0 | } |
60 | | |
61 | 0 | std::string getNodeLabel(DomTreeNode *Node, DominatorTree *G) { |
62 | 0 | return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode()); |
63 | 0 | } |
64 | | }; |
65 | | |
66 | | template<> |
67 | | struct DOTGraphTraits<PostDominatorTree*> |
68 | | : public DOTGraphTraits<DomTreeNode*> { |
69 | | |
70 | | DOTGraphTraits (bool isSimple=false) |
71 | 0 | : DOTGraphTraits<DomTreeNode*>(isSimple) {} |
72 | | |
73 | 0 | static std::string getGraphName(PostDominatorTree *DT) { |
74 | 0 | return "Post dominator tree"; |
75 | 0 | } |
76 | | |
77 | 0 | std::string getNodeLabel(DomTreeNode *Node, PostDominatorTree *G ) { |
78 | 0 | return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode()); |
79 | 0 | } |
80 | | }; |
81 | | } |
82 | | |
83 | 0 | 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 | 0 | #endif // NDEBUG |
89 | 0 | } |
90 | | |
91 | 0 | 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 | 0 | #endif // NDEBUG |
97 | 0 | } |
98 | | |
99 | | namespace { |
100 | | struct DominatorTreeWrapperPassAnalysisGraphTraits { |
101 | 0 | static DominatorTree *getGraph(DominatorTreeWrapperPass *DTWP) { |
102 | 0 | return &DTWP->getDomTree(); |
103 | 0 | } |
104 | | }; |
105 | | |
106 | | struct DomViewer : public DOTGraphTraitsViewer< |
107 | | DominatorTreeWrapperPass, false, DominatorTree *, |
108 | | DominatorTreeWrapperPassAnalysisGraphTraits> { |
109 | | static char ID; |
110 | | DomViewer() |
111 | | : DOTGraphTraitsViewer<DominatorTreeWrapperPass, false, DominatorTree *, |
112 | | DominatorTreeWrapperPassAnalysisGraphTraits>( |
113 | 0 | "dom", ID) { |
114 | 0 | initializeDomViewerPass(*PassRegistry::getPassRegistry()); |
115 | 0 | } |
116 | | }; |
117 | | |
118 | | struct DomOnlyViewer : public DOTGraphTraitsViewer< |
119 | | DominatorTreeWrapperPass, true, DominatorTree *, |
120 | | DominatorTreeWrapperPassAnalysisGraphTraits> { |
121 | | static char ID; |
122 | | DomOnlyViewer() |
123 | | : DOTGraphTraitsViewer<DominatorTreeWrapperPass, true, DominatorTree *, |
124 | | DominatorTreeWrapperPassAnalysisGraphTraits>( |
125 | 0 | "domonly", ID) { |
126 | 0 | initializeDomOnlyViewerPass(*PassRegistry::getPassRegistry()); |
127 | 0 | } |
128 | | }; |
129 | | |
130 | | struct PostDominatorTreeWrapperPassAnalysisGraphTraits { |
131 | 0 | static PostDominatorTree *getGraph(PostDominatorTreeWrapperPass *PDTWP) { |
132 | 0 | return &PDTWP->getPostDomTree(); |
133 | 0 | } |
134 | | }; |
135 | | |
136 | | struct PostDomViewer : public DOTGraphTraitsViewer< |
137 | | PostDominatorTreeWrapperPass, false, |
138 | | PostDominatorTree *, |
139 | | PostDominatorTreeWrapperPassAnalysisGraphTraits> { |
140 | | static char ID; |
141 | | PostDomViewer() : |
142 | | DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, false, |
143 | | PostDominatorTree *, |
144 | | PostDominatorTreeWrapperPassAnalysisGraphTraits>( |
145 | 0 | "postdom", ID){ |
146 | 0 | initializePostDomViewerPass(*PassRegistry::getPassRegistry()); |
147 | 0 | } |
148 | | }; |
149 | | |
150 | | struct PostDomOnlyViewer : public DOTGraphTraitsViewer< |
151 | | PostDominatorTreeWrapperPass, true, |
152 | | PostDominatorTree *, |
153 | | PostDominatorTreeWrapperPassAnalysisGraphTraits> { |
154 | | static char ID; |
155 | | PostDomOnlyViewer() : |
156 | | DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, true, |
157 | | PostDominatorTree *, |
158 | | PostDominatorTreeWrapperPassAnalysisGraphTraits>( |
159 | 0 | "postdomonly", ID){ |
160 | 0 | initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry()); |
161 | 0 | } |
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; |
189 | | DomPrinter() |
190 | | : DOTGraphTraitsPrinter<DominatorTreeWrapperPass, false, DominatorTree *, |
191 | | DominatorTreeWrapperPassAnalysisGraphTraits>( |
192 | 0 | "dom", ID) { |
193 | 0 | initializeDomPrinterPass(*PassRegistry::getPassRegistry()); |
194 | 0 | } |
195 | | }; |
196 | | |
197 | | struct DomOnlyPrinter : public DOTGraphTraitsPrinter< |
198 | | DominatorTreeWrapperPass, true, DominatorTree *, |
199 | | DominatorTreeWrapperPassAnalysisGraphTraits> { |
200 | | static char ID; |
201 | | DomOnlyPrinter() |
202 | | : DOTGraphTraitsPrinter<DominatorTreeWrapperPass, true, DominatorTree *, |
203 | | DominatorTreeWrapperPassAnalysisGraphTraits>( |
204 | 0 | "domonly", ID) { |
205 | 0 | initializeDomOnlyPrinterPass(*PassRegistry::getPassRegistry()); |
206 | 0 | } |
207 | | }; |
208 | | |
209 | | struct PostDomPrinter |
210 | | : public DOTGraphTraitsPrinter< |
211 | | PostDominatorTreeWrapperPass, false, |
212 | | PostDominatorTree *, |
213 | | PostDominatorTreeWrapperPassAnalysisGraphTraits> { |
214 | | static char ID; |
215 | | PostDomPrinter() : |
216 | | DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, false, |
217 | | PostDominatorTree *, |
218 | | PostDominatorTreeWrapperPassAnalysisGraphTraits>( |
219 | 0 | "postdom", ID) { |
220 | 0 | initializePostDomPrinterPass(*PassRegistry::getPassRegistry()); |
221 | 0 | } |
222 | | }; |
223 | | |
224 | | struct PostDomOnlyPrinter |
225 | | : public DOTGraphTraitsPrinter< |
226 | | PostDominatorTreeWrapperPass, true, |
227 | | PostDominatorTree *, |
228 | | PostDominatorTreeWrapperPassAnalysisGraphTraits> { |
229 | | static char ID; |
230 | | PostDomOnlyPrinter() : |
231 | | DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, true, |
232 | | PostDominatorTree *, |
233 | | PostDominatorTreeWrapperPassAnalysisGraphTraits>( |
234 | 0 | "postdomonly", ID) { |
235 | 0 | initializePostDomOnlyPrinterPass(*PassRegistry::getPassRegistry()); |
236 | 0 | } |
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 | | |
268 | 0 | FunctionPass *llvm::createDomPrinterPass() { |
269 | 0 | return new DomPrinter(); |
270 | 0 | } |
271 | | |
272 | 0 | FunctionPass *llvm::createDomOnlyPrinterPass() { |
273 | 0 | return new DomOnlyPrinter(); |
274 | 0 | } |
275 | | |
276 | 0 | FunctionPass *llvm::createDomViewerPass() { |
277 | 0 | return new DomViewer(); |
278 | 0 | } |
279 | | |
280 | 0 | FunctionPass *llvm::createDomOnlyViewerPass() { |
281 | 0 | return new DomOnlyViewer(); |
282 | 0 | } |
283 | | |
284 | 0 | FunctionPass *llvm::createPostDomPrinterPass() { |
285 | 0 | return new PostDomPrinter(); |
286 | 0 | } |
287 | | |
288 | 0 | FunctionPass *llvm::createPostDomOnlyPrinterPass() { |
289 | 0 | return new PostDomOnlyPrinter(); |
290 | 0 | } |
291 | | |
292 | 0 | FunctionPass *llvm::createPostDomViewerPass() { |
293 | 0 | return new PostDomViewer(); |
294 | 0 | } |
295 | | |
296 | 0 | FunctionPass *llvm::createPostDomOnlyViewerPass() { |
297 | 0 | return new PostDomOnlyViewer(); |
298 | 0 | } |