Home | History | Annotate | Download | only in IR 
      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/Assembly/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 
    137