Coverage Report

Created: 2017-10-03 07:32

/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
}