mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-30 05:29:47 +00:00
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@90134 91177308-0d34-0410-b5e6-96231b3b80d8
281 lines
8.0 KiB
C++
281 lines
8.0 KiB
C++
//===- 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.<fnname>.dot or postdom.<fnname>.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<DomTreeNode*> : public DefaultDOTGraphTraits {
|
|
|
|
DOTGraphTraits (bool isSimple=false)
|
|
: DefaultDOTGraphTraits(isSimple) {}
|
|
|
|
std::string getNodeLabel(DomTreeNode *Node, DomTreeNode *Graph) {
|
|
|
|
BasicBlock *BB = Node->getBlock();
|
|
|
|
if (!BB)
|
|
return "Post dominance root node";
|
|
|
|
|
|
if (isSimple())
|
|
return DOTGraphTraits<const Function*>
|
|
::getSimpleNodeLabel(BB, BB->getParent());
|
|
else
|
|
return DOTGraphTraits<const Function*>
|
|
::getCompleteNodeLabel(BB, BB->getParent());
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct DOTGraphTraits<DominatorTree*> : public DOTGraphTraits<DomTreeNode*> {
|
|
|
|
DOTGraphTraits (bool isSimple=false)
|
|
: DOTGraphTraits<DomTreeNode*>(isSimple) {}
|
|
|
|
static std::string getGraphName(DominatorTree *DT) {
|
|
return "Dominator tree";
|
|
}
|
|
|
|
std::string getNodeLabel(DomTreeNode *Node, DominatorTree *G) {
|
|
return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode());
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct DOTGraphTraits<PostDominatorTree*>
|
|
: public DOTGraphTraits<DomTreeNode*> {
|
|
|
|
DOTGraphTraits (bool isSimple=false)
|
|
: DOTGraphTraits<DomTreeNode*>(isSimple) {}
|
|
|
|
static std::string getGraphName(PostDominatorTree *DT) {
|
|
return "Post dominator tree";
|
|
}
|
|
|
|
std::string getNodeLabel(DomTreeNode *Node, PostDominatorTree *G ) {
|
|
return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode());
|
|
}
|
|
};
|
|
}
|
|
|
|
namespace {
|
|
template <class Analysis, bool OnlyBBS>
|
|
struct GenericGraphViewer : public FunctionPass {
|
|
std::string Name;
|
|
|
|
GenericGraphViewer(std::string GraphName, const void *ID) : FunctionPass(ID) {
|
|
Name = GraphName;
|
|
}
|
|
|
|
virtual bool runOnFunction(Function &F) {
|
|
Analysis *Graph;
|
|
std::string Title, GraphName;
|
|
Graph = &getAnalysis<Analysis>();
|
|
GraphName = DOTGraphTraits<Analysis*>::getGraphName(Graph);
|
|
Title = GraphName + " for '" + F.getNameStr() + "' function";
|
|
ViewGraph(Graph, Name, OnlyBBS, Title);
|
|
|
|
return false;
|
|
}
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.setPreservesAll();
|
|
AU.addRequired<Analysis>();
|
|
}
|
|
};
|
|
|
|
struct DomViewer
|
|
: public GenericGraphViewer<DominatorTree, false> {
|
|
static char ID;
|
|
DomViewer() : GenericGraphViewer<DominatorTree, false>("dom", &ID){}
|
|
};
|
|
|
|
struct DomOnlyViewer
|
|
: public GenericGraphViewer<DominatorTree, true> {
|
|
static char ID;
|
|
DomOnlyViewer() : GenericGraphViewer<DominatorTree, true>("domonly", &ID){}
|
|
};
|
|
|
|
struct PostDomViewer
|
|
: public GenericGraphViewer<PostDominatorTree, false> {
|
|
static char ID;
|
|
PostDomViewer() :
|
|
GenericGraphViewer<PostDominatorTree, false>("postdom", &ID){}
|
|
};
|
|
|
|
struct PostDomOnlyViewer
|
|
: public GenericGraphViewer<PostDominatorTree, true> {
|
|
static char ID;
|
|
PostDomOnlyViewer() :
|
|
GenericGraphViewer<PostDominatorTree, true>("postdomonly", &ID){}
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
char DomViewer::ID = 0;
|
|
RegisterPass<DomViewer> A("view-dom",
|
|
"View dominance tree of function");
|
|
|
|
char DomOnlyViewer::ID = 0;
|
|
RegisterPass<DomOnlyViewer> B("view-dom-only",
|
|
"View dominance tree of function "
|
|
"(with no function bodies)");
|
|
|
|
char PostDomViewer::ID = 0;
|
|
RegisterPass<PostDomViewer> C("view-postdom",
|
|
"View postdominance tree of function");
|
|
|
|
char PostDomOnlyViewer::ID = 0;
|
|
RegisterPass<PostDomOnlyViewer> D("view-postdom-only",
|
|
"View postdominance tree of function "
|
|
"(with no function bodies)");
|
|
|
|
namespace {
|
|
template <class Analysis, bool OnlyBBS>
|
|
struct GenericGraphPrinter : public FunctionPass {
|
|
|
|
std::string Name;
|
|
|
|
GenericGraphPrinter(std::string GraphName, const void *ID)
|
|
: 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<Analysis>();
|
|
|
|
std::string Title, GraphName;
|
|
GraphName = DOTGraphTraits<Analysis*>::getGraphName(Graph);
|
|
Title = GraphName + " for '" + F.getNameStr() + "' function";
|
|
|
|
if (ErrorInfo.empty())
|
|
WriteGraph(File, Graph, OnlyBBS, Name, Title);
|
|
else
|
|
errs() << " error opening file for writing!";
|
|
errs() << "\n";
|
|
return false;
|
|
}
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.setPreservesAll();
|
|
AU.addRequired<Analysis>();
|
|
}
|
|
};
|
|
|
|
struct DomPrinter
|
|
: public GenericGraphPrinter<DominatorTree, false> {
|
|
static char ID;
|
|
DomPrinter() : GenericGraphPrinter<DominatorTree, false>("dom", &ID) {}
|
|
};
|
|
|
|
struct DomOnlyPrinter
|
|
: public GenericGraphPrinter<DominatorTree, true> {
|
|
static char ID;
|
|
DomOnlyPrinter() : GenericGraphPrinter<DominatorTree, true>("domonly", &ID) {}
|
|
};
|
|
|
|
struct PostDomPrinter
|
|
: public GenericGraphPrinter<PostDominatorTree, false> {
|
|
static char ID;
|
|
PostDomPrinter() :
|
|
GenericGraphPrinter<PostDominatorTree, false>("postdom", &ID) {}
|
|
};
|
|
|
|
struct PostDomOnlyPrinter
|
|
: public GenericGraphPrinter<PostDominatorTree, true> {
|
|
static char ID;
|
|
PostDomOnlyPrinter() :
|
|
GenericGraphPrinter<PostDominatorTree, true>("postdomonly", &ID) {}
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
char DomPrinter::ID = 0;
|
|
RegisterPass<DomPrinter> E("dot-dom",
|
|
"Print dominance tree of function "
|
|
"to 'dot' file");
|
|
|
|
char DomOnlyPrinter::ID = 0;
|
|
RegisterPass<DomOnlyPrinter> F("dot-dom-only",
|
|
"Print dominance tree of function "
|
|
"to 'dot' file "
|
|
"(with no function bodies)");
|
|
|
|
char PostDomPrinter::ID = 0;
|
|
RegisterPass<PostDomPrinter> G("dot-postdom",
|
|
"Print postdominance tree of function "
|
|
"to 'dot' file");
|
|
|
|
char PostDomOnlyPrinter::ID = 0;
|
|
RegisterPass<PostDomOnlyPrinter> 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();
|
|
}
|