X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAnalysis%2FCFGPrinter.cpp;h=c2c19d6a69efbd370b0d4d5bfb116a878fed7dcc;hb=283c82abaaa85d032725cba11fb9ad05c9a9b060;hp=578889bade98a2011f5a683f2b27cb037c7e1de3;hpb=3e0c1542409eda9afaf7427ad72facdecb91128c;p=oota-llvm.git diff --git a/lib/Analysis/CFGPrinter.cpp b/lib/Analysis/CFGPrinter.cpp index 578889bade9..c2c19d6a69e 100644 --- a/lib/Analysis/CFGPrinter.cpp +++ b/lib/Analysis/CFGPrinter.cpp @@ -2,12 +2,12 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // -// This file defines a '-print-cfg' analysis pass, which emits the +// This file defines a '-dot-cfg' analysis pass, which emits the // cfg..dot file for each function in the program, with a graph of the // CFG for that function. // @@ -17,233 +17,142 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Function.h" -#include "llvm/Instructions.h" -#include "llvm/Pass.h" #include "llvm/Analysis/CFGPrinter.h" -#include "llvm/Assembly/Writer.h" -#include "llvm/Support/CFG.h" -#include "llvm/Support/GraphWriter.h" -#include "llvm/System/Path.h" -#include "llvm/System/Program.h" -#include "llvm/Config/config.h" -#include -#include +#include "llvm/Pass.h" +#include "llvm/Support/FileSystem.h" using namespace llvm; -/// CFGOnly flag - This is used to control whether or not the CFG graph printer -/// prints out the contents of basic blocks or not. This is acceptable because -/// this code is only really used for debugging purposes. -/// -static bool CFGOnly = false; +namespace { + struct CFGViewer : public FunctionPass { + static char ID; // Pass identifcation, replacement for typeid + CFGViewer() : FunctionPass(ID) { + initializeCFGOnlyViewerPass(*PassRegistry::getPassRegistry()); + } -namespace llvm { -template<> -struct DOTGraphTraits : public DefaultDOTGraphTraits { - static std::string getGraphName(const Function *F) { - return "CFG for '" + F->getName() + "' function"; - } + bool runOnFunction(Function &F) override { + F.viewCFG(); + return false; + } - static std::string getNodeLabel(const BasicBlock *Node, - const Function *Graph) { - if (CFGOnly && !Node->getName().empty()) - return Node->getName() + ":"; + void print(raw_ostream &OS, const Module* = nullptr) const override {} - std::ostringstream Out; - if (CFGOnly) { - WriteAsOperand(Out, Node, false, true); - return Out.str(); + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.setPreservesAll(); } + }; +} - if (Node->getName().empty()) { - WriteAsOperand(Out, Node, false, true); - Out << ":"; - } +char CFGViewer::ID = 0; +INITIALIZE_PASS(CFGViewer, "view-cfg", "View CFG of function", false, true) - Out << *Node; - std::string OutStr = Out.str(); - if (OutStr[0] == '\n') OutStr.erase(OutStr.begin()); +namespace { + struct CFGOnlyViewer : public FunctionPass { + static char ID; // Pass identifcation, replacement for typeid + CFGOnlyViewer() : FunctionPass(ID) { + initializeCFGOnlyViewerPass(*PassRegistry::getPassRegistry()); + } - // Process string output to make it nicer... - for (unsigned i = 0; i != OutStr.length(); ++i) - if (OutStr[i] == '\n') { // Left justify - OutStr[i] = '\\'; - OutStr.insert(OutStr.begin()+i+1, 'l'); - } else if (OutStr[i] == ';') { // Delete comments! - unsigned Idx = OutStr.find('\n', i+1); // Find end of line - OutStr.erase(OutStr.begin()+i, OutStr.begin()+Idx); - --i; - } + bool runOnFunction(Function &F) override { + F.viewCFGOnly(); + return false; + } - return OutStr; - } + void print(raw_ostream &OS, const Module* = nullptr) const override {} - static std::string getEdgeSourceLabel(const BasicBlock *Node, - succ_const_iterator I) { - // Label source of conditional branches with "T" or "F" - if (const BranchInst *BI = dyn_cast(Node->getTerminator())) - if (BI->isConditional()) - return (I == succ_begin(Node)) ? "T" : "F"; - return ""; - } -}; + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.setPreservesAll(); + } + }; } +char CFGOnlyViewer::ID = 0; +INITIALIZE_PASS(CFGOnlyViewer, "view-cfg-only", + "View CFG of function (with no function bodies)", false, true) + namespace { struct CFGPrinter : public FunctionPass { - virtual bool runOnFunction(Function &F) { - std::string Filename = "cfg." + F.getName() + ".dot"; - std::cerr << "Writing '" << Filename << "'..."; - std::ofstream File(Filename.c_str()); + static char ID; // Pass identification, replacement for typeid + CFGPrinter() : FunctionPass(ID) { + initializeCFGPrinterPass(*PassRegistry::getPassRegistry()); + } - if (File.good()) + bool runOnFunction(Function &F) override { + std::string Filename = "cfg." + F.getName().str() + ".dot"; + errs() << "Writing '" << Filename << "'..."; + + std::string ErrorInfo; + raw_fd_ostream File(Filename.c_str(), ErrorInfo, sys::fs::F_Text); + + if (ErrorInfo.empty()) WriteGraph(File, (const Function*)&F); else - std::cerr << " error opening file for writing!"; - std::cerr << "\n"; + errs() << " error opening file for writing!"; + errs() << "\n"; return false; } - void print(std::ostream &OS, const Module* = 0) const {} + void print(raw_ostream &OS, const Module* = nullptr) const override {} - virtual void getAnalysisUsage(AnalysisUsage &AU) const { + void getAnalysisUsage(AnalysisUsage &AU) const override { AU.setPreservesAll(); } }; +} + +char CFGPrinter::ID = 0; +INITIALIZE_PASS(CFGPrinter, "dot-cfg", "Print CFG of function to 'dot' file", + false, true) + +namespace { + struct CFGOnlyPrinter : public FunctionPass { + static char ID; // Pass identification, replacement for typeid + CFGOnlyPrinter() : FunctionPass(ID) { + initializeCFGOnlyPrinterPass(*PassRegistry::getPassRegistry()); + } - RegisterAnalysis P1("print-cfg", - "Print CFG of function to 'dot' file"); + bool runOnFunction(Function &F) override { + std::string Filename = "cfg." + F.getName().str() + ".dot"; + errs() << "Writing '" << Filename << "'..."; - struct CFGOnlyPrinter : public CFGPrinter { - virtual bool runOnFunction(Function &F) { - bool OldCFGOnly = CFGOnly; - CFGOnly = true; - CFGPrinter::runOnFunction(F); - CFGOnly = OldCFGOnly; + std::string ErrorInfo; + raw_fd_ostream File(Filename.c_str(), ErrorInfo, sys::fs::F_Text); + + if (ErrorInfo.empty()) + WriteGraph(File, (const Function*)&F, true); + else + errs() << " error opening file for writing!"; + errs() << "\n"; return false; } - void print(std::ostream &OS, const Module* = 0) const {} + void print(raw_ostream &OS, const Module* = nullptr) const override {} - virtual void getAnalysisUsage(AnalysisUsage &AU) const { + void getAnalysisUsage(AnalysisUsage &AU) const override { AU.setPreservesAll(); } }; - - RegisterAnalysis - P2("print-cfg-only", - "Print CFG of function to 'dot' file (with no function bodies)"); } +char CFGOnlyPrinter::ID = 0; +INITIALIZE_PASS(CFGOnlyPrinter, "dot-cfg-only", + "Print CFG of function to 'dot' file (with no function bodies)", + false, true) + /// viewCFG - This function is meant for use from the debugger. You can just /// say 'call F->viewCFG()' and a ghostview window should pop up from the /// program, displaying the CFG of the current function. This depends on there /// being a 'dot' and 'gv' program in your path. /// void Function::viewCFG() const { -#ifndef NDEBUG - char pathsuff[9]; - - sprintf(pathsuff, "%06u", unsigned(rand())); - - sys::Path TempDir = sys::Path::GetTemporaryDirectory(); - sys::Path Filename = TempDir; - - Filename.appendComponent("cfg" + getName() + "." + pathsuff + ".dot"); - std::cerr << "Writing '" << Filename << "'... "; - std::ofstream F(Filename.c_str()); - - if (!F.good()) { - std::cerr << " error opening file for writing!\n"; - return; - } - - WriteGraph(F, this); - F.close(); - std::cerr << "\n"; - -#if HAVE_GRAPHVIZ - sys::Path Graphviz(LLVM_PATH_GRAPHVIZ); - std::vector args; - args.push_back(Graphviz.c_str()); - args.push_back(Filename.c_str()); - args.push_back(0); - - std::cerr << "Running 'Graphviz' program... " << std::flush; - if (sys::Program::ExecuteAndWait(Graphviz, &args[0])) { - std::cerr << "Error viewing graph: 'Graphviz' not in path?\n"; - } else { - Filename.eraseFromDisk(); - return; - } -#elif (HAVE_GV && HAVE_DOT) - sys::Path PSFilename = TempDir; - PSFilename.appendComponent(std::string("cfg.tempgraph") + "." + pathsuff + ".ps"); - - sys::Path dot(LLVM_PATH_DOT); - std::vector args; - args.push_back(dot.c_str()); - args.push_back("-Tps"); - args.push_back("-Nfontname=Courier"); - args.push_back("-Gsize=7.5,10"); - args.push_back(Filename.c_str()); - args.push_back("-o"); - args.push_back(PSFilename.c_str()); - args.push_back(0); - - std::cerr << "Running 'dot' program... " << std::flush; - if (sys::Program::ExecuteAndWait(dot, &args[0])) { - std::cerr << "Error viewing graph: 'dot' not in path?\n"; - } else { - std::cerr << "\n"; - - sys::Path gv(LLVM_PATH_GV); - args.clear(); - args.push_back(gv.c_str()); - args.push_back(PSFilename.c_str()); - args.push_back(0); - - sys::Program::ExecuteAndWait(gv, &args[0]); - } - Filename.eraseFromDisk(); - PSFilename.eraseFromDisk(); - return; -#elif HAVE_DOTTY - sys::Path dotty(LLVM_PATH_DOTTY); - std::vector args; - args.push_back(dotty.c_str()); - args.push_back(Filename.c_str()); - args.push_back(0); - - std::cerr << "Running 'dotty' program... " << std::flush; - if (sys::Program::ExecuteAndWait(dotty, &args[0])) { - std::cerr << "Error viewing graph: 'dotty' not in path?\n"; - } else { -#ifndef __MINGW32__ // Dotty spawns another app and doesn't wait until it returns - Filename.eraseFromDisk(); -#endif - return; - } -#endif - -#endif // NDEBUG - std::cerr << "Function::viewCFG is only available in debug builds on " - << "systems with Graphviz or gv or dotty!\n"; - -#ifndef NDEBUG - Filename.eraseFromDisk(); - TempDir.eraseFromDisk(true); -#endif + ViewGraph(this, "cfg" + getName()); } /// viewCFGOnly - This function is meant for use from the debugger. It works /// just like viewCFG, but it does not include the contents of basic blocks -/// into the nodes, just the label. If you are only interested in the CFG t -/// his can make the graph smaller. +/// into the nodes, just the label. If you are only interested in the CFG +/// this can make the graph smaller. /// void Function::viewCFGOnly() const { - CFGOnly = true; - viewCFG(); - CFGOnly = false; + ViewGraph(this, "cfg" + getName(), true); } FunctionPass *llvm::createCFGPrinterPass () {