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