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"
20using namespace llvm;
21
22namespace {
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
103char PrintModulePass::ID = 0;
104INITIALIZE_PASS(PrintModulePass, "print-module",
105                "Print module to stderr", false, false)
106char PrintFunctionPass::ID = 0;
107INITIALIZE_PASS(PrintFunctionPass, "print-function",
108                "Print function to stderr", false, false)
109char PrintBasicBlockPass::ID = 0;
110INITIALIZE_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.
115ModulePass *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.
123FunctionPass *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.
131BasicBlockPass *llvm::createPrintBasicBlockPass(llvm::raw_ostream *OS,
132                                        bool DeleteStream,
133                                        const std::string &Banner) {
134  return new PrintBasicBlockPass(Banner, OS, DeleteStream);
135}
136
137