lib/IR/IRPrintingPasses.cpp

   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   M.print(OS, nullptr, ShouldPreserveUseListOrder);
  32   return PreservedAnalyses::all();
  33 }
  34
  35 PrintFunctionPass::PrintFunctionPass() : OS(dbgs()) {}
  36 PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
  37     : OS(OS), Banner(Banner) {}
  38
  39 PreservedAnalyses PrintFunctionPass::run(Function &F) {
  40   OS << Banner << static_cast<Value &>(F);
  41   return PreservedAnalyses::all();
  42 }
  43
  44 namespace {
  45
  46 class PrintModulePassWrapper : public ModulePass {
  47   PrintModulePass P;
  48
  49 public:
  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
  66 class PrintFunctionPassWrapper : public FunctionPass {
  67   PrintFunctionPass P;
  68
  69 public:
  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
  86 class PrintBasicBlockPass : public BasicBlockPass {
  87   raw_ostream &Out;
  88   std::string Banner;
  89
  90 public:
  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
 108 char PrintModulePassWrapper::ID = 0;
 109 INITIALIZE_PASS(PrintModulePassWrapper, "print-module",
 110                 "Print module to stderr", false, false)
 111 char PrintFunctionPassWrapper::ID = 0;
 112 INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function",
 113                 "Print function to stderr", false, false)
 114 char PrintBasicBlockPass::ID = 0;
 115 INITIALIZE_PASS(PrintBasicBlockPass, "print-bb", "Print BB to stderr", false,
 116                 false)
 117
 118 ModulePass *llvm::createPrintModulePass(llvm::raw_ostream &OS,
 119                                         const std::string &Banner,
 120                                         bool ShouldPreserveUseListOrder) {
 121   return new PrintModulePassWrapper(OS, Banner, ShouldPreserveUseListOrder);
 122 }
 123
 124 FunctionPass *llvm::createPrintFunctionPass(llvm::raw_ostream &OS,
 125                                             const std::string &Banner) {
 126   return new PrintFunctionPassWrapper(OS, Banner);
 127 }
 128
 129 BasicBlockPass *llvm::createPrintBasicBlockPass(llvm::raw_ostream &OS,
 130                                                 const std::string &Banner) {
 131   return new PrintBasicBlockPass(OS, Banner);
 132 }