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 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 #endif  // NDEBUG
  89 }
  90
  91 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 #endif  // NDEBUG
  97 }
  98
  99 namespace {
 100 struct DominatorTreeWrapperPassAnalysisGraphTraits {
 101   static DominatorTree *getGraph(DominatorTreeWrapperPass *DTWP) {
 102     return &DTWP->getDomTree();
 103   }
 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             "dom", ID) {
 114     initializeDomViewerPass(*PassRegistry::getPassRegistry());
 115   }
 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             "domonly", ID) {
 126     initializeDomOnlyViewerPass(*PassRegistry::getPassRegistry());
 127   }
 128 };
 129
 130 struct PostDominatorTreeWrapperPassAnalysisGraphTraits {
 131   static PostDominatorTree *getGraph(PostDominatorTreeWrapperPass *PDTWP) {
 132     return &PDTWP->getPostDomTree();
 133   }
 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         "postdom", ID){
 146       initializePostDomViewerPass(*PassRegistry::getPassRegistry());
 147     }
 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         "postdomonly", ID){
 160       initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry());
 161     }
 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             "dom", ID) {
 193     initializeDomPrinterPass(*PassRegistry::getPassRegistry());
 194   }
 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             "domonly", ID) {
 205     initializeDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
 206   }
 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         "postdom", ID) {
 220       initializePostDomPrinterPass(*PassRegistry::getPassRegistry());
 221     }
 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         "postdomonly", ID) {
 235       initializePostDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
 236     }
 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 FunctionPass *llvm::createDomPrinterPass() {
 269   return new DomPrinter();
 270 }
 271
 272 FunctionPass *llvm::createDomOnlyPrinterPass() {
 273   return new DomOnlyPrinter();
 274 }
 275
 276 FunctionPass *llvm::createDomViewerPass() {
 277   return new DomViewer();
 278 }
 279
 280 FunctionPass *llvm::createDomOnlyViewerPass() {
 281   return new DomOnlyViewer();
 282 }
 283
 284 FunctionPass *llvm::createPostDomPrinterPass() {
 285   return new PostDomPrinter();
 286 }
 287
 288 FunctionPass *llvm::createPostDomOnlyPrinterPass() {
 289   return new PostDomOnlyPrinter();
 290 }
 291
 292 FunctionPass *llvm::createPostDomViewerPass() {
 293   return new PostDomViewer();
 294 }
 295
 296 FunctionPass *llvm::createPostDomOnlyViewerPass() {
 297   return new PostDomOnlyViewer();
 298 }