contrib/llvm/lib/Analysis/DomPrinter.cpp

   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     : DefaultDOTGraphTraits(isSimple) {}
  33
  34   std::string getNodeLabel(DomTreeNode *Node, DomTreeNode *Graph) {
  35
  36     BasicBlock *BB = Node->getBlock();
  37
  38     if (!BB)
  39       return "Post dominance root node";
  40
  41
  42     if (isSimple())
  43       return DOTGraphTraits<const Function*>
  44         ::getSimpleNodeLabel(BB, BB->getParent());
  45     else
  46       return DOTGraphTraits<const Function*>
  47         ::getCompleteNodeLabel(BB, BB->getParent());
  48   }
  49 };
  50
  51 template<>
  52 struct DOTGraphTraits<DominatorTree*> : public DOTGraphTraits<DomTreeNode*> {
  53
  54   DOTGraphTraits (bool isSimple=false)
  55     : DOTGraphTraits<DomTreeNode*>(isSimple) {}
  56
  57   static std::string getGraphName(DominatorTree *DT) {
  58     return "Dominator tree";
  59   }
  60
  61   std::string getNodeLabel(DomTreeNode *Node, DominatorTree *G) {
  62     return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode());
  63   }
  64 };
  65
  66 template<>
  67 struct DOTGraphTraits<PostDominatorTree*>
  68   : public DOTGraphTraits<DomTreeNode*> {
  69
  70   DOTGraphTraits (bool isSimple=false)
  71     : DOTGraphTraits<DomTreeNode*>(isSimple) {}
  72
  73   static std::string getGraphName(PostDominatorTree *DT) {
  74     return "Post dominator tree";
  75   }
  76
  77   std::string getNodeLabel(DomTreeNode *Node, PostDominatorTree *G ) {
  78     return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode());
  79   }
  80 };
  81 }
  82
  83 namespace {
  84 struct DominatorTreeWrapperPassAnalysisGraphTraits {
  85   static DominatorTree *getGraph(DominatorTreeWrapperPass *DTWP) {
  86     return &DTWP->getDomTree();
  87   }
  88 };
  89
  90 struct DomViewer : public DOTGraphTraitsViewer<
  91                        DominatorTreeWrapperPass, false, DominatorTree *,
  92                        DominatorTreeWrapperPassAnalysisGraphTraits> {
  93   static char ID;
  94   DomViewer()
  95       : DOTGraphTraitsViewer<DominatorTreeWrapperPass, false, DominatorTree *,
  96                              DominatorTreeWrapperPassAnalysisGraphTraits>(
  97             "dom", ID) {
  98     initializeDomViewerPass(*PassRegistry::getPassRegistry());
  99   }
 100 };
 101
 102 struct DomOnlyViewer : public DOTGraphTraitsViewer<
 103                            DominatorTreeWrapperPass, true, DominatorTree *,
 104                            DominatorTreeWrapperPassAnalysisGraphTraits> {
 105   static char ID;
 106   DomOnlyViewer()
 107       : DOTGraphTraitsViewer<DominatorTreeWrapperPass, true, DominatorTree *,
 108                              DominatorTreeWrapperPassAnalysisGraphTraits>(
 109             "domonly", ID) {
 110     initializeDomOnlyViewerPass(*PassRegistry::getPassRegistry());
 111   }
 112 };
 113
 114 struct PostDominatorTreeWrapperPassAnalysisGraphTraits {
 115   static PostDominatorTree *getGraph(PostDominatorTreeWrapperPass *PDTWP) {
 116     return &PDTWP->getPostDomTree();
 117   }
 118 };
 119
 120 struct PostDomViewer : public DOTGraphTraitsViewer<
 121                           PostDominatorTreeWrapperPass, false,
 122                           PostDominatorTree *,
 123                           PostDominatorTreeWrapperPassAnalysisGraphTraits> {
 124   static char ID;
 125   PostDomViewer() :
 126     DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, false,
 127                          PostDominatorTree *,
 128                          PostDominatorTreeWrapperPassAnalysisGraphTraits>(
 129         "postdom", ID){
 130       initializePostDomViewerPass(*PassRegistry::getPassRegistry());
 131     }
 132 };
 133
 134 struct PostDomOnlyViewer : public DOTGraphTraitsViewer<
 135                             PostDominatorTreeWrapperPass, true,
 136                             PostDominatorTree *,
 137                             PostDominatorTreeWrapperPassAnalysisGraphTraits> {
 138   static char ID;
 139   PostDomOnlyViewer() :
 140     DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, true,
 141                          PostDominatorTree *,
 142                          PostDominatorTreeWrapperPassAnalysisGraphTraits>(
 143         "postdomonly", ID){
 144       initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry());
 145     }
 146 };
 147 } // end anonymous namespace
 148
 149 char DomViewer::ID = 0;
 150 INITIALIZE_PASS(DomViewer, "view-dom",
 151                 "View dominance tree of function", false, false)
 152
 153 char DomOnlyViewer::ID = 0;
 154 INITIALIZE_PASS(DomOnlyViewer, "view-dom-only",
 155                 "View dominance tree of function (with no function bodies)",
 156                 false, false)
 157
 158 char PostDomViewer::ID = 0;
 159 INITIALIZE_PASS(PostDomViewer, "view-postdom",
 160                 "View postdominance tree of function", false, false)
 161
 162 char PostDomOnlyViewer::ID = 0;
 163 INITIALIZE_PASS(PostDomOnlyViewer, "view-postdom-only",
 164                 "View postdominance tree of function "
 165                 "(with no function bodies)",
 166                 false, false)
 167
 168 namespace {
 169 struct DomPrinter : public DOTGraphTraitsPrinter<
 170                         DominatorTreeWrapperPass, false, DominatorTree *,
 171                         DominatorTreeWrapperPassAnalysisGraphTraits> {
 172   static char ID;
 173   DomPrinter()
 174       : DOTGraphTraitsPrinter<DominatorTreeWrapperPass, false, DominatorTree *,
 175                               DominatorTreeWrapperPassAnalysisGraphTraits>(
 176             "dom", ID) {
 177     initializeDomPrinterPass(*PassRegistry::getPassRegistry());
 178   }
 179 };
 180
 181 struct DomOnlyPrinter : public DOTGraphTraitsPrinter<
 182                             DominatorTreeWrapperPass, true, DominatorTree *,
 183                             DominatorTreeWrapperPassAnalysisGraphTraits> {
 184   static char ID;
 185   DomOnlyPrinter()
 186       : DOTGraphTraitsPrinter<DominatorTreeWrapperPass, true, DominatorTree *,
 187                               DominatorTreeWrapperPassAnalysisGraphTraits>(
 188             "domonly", ID) {
 189     initializeDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
 190   }
 191 };
 192
 193 struct PostDomPrinter
 194   : public DOTGraphTraitsPrinter<
 195                             PostDominatorTreeWrapperPass, false,
 196                             PostDominatorTree *,
 197                             PostDominatorTreeWrapperPassAnalysisGraphTraits> {
 198   static char ID;
 199   PostDomPrinter() :
 200     DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, false,
 201                           PostDominatorTree *,
 202                           PostDominatorTreeWrapperPassAnalysisGraphTraits>(
 203         "postdom", ID) {
 204       initializePostDomPrinterPass(*PassRegistry::getPassRegistry());
 205     }
 206 };
 207
 208 struct PostDomOnlyPrinter
 209   : public DOTGraphTraitsPrinter<
 210                             PostDominatorTreeWrapperPass, true,
 211                             PostDominatorTree *,
 212                             PostDominatorTreeWrapperPassAnalysisGraphTraits> {
 213   static char ID;
 214   PostDomOnlyPrinter() :
 215     DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, true,
 216                           PostDominatorTree *,
 217                           PostDominatorTreeWrapperPassAnalysisGraphTraits>(
 218         "postdomonly", ID) {
 219       initializePostDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
 220     }
 221 };
 222 } // end anonymous namespace
 223
 224
 225
 226 char DomPrinter::ID = 0;
 227 INITIALIZE_PASS(DomPrinter, "dot-dom",
 228                 "Print dominance tree of function to 'dot' file",
 229                 false, false)
 230
 231 char DomOnlyPrinter::ID = 0;
 232 INITIALIZE_PASS(DomOnlyPrinter, "dot-dom-only",
 233                 "Print dominance tree of function to 'dot' file "
 234                 "(with no function bodies)",
 235                 false, false)
 236
 237 char PostDomPrinter::ID = 0;
 238 INITIALIZE_PASS(PostDomPrinter, "dot-postdom",
 239                 "Print postdominance tree of function to 'dot' file",
 240                 false, false)
 241
 242 char PostDomOnlyPrinter::ID = 0;
 243 INITIALIZE_PASS(PostDomOnlyPrinter, "dot-postdom-only",
 244                 "Print postdominance tree of function to 'dot' file "
 245                 "(with no function bodies)",
 246                 false, false)
 247
 248 // Create methods available outside of this file, to use them
 249 // "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by
 250 // the link time optimization.
 251
 252 FunctionPass *llvm::createDomPrinterPass() {
 253   return new DomPrinter();
 254 }
 255
 256 FunctionPass *llvm::createDomOnlyPrinterPass() {
 257   return new DomOnlyPrinter();
 258 }
 259
 260 FunctionPass *llvm::createDomViewerPass() {
 261   return new DomViewer();
 262 }
 263
 264 FunctionPass *llvm::createDomOnlyViewerPass() {
 265   return new DomOnlyViewer();
 266 }
 267
 268 FunctionPass *llvm::createPostDomPrinterPass() {
 269   return new PostDomPrinter();
 270 }
 271
 272 FunctionPass *llvm::createPostDomOnlyPrinterPass() {
 273   return new PostDomOnlyPrinter();
 274 }
 275
 276 FunctionPass *llvm::createPostDomViewerPass() {
 277   return new PostDomViewer();
 278 }
 279
 280 FunctionPass *llvm::createPostDomOnlyViewerPass() {
 281   return new PostDomOnlyViewer();
 282 }