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"
21 using namespace llvm;
22 
23 PrintModulePass::PrintModulePass() : OS(dbgs()) {}
24 PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner,
25                                  bool ShouldPreserveUseListOrder)
26     : OS(OS), Banner(Banner),
27       ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
28 
29 PreservedAnalyses PrintModulePass::run(Module &M, ModuleAnalysisManager &) {
30   if (!Banner.empty())
31     OS << Banner << "\n";
32   if (llvm::isFunctionInPrintList("*"))
33     M.print(OS, nullptr, ShouldPreserveUseListOrder);
34   else {
35     for(const auto &F : M.functions())
36       if (llvm::isFunctionInPrintList(F.getName()))
37         F.print(OS);
38   }
39   return PreservedAnalyses::all();
40 }
41 
42 PrintFunctionPass::PrintFunctionPass() : OS(dbgs()) {}
43 PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
44     : OS(OS), Banner(Banner) {}
45 
46 PreservedAnalyses PrintFunctionPass::run(Function &F,
47                                          FunctionAnalysisManager &) {
48   if (isFunctionInPrintList(F.getName())) {
49     if (forcePrintModuleIR())
50       OS << Banner << " (function: " << F.getName() << ")\n" << *F.getParent();
51     else
52       OS << Banner << static_cast<Value &>(F);
53   }
54   return PreservedAnalyses::all();
55 }
56 
57 namespace {
58 
59 class PrintModulePassWrapper : public ModulePass {
60   PrintModulePass P;
61 
62 public:
63   static char ID;
64   PrintModulePassWrapper() : ModulePass(ID) {}
65   PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner,
66                          bool ShouldPreserveUseListOrder)
67       : ModulePass(ID), P(OS, Banner, ShouldPreserveUseListOrder) {}
68 
69   bool runOnModule(Module &M) override {
70     ModuleAnalysisManager DummyMAM;
71     P.run(M, DummyMAM);
72     return false;
73   }
74 
75   void getAnalysisUsage(AnalysisUsage &AU) const override {
76     AU.setPreservesAll();
77   }
78 
79   StringRef getPassName() const override { return "Print Module IR"; }
80 };
81 
82 class PrintFunctionPassWrapper : public FunctionPass {
83   PrintFunctionPass P;
84 
85 public:
86   static char ID;
87   PrintFunctionPassWrapper() : FunctionPass(ID) {}
88   PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
89       : FunctionPass(ID), P(OS, Banner) {}
90 
91   // This pass just prints a banner followed by the function as it's processed.
92   bool runOnFunction(Function &F) override {
93     FunctionAnalysisManager DummyFAM;
94     P.run(F, DummyFAM);
95     return false;
96   }
97 
98   void getAnalysisUsage(AnalysisUsage &AU) const override {
99     AU.setPreservesAll();
100   }
101 
102   StringRef getPassName() const override { return "Print Function IR"; }
103 };
104 
105 class PrintBasicBlockPass : public BasicBlockPass {
106   raw_ostream &Out;
107   std::string Banner;
108 
109 public:
110   static char ID;
111   PrintBasicBlockPass() : BasicBlockPass(ID), Out(dbgs()) {}
112   PrintBasicBlockPass(raw_ostream &Out, const std::string &Banner)
113       : BasicBlockPass(ID), Out(Out), Banner(Banner) {}
114 
115   bool runOnBasicBlock(BasicBlock &BB) override {
116     Out << Banner << BB;
117     return false;
118   }
119 
120   void getAnalysisUsage(AnalysisUsage &AU) const override {
121     AU.setPreservesAll();
122   }
123 
124   StringRef getPassName() const override { return "Print BasicBlock IR"; }
125 };
126 
127 }
128 
129 char PrintModulePassWrapper::ID = 0;
130 INITIALIZE_PASS(PrintModulePassWrapper, "print-module",
131                 "Print module to stderr", false, true)
132 char PrintFunctionPassWrapper::ID = 0;
133 INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function",
134                 "Print function to stderr", false, true)
135 char PrintBasicBlockPass::ID = 0;
136 INITIALIZE_PASS(PrintBasicBlockPass, "print-bb", "Print BB to stderr", false,
137                 true)
138 
139 ModulePass *llvm::createPrintModulePass(llvm::raw_ostream &OS,
140                                         const std::string &Banner,
141                                         bool ShouldPreserveUseListOrder) {
142   return new PrintModulePassWrapper(OS, Banner, ShouldPreserveUseListOrder);
143 }
144 
145 FunctionPass *llvm::createPrintFunctionPass(llvm::raw_ostream &OS,
146                                             const std::string &Banner) {
147   return new PrintFunctionPassWrapper(OS, Banner);
148 }
149 
150 BasicBlockPass *llvm::createPrintBasicBlockPass(llvm::raw_ostream &OS,
151                                                 const std::string &Banner) {
152   return new PrintBasicBlockPass(OS, Banner);
153 }
154 
155 bool llvm::isIRPrintingPass(Pass *P) {
156   const char *PID = (const char*)P->getPassID();
157 
158   return (PID == &PrintModulePassWrapper::ID)
159       || (PID == &PrintFunctionPassWrapper::ID)
160       || (PID == &PrintBasicBlockPass::ID);
161 }
162