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