1 //===--- IRPrintingPasses.cpp - Module and Function printing passes -------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // PrintModulePass and PrintFunctionPass implementations.
12 //===----------------------------------------------------------------------===//
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"
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) {}
29 PreservedAnalyses PrintModulePass::run(Module &M, ModuleAnalysisManager &) {
31 if (llvm::isFunctionInPrintList("*"))
32 M.print(OS, nullptr, ShouldPreserveUseListOrder);
34 for(const auto &F : M.functions())
35 if (llvm::isFunctionInPrintList(F.getName()))
38 return PreservedAnalyses::all();
41 PrintFunctionPass::PrintFunctionPass() : OS(dbgs()) {}
42 PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
43 : OS(OS), Banner(Banner) {}
45 PreservedAnalyses PrintFunctionPass::run(Function &F,
46 FunctionAnalysisManager &) {
47 if (isFunctionInPrintList(F.getName()))
48 OS << Banner << static_cast<Value &>(F);
49 return PreservedAnalyses::all();
54 class PrintModulePassWrapper : public ModulePass {
59 PrintModulePassWrapper() : ModulePass(ID) {}
60 PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner,
61 bool ShouldPreserveUseListOrder)
62 : ModulePass(ID), P(OS, Banner, ShouldPreserveUseListOrder) {}
64 bool runOnModule(Module &M) override {
65 ModuleAnalysisManager DummyMAM;
70 void getAnalysisUsage(AnalysisUsage &AU) const override {
74 StringRef getPassName() const override { return "Print Module IR"; }
\r
77 class PrintFunctionPassWrapper : public FunctionPass {
82 PrintFunctionPassWrapper() : FunctionPass(ID) {}
83 PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
84 : FunctionPass(ID), P(OS, Banner) {}
86 // This pass just prints a banner followed by the function as it's processed.
87 bool runOnFunction(Function &F) override {
88 FunctionAnalysisManager DummyFAM;
93 void getAnalysisUsage(AnalysisUsage &AU) const override {
97 StringRef getPassName() const override { return "Print Function IR"; }
\r
100 class PrintBasicBlockPass : public BasicBlockPass {
106 PrintBasicBlockPass() : BasicBlockPass(ID), Out(dbgs()) {}
107 PrintBasicBlockPass(raw_ostream &Out, const std::string &Banner)
108 : BasicBlockPass(ID), Out(Out), Banner(Banner) {}
110 bool runOnBasicBlock(BasicBlock &BB) override {
115 void getAnalysisUsage(AnalysisUsage &AU) const override {
116 AU.setPreservesAll();
119 StringRef getPassName() const override { return "Print BasicBlock IR"; }
124 char PrintModulePassWrapper::ID = 0;
125 INITIALIZE_PASS(PrintModulePassWrapper, "print-module",
126 "Print module to stderr", false, false)
127 char PrintFunctionPassWrapper::ID = 0;
128 INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function",
129 "Print function to stderr", false, false)
130 char PrintBasicBlockPass::ID = 0;
131 INITIALIZE_PASS(PrintBasicBlockPass, "print-bb", "Print BB to stderr", false,
134 ModulePass *llvm::createPrintModulePass(llvm::raw_ostream &OS,
135 const std::string &Banner,
136 bool ShouldPreserveUseListOrder) {
137 return new PrintModulePassWrapper(OS, Banner, ShouldPreserveUseListOrder);
140 FunctionPass *llvm::createPrintFunctionPass(llvm::raw_ostream &OS,
141 const std::string &Banner) {
142 return new PrintFunctionPassWrapper(OS, Banner);
145 BasicBlockPass *llvm::createPrintBasicBlockPass(llvm::raw_ostream &OS,
146 const std::string &Banner) {
147 return new PrintBasicBlockPass(OS, Banner);