Home | History | Annotate | Download | only in Analysis 
      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 }
    283