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