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