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