lib/IR/PrintModulePass.cpp

   1 //===--- IR/PrintModulePass.cpp - Module/Function Printer -----------------===//
   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 // PrintModulePass and PrintFunctionPass implementations.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/IR/PrintModulePass.h"
  15 #include "llvm/IR/Function.h"
  16 #include "llvm/IR/Module.h"
  17 #include "llvm/Pass.h"
  18 #include "llvm/Support/Debug.h"
  19 #include "llvm/Support/raw_ostream.h"
  20 using namespace llvm;
  21
  22 namespace {
  23
  24   class PrintModulePass : public ModulePass {
  25     std::string Banner;
  26     raw_ostream *Out;       // raw_ostream to print on
  27     bool DeleteStream;      // Delete the ostream in our dtor?
  28   public:
  29     static char ID;
  30     PrintModulePass() : ModulePass(ID), Out(&dbgs()),
  31       DeleteStream(false) {}
  32     PrintModulePass(const std::string &B, raw_ostream *o, bool DS)
  33         : ModulePass(ID), Banner(B), Out(o), DeleteStream(DS) {}
  34
  35     ~PrintModulePass() {
  36       if (DeleteStream) delete Out;
  37     }
  38
  39     bool runOnModule(Module &M) {
  40       (*Out) << Banner << M;
  41       return false;
  42     }
  43
  44     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  45       AU.setPreservesAll();
  46     }
  47   };
  48
  49   class PrintFunctionPass : public FunctionPass {
  50     std::string Banner;     // String to print before each function
  51     raw_ostream *Out;       // raw_ostream to print on
  52     bool DeleteStream;      // Delete the ostream in our dtor?
  53   public:
  54     static char ID;
  55     PrintFunctionPass() : FunctionPass(ID), Banner(""), Out(&dbgs()),
  56                           DeleteStream(false) {}
  57     PrintFunctionPass(const std::string &B, raw_ostream *o, bool DS)
  58       : FunctionPass(ID), Banner(B), Out(o), DeleteStream(DS) {}
  59
  60     ~PrintFunctionPass() {
  61       if (DeleteStream) delete Out;
  62     }
  63
  64     // runOnFunction - This pass just prints a banner followed by the
  65     // function as it's processed.
  66     //
  67     bool runOnFunction(Function &F) {
  68       (*Out) << Banner << static_cast<Value&>(F);
  69       return false;
  70     }
  71
  72     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  73       AU.setPreservesAll();
  74     }
  75   };
  76
  77   class PrintBasicBlockPass : public BasicBlockPass {
  78     std::string Banner;
  79     raw_ostream *Out;       // raw_ostream to print on
  80     bool DeleteStream;      // Delete the ostream in our dtor?
  81   public:
  82     static char ID;
  83     PrintBasicBlockPass() : BasicBlockPass(ID), Out(&dbgs()),
  84       DeleteStream(false) {}
  85     PrintBasicBlockPass(const std::string &B, raw_ostream *o, bool DS)
  86         : BasicBlockPass(ID), Banner(B), Out(o), DeleteStream(DS) {}
  87
  88     ~PrintBasicBlockPass() {
  89       if (DeleteStream) delete Out;
  90     }
  91
  92     bool runOnBasicBlock(BasicBlock &BB) {
  93       (*Out) << Banner << BB;
  94       return false;
  95     }
  96
  97     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  98       AU.setPreservesAll();
  99     }
 100   };
 101 }
 102
 103 char PrintModulePass::ID = 0;
 104 INITIALIZE_PASS(PrintModulePass, "print-module",
 105                 "Print module to stderr", false, false)
 106 char PrintFunctionPass::ID = 0;
 107 INITIALIZE_PASS(PrintFunctionPass, "print-function",
 108                 "Print function to stderr", false, false)
 109 char PrintBasicBlockPass::ID = 0;
 110 INITIALIZE_PASS(PrintBasicBlockPass, "print-bb",
 111                 "Print BB to stderr", false, false)
 112
 113 /// createPrintModulePass - Create and return a pass that writes the
 114 /// module to the specified raw_ostream.
 115 ModulePass *llvm::createPrintModulePass(llvm::raw_ostream *OS,
 116                                         bool DeleteStream,
 117                                         const std::string &Banner) {
 118   return new PrintModulePass(Banner, OS, DeleteStream);
 119 }
 120
 121 /// createPrintFunctionPass - Create and return a pass that prints
 122 /// functions to the specified raw_ostream as they are processed.
 123 FunctionPass *llvm::createPrintFunctionPass(const std::string &Banner,
 124                                             llvm::raw_ostream *OS,
 125                                             bool DeleteStream) {
 126   return new PrintFunctionPass(Banner, OS, DeleteStream);
 127 }
 128
 129 /// createPrintBasicBlockPass - Create and return a pass that writes the
 130 /// BB to the specified raw_ostream.
 131 BasicBlockPass *llvm::createPrintBasicBlockPass(llvm::raw_ostream *OS,
 132                                         bool DeleteStream,
 133                                         const std::string &Banner) {
 134   return new PrintBasicBlockPass(Banner, OS, DeleteStream);
 135 }
 136