Coverage Report

Created: 2019-07-24 05:18

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