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