Home | History | Annotate | Download | only in IR 
      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, AnalysisManager<Module> &) {
     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                                          AnalysisManager<Function> &) {
     47   if (isFunctionInPrintList(F.getName()))
     48     OS << Banner << static_cast<Value &>(F);
     49   return PreservedAnalyses::all();
     50 }
     51 
     52 namespace {
     53 
     54 class PrintModulePassWrapper : public ModulePass {
     55   PrintModulePass P;
     56 
     57 public:
     58   static char ID;
     59   PrintModulePassWrapper() : ModulePass(ID) {}
     60   PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner,
     61                          bool ShouldPreserveUseListOrder)
     62       : ModulePass(ID), P(OS, Banner, ShouldPreserveUseListOrder) {}
     63 
     64   bool runOnModule(Module &M) override {
     65     ModuleAnalysisManager DummyMAM;
     66     P.run(M, DummyMAM);
     67     return false;
     68   }
     69 
     70   void getAnalysisUsage(AnalysisUsage &AU) const override {
     71     AU.setPreservesAll();
     72   }
     73 };
     74 
     75 class PrintFunctionPassWrapper : public FunctionPass {
     76   PrintFunctionPass P;
     77 
     78 public:
     79   static char ID;
     80   PrintFunctionPassWrapper() : FunctionPass(ID) {}
     81   PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
     82       : FunctionPass(ID), P(OS, Banner) {}
     83 
     84   // This pass just prints a banner followed by the function as it's processed.
     85   bool runOnFunction(Function &F) override {
     86     FunctionAnalysisManager DummyFAM;
     87     P.run(F, DummyFAM);
     88     return false;
     89   }
     90 
     91   void getAnalysisUsage(AnalysisUsage &AU) const override {
     92     AU.setPreservesAll();
     93   }
     94 };
     95 
     96 class PrintBasicBlockPass : public BasicBlockPass {
     97   raw_ostream &Out;
     98   std::string Banner;
     99 
    100 public:
    101   static char ID;
    102   PrintBasicBlockPass() : BasicBlockPass(ID), Out(dbgs()) {}
    103   PrintBasicBlockPass(raw_ostream &Out, const std::string &Banner)
    104       : BasicBlockPass(ID), Out(Out), Banner(Banner) {}
    105 
    106   bool runOnBasicBlock(BasicBlock &BB) override {
    107     Out << Banner << BB;
    108     return false;
    109   }
    110 
    111   void getAnalysisUsage(AnalysisUsage &AU) const override {
    112     AU.setPreservesAll();
    113   }
    114 };
    115 
    116 }
    117 
    118 char PrintModulePassWrapper::ID = 0;
    119 INITIALIZE_PASS(PrintModulePassWrapper, "print-module",
    120                 "Print module to stderr", false, false)
    121 char PrintFunctionPassWrapper::ID = 0;
    122 INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function",
    123                 "Print function to stderr", false, false)
    124 char PrintBasicBlockPass::ID = 0;
    125 INITIALIZE_PASS(PrintBasicBlockPass, "print-bb", "Print BB to stderr", false,
    126                 false)
    127 
    128 ModulePass *llvm::createPrintModulePass(llvm::raw_ostream &OS,
    129                                         const std::string &Banner,
    130                                         bool ShouldPreserveUseListOrder) {
    131   return new PrintModulePassWrapper(OS, Banner, ShouldPreserveUseListOrder);
    132 }
    133 
    134 FunctionPass *llvm::createPrintFunctionPass(llvm::raw_ostream &OS,
    135                                             const std::string &Banner) {
    136   return new PrintFunctionPassWrapper(OS, Banner);
    137 }
    138 
    139 BasicBlockPass *llvm::createPrintBasicBlockPass(llvm::raw_ostream &OS,
    140                                                 const std::string &Banner) {
    141   return new PrintBasicBlockPass(OS, Banner);
    142 }
    143