1 //===- DomPrinter.cpp - DOT printer for the dominance trees ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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
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.
19 //===----------------------------------------------------------------------===//
21 #include "llvm/Analysis/DomPrinter.h"
23 #include "llvm/Analysis/Dominators.h"
24 #include "llvm/Analysis/DOTGraphTraitsPass.h"
25 #include "llvm/Analysis/PostDominators.h"
31 struct DOTGraphTraits<DomTreeNode*> : public DefaultDOTGraphTraits {
33 DOTGraphTraits (bool isSimple=false)
34 : DefaultDOTGraphTraits(isSimple) {}
36 std::string getNodeLabel(DomTreeNode *Node, DomTreeNode *Graph) {
38 BasicBlock *BB = Node->getBlock();
41 return "Post dominance root node";
45 return DOTGraphTraits<const Function*>
46 ::getSimpleNodeLabel(BB, BB->getParent());
48 return DOTGraphTraits<const Function*>
49 ::getCompleteNodeLabel(BB, BB->getParent());
54 struct DOTGraphTraits<DominatorTree*> : public DOTGraphTraits<DomTreeNode*> {
56 DOTGraphTraits (bool isSimple=false)
57 : DOTGraphTraits<DomTreeNode*>(isSimple) {}
59 static std::string getGraphName(DominatorTree *DT) {
60 return "Dominator tree";
63 std::string getNodeLabel(DomTreeNode *Node, DominatorTree *G) {
64 return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode());
69 struct DOTGraphTraits<PostDominatorTree*>
70 : public DOTGraphTraits<DomTreeNode*> {
72 DOTGraphTraits (bool isSimple=false)
73 : DOTGraphTraits<DomTreeNode*>(isSimple) {}
75 static std::string getGraphName(PostDominatorTree *DT) {
76 return "Post dominator tree";
79 std::string getNodeLabel(DomTreeNode *Node, PostDominatorTree *G ) {
80 return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode());
86 template <class Analysis, bool OnlyBBS>
87 struct GenericGraphViewer : public FunctionPass {
90 GenericGraphViewer(std::string GraphName, const void *ID) : FunctionPass(ID) {
94 virtual bool runOnFunction(Function &F) {
96 std::string Title, GraphName;
97 Graph = &getAnalysis<Analysis>();
98 GraphName = DOTGraphTraits<Analysis*>::getGraphName(Graph);
99 Title = GraphName + " for '" + F.getNameStr() + "' function";
100 ViewGraph(Graph, Name, OnlyBBS, Title);
105 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
106 AU.setPreservesAll();
107 AU.addRequired<Analysis>();
112 : public DOTGraphTraitsViewer<DominatorTree, false> {
114 DomViewer() : DOTGraphTraitsViewer<DominatorTree, false>("dom", &ID){}
118 : public DOTGraphTraitsViewer<DominatorTree, true> {
120 DomOnlyViewer() : DOTGraphTraitsViewer<DominatorTree, true>("domonly", &ID){}
124 : public DOTGraphTraitsViewer<PostDominatorTree, false> {
127 DOTGraphTraitsViewer<PostDominatorTree, false>("postdom", &ID){}
130 struct PostDomOnlyViewer
131 : public DOTGraphTraitsViewer<PostDominatorTree, true> {
133 PostDomOnlyViewer() :
134 DOTGraphTraitsViewer<PostDominatorTree, true>("postdomonly", &ID){}
136 } // end anonymous namespace
138 char DomViewer::ID = 0;
139 RegisterPass<DomViewer> A("view-dom",
140 "View dominance tree of function");
142 char DomOnlyViewer::ID = 0;
143 RegisterPass<DomOnlyViewer> B("view-dom-only",
144 "View dominance tree of function "
145 "(with no function bodies)");
147 char PostDomViewer::ID = 0;
148 RegisterPass<PostDomViewer> C("view-postdom",
149 "View postdominance tree of function");
151 char PostDomOnlyViewer::ID = 0;
152 RegisterPass<PostDomOnlyViewer> D("view-postdom-only",
153 "View postdominance tree of function "
154 "(with no function bodies)");
158 : public DOTGraphTraitsPrinter<DominatorTree, false> {
160 DomPrinter() : DOTGraphTraitsPrinter<DominatorTree, false>("dom", &ID) {}
163 struct DomOnlyPrinter
164 : public DOTGraphTraitsPrinter<DominatorTree, true> {
166 DomOnlyPrinter() : DOTGraphTraitsPrinter<DominatorTree, true>("domonly", &ID) {}
169 struct PostDomPrinter
170 : public DOTGraphTraitsPrinter<PostDominatorTree, false> {
173 DOTGraphTraitsPrinter<PostDominatorTree, false>("postdom", &ID) {}
176 struct PostDomOnlyPrinter
177 : public DOTGraphTraitsPrinter<PostDominatorTree, true> {
179 PostDomOnlyPrinter() :
180 DOTGraphTraitsPrinter<PostDominatorTree, true>("postdomonly", &ID) {}
182 } // end anonymous namespace
186 char DomPrinter::ID = 0;
187 RegisterPass<DomPrinter> E("dot-dom",
188 "Print dominance tree of function "
191 char DomOnlyPrinter::ID = 0;
192 RegisterPass<DomOnlyPrinter> F("dot-dom-only",
193 "Print dominance tree of function "
195 "(with no function bodies)");
197 char PostDomPrinter::ID = 0;
198 RegisterPass<PostDomPrinter> G("dot-postdom",
199 "Print postdominance tree of function "
202 char PostDomOnlyPrinter::ID = 0;
203 RegisterPass<PostDomOnlyPrinter> H("dot-postdom-only",
204 "Print postdominance tree of function "
206 "(with no function bodies)");
208 // Create methods available outside of this file, to use them
209 // "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by
210 // the link time optimization.
212 FunctionPass *llvm::createDomPrinterPass() {
213 return new DomPrinter();
216 FunctionPass *llvm::createDomOnlyPrinterPass() {
217 return new DomOnlyPrinter();
220 FunctionPass *llvm::createDomViewerPass() {
221 return new DomViewer();
224 FunctionPass *llvm::createDomOnlyViewerPass() {
225 return new DomOnlyViewer();
228 FunctionPass *llvm::createPostDomPrinterPass() {
229 return new PostDomPrinter();
232 FunctionPass *llvm::createPostDomOnlyPrinterPass() {
233 return new PostDomOnlyPrinter();
236 FunctionPass *llvm::createPostDomViewerPass() {
237 return new PostDomViewer();
240 FunctionPass *llvm::createPostDomOnlyViewerPass() {
241 return new PostDomOnlyViewer();