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   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 }