From 8851d6cf9c16061635a9484bc639097d19a389d0 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 18 Oct 2009 04:10:40 +0000 Subject: [PATCH] add function passes for printing various dominator datastructures accessible through opt. Patch by Tobias Grosser! llvm-svn: 84397 --- include/llvm/Analysis/DomPrinter.h | 30 ++++ include/llvm/LinkAllPasses.h | 9 + lib/Analysis/CMakeLists.txt | 1 + lib/Analysis/DomPrinter.cpp | 268 +++++++++++++++++++++++++++++ 4 files changed, 308 insertions(+) create mode 100644 include/llvm/Analysis/DomPrinter.h create mode 100644 lib/Analysis/DomPrinter.cpp diff --git a/include/llvm/Analysis/DomPrinter.h b/include/llvm/Analysis/DomPrinter.h new file mode 100644 index 00000000000..0ed28994995 --- /dev/null +++ b/include/llvm/Analysis/DomPrinter.h @@ -0,0 +1,30 @@ +//===-- DomPrinter.h - Dom printer external interface ------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines external functions that can be called to explicitly +// instantiate the dominance tree printer. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_ANALYSIS_DOMPRINTER_H +#define LLVM_ANALYSIS_DOMPRINTER_H + +namespace llvm { + class FunctionPass; + FunctionPass *createDomPrinterPass(); + FunctionPass *createDomOnlyPrinterPass(); + FunctionPass *createDomViewerPass(); + FunctionPass *createDomOnlyViewerPass(); + FunctionPass *createPostDomPrinterPass(); + FunctionPass *createPostDomOnlyPrinterPass(); + FunctionPass *createPostDomViewerPass(); + FunctionPass *createPostDomOnlyViewerPass(); +} // End llvm namespace + +#endif diff --git a/include/llvm/LinkAllPasses.h b/include/llvm/LinkAllPasses.h index e9a0542bf10..a7de7e7fb30 100644 --- a/include/llvm/LinkAllPasses.h +++ b/include/llvm/LinkAllPasses.h @@ -16,6 +16,7 @@ #define LLVM_LINKALLPASSES_H #include "llvm/Analysis/AliasSetTracker.h" +#include "llvm/Analysis/DomPrinter.h" #include "llvm/Analysis/FindUsedTypes.h" #include "llvm/Analysis/IntervalPartition.h" #include "llvm/Analysis/Passes.h" @@ -62,6 +63,10 @@ namespace { (void) llvm::createDeadInstEliminationPass(); (void) llvm::createDeadStoreEliminationPass(); (void) llvm::createDeadTypeEliminationPass(); + (void) llvm::createDomOnlyPrinterPass(); + (void) llvm::createDomPrinterPass(); + (void) llvm::createDomOnlyViewerPass(); + (void) llvm::createDomViewerPass(); (void) llvm::createEdgeProfilerPass(); (void) llvm::createOptimalEdgeProfilerPass(); (void) llvm::createFunctionInliningPass(); @@ -98,6 +103,10 @@ namespace { (void) llvm::createPromoteMemoryToRegisterPass(); (void) llvm::createDemoteRegisterToMemoryPass(); (void) llvm::createPruneEHPass(); + (void) llvm::createPostDomOnlyPrinterPass(); + (void) llvm::createPostDomPrinterPass(); + (void) llvm::createPostDomOnlyViewerPass(); + (void) llvm::createPostDomViewerPass(); (void) llvm::createRaiseAllocationsPass(); (void) llvm::createReassociatePass(); (void) llvm::createSCCPPass(); diff --git a/lib/Analysis/CMakeLists.txt b/lib/Analysis/CMakeLists.txt index 1d2f118bb44..d4be9863b6a 100644 --- a/lib/Analysis/CMakeLists.txt +++ b/lib/Analysis/CMakeLists.txt @@ -11,6 +11,7 @@ add_llvm_library(LLVMAnalysis ConstantFolding.cpp DbgInfoPrinter.cpp DebugInfo.cpp + DomPrinter.cpp IVUsers.cpp InlineCost.cpp InstCount.cpp diff --git a/lib/Analysis/DomPrinter.cpp b/lib/Analysis/DomPrinter.cpp new file mode 100644 index 00000000000..f7918177cca --- /dev/null +++ b/lib/Analysis/DomPrinter.cpp @@ -0,0 +1,268 @@ +//===- DomPrinter.cpp - DOT printer for the dominance trees ------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines '-dot-dom' and '-dot-postdom' analysis passes, which emit +// a dom..dot or postdom..dot file for each function in the +// program, with a graph of the dominance/postdominance tree of that +// function. +// +// There are also passes available to directly call dotty ('-view-dom' or +// '-view-postdom'). By appending '-only' like '-dot-dom-only' only the +// names of the bbs are printed, but the content is hidden. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Analysis/DomPrinter.h" + +#include "llvm/Pass.h" +#include "llvm/Function.h" +#include "llvm/Analysis/CFGPrinter.h" +#include "llvm/Analysis/Dominators.h" +#include "llvm/Analysis/PostDominators.h" + +using namespace llvm; + +namespace llvm { +template<> +struct DOTGraphTraits : public DefaultDOTGraphTraits { + static std::string getNodeLabel(DomTreeNode *Node, DomTreeNode *Graph, + bool ShortNames) { + + BasicBlock *BB = Node->getBlock(); + + if (!BB) + return "Post dominance root node"; + + return DOTGraphTraits::getNodeLabel(BB, BB->getParent(), + ShortNames); + } +}; + +template<> +struct DOTGraphTraits : public DOTGraphTraits { + + static std::string getGraphName(DominatorTree *DT) { + return "Dominator tree"; + } + + static std::string getNodeLabel(DomTreeNode *Node, + DominatorTree *G, + bool ShortNames) { + return DOTGraphTraits::getNodeLabel(Node, G->getRootNode(), + ShortNames); + } +}; + +template<> +struct DOTGraphTraits + : public DOTGraphTraits { + static std::string getGraphName(PostDominatorTree *DT) { + return "Post dominator tree"; + } + static std::string getNodeLabel(DomTreeNode *Node, + PostDominatorTree *G, + bool ShortNames) { + return DOTGraphTraits::getNodeLabel(Node, + G->getRootNode(), + ShortNames); + } +}; +} + +namespace { +template +struct GenericGraphViewer : public FunctionPass { + + static char ID; + std::string Name; + + GenericGraphViewer(std::string GraphName) : FunctionPass(&ID) { + Name = GraphName; + } + + virtual bool runOnFunction(Function &F) { + Analysis *Graph; + + Graph = &getAnalysis(); + ViewGraph(Graph, Name, OnlyBBS); + + return false; + } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + AU.addRequired(); + } +}; + +struct DomViewer + : public GenericGraphViewer { + static char ID; + DomViewer() : GenericGraphViewer("dom"){} +}; + +struct DomOnlyViewer + : public GenericGraphViewer { + static char ID; + DomOnlyViewer() : GenericGraphViewer("domonly"){} +}; + +struct PostDomViewer + : public GenericGraphViewer { + static char ID; + PostDomViewer() : + GenericGraphViewer("postdom"){} +}; + +struct PostDomOnlyViewer + : public GenericGraphViewer { + static char ID; + PostDomOnlyViewer() : + GenericGraphViewer("postdomonly"){} +}; +} // end anonymous namespace + +char DomViewer::ID = 0; +RegisterPass A("view-dom", + "View dominance tree of function"); + +char DomOnlyViewer::ID = 0; +RegisterPass B("view-dom-only", + "View dominance tree of function " + "(with no function bodies)"); + +char PostDomViewer::ID = 0; +RegisterPass C("view-postdom", + "View postdominance tree of function"); + +char PostDomOnlyViewer::ID = 0; +RegisterPass D("view-postdom-only", + "View postdominance tree of function " + "(with no function bodies)"); + +namespace { +template +struct GenericGraphPrinter : public FunctionPass { + + static char ID; + std::string Name; + + GenericGraphPrinter(std::string GraphName) : FunctionPass(&ID) { + Name = GraphName; + } + + virtual bool runOnFunction(Function &F) { + Analysis *Graph; + std::string Filename = Name + "." + F.getNameStr() + ".dot"; + errs() << "Writing '" << Filename << "'..."; + + std::string ErrorInfo; + raw_fd_ostream File(Filename.c_str(), ErrorInfo); + Graph = &getAnalysis(); + + if (ErrorInfo.empty()) + WriteGraph(File, Graph, OnlyBBS); + else + errs() << " error opening file for writing!"; + errs() << "\n"; + return false; + } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + AU.addRequired(); + } +}; + +struct DomPrinter + : public GenericGraphPrinter { + static char ID; + DomPrinter() : GenericGraphPrinter("dom"){} +}; + +struct DomOnlyPrinter + : public GenericGraphPrinter { + static char ID; + DomOnlyPrinter() : GenericGraphPrinter("domonly"){} +}; + +struct PostDomPrinter + : public GenericGraphPrinter { + static char ID; + PostDomPrinter() : + GenericGraphPrinter("postdom"){} +}; + +struct PostDomOnlyPrinter + : public GenericGraphPrinter { + static char ID; + PostDomOnlyPrinter() : + GenericGraphPrinter("postdomonly"){} +}; +} // end anonymous namespace + + + +char DomPrinter::ID = 0; +RegisterPass E("dot-dom", + "Print dominance tree of function " + "to 'dot' file"); + +char DomOnlyPrinter::ID = 0; +RegisterPass F("dot-dom-only", + "Print dominance tree of function " + "to 'dot' file " + "(with no function bodies)"); + +char PostDomPrinter::ID = 0; +RegisterPass G("dot-postdom", + "Print postdominance tree of function " + "to 'dot' file"); + +char PostDomOnlyPrinter::ID = 0; +RegisterPass H("dot-postdom-only", + "Print postdominance tree of function " + "to 'dot' file " + "(with no function bodies)"); + +// Create methods available outside of this file, to use them +// "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by +// the link time optimization. + +FunctionPass *llvm::createDomPrinterPass() { + return new DomPrinter(); +} + +FunctionPass *llvm::createDomOnlyPrinterPass() { + return new DomOnlyPrinter(); +} + +FunctionPass *llvm::createDomViewerPass() { + return new DomViewer(); +} + +FunctionPass *llvm::createDomOnlyViewerPass() { + return new DomOnlyViewer(); +} + +FunctionPass *llvm::createPostDomPrinterPass() { + return new PostDomPrinter(); +} + +FunctionPass *llvm::createPostDomOnlyPrinterPass() { + return new PostDomOnlyPrinter(); +} + +FunctionPass *llvm::createPostDomViewerPass() { + return new PostDomViewer(); +} + +FunctionPass *llvm::createPostDomOnlyViewerPass() { + return new PostDomOnlyViewer(); +}