Line data    Source code

       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           0 : PrintModulePass::PrintModulePass() : OS(dbgs()) {}
      24       14404 : PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner,
      25       14404 :                                  bool ShouldPreserveUseListOrder)
      26             :     : OS(OS), Banner(Banner),
      27       14404 :       ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
      28             : 
      29       14402 : PreservedAnalyses PrintModulePass::run(Module &M, ModuleAnalysisManager &) {
      30       14402 :   OS << Banner;
      31       14402 :   if (llvm::isFunctionInPrintList("*"))
      32       14400 :     M.print(OS, nullptr, ShouldPreserveUseListOrder);
      33             :   else {
      34           6 :     for(const auto &F : M.functions())
      35           4 :       if (llvm::isFunctionInPrintList(F.getName()))
      36           2 :         F.print(OS);
      37             :   }
      38       14401 :   return PreservedAnalyses::all();
      39             : }
      40             : 
      41           0 : PrintFunctionPass::PrintFunctionPass() : OS(dbgs()) {}
      42         164 : PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
      43         164 :     : OS(OS), Banner(Banner) {}
      44             : 
      45         253 : PreservedAnalyses PrintFunctionPass::run(Function &F,
      46             :                                          FunctionAnalysisManager &) {
      47         253 :   if (isFunctionInPrintList(F.getName())) {
      48         233 :     if (forcePrintModuleIR())
      49           6 :       OS << Banner << " (function: " << F.getName() << ")\n" << *F.getParent();
      50             :     else
      51         227 :       OS << Banner << static_cast<Value &>(F);
      52             :   }
      53         253 :   return PreservedAnalyses::all();
      54             : }
      55             : 
      56             : namespace {
      57             : 
      58             : class PrintModulePassWrapper : public ModulePass {
      59             :   PrintModulePass P;
      60             : 
      61             : public:
      62             :   static char ID;
      63           0 :   PrintModulePassWrapper() : ModulePass(ID) {}
      64             :   PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner,
      65             :                          bool ShouldPreserveUseListOrder)
      66       13755 :       : ModulePass(ID), P(OS, Banner, ShouldPreserveUseListOrder) {}
      67             : 
      68       13755 :   bool runOnModule(Module &M) override {
      69       13755 :     ModuleAnalysisManager DummyMAM;
      70       13755 :     P.run(M, DummyMAM);
      71       13754 :     return false;
      72             :   }
      73             : 
      74       13755 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
      75             :     AU.setPreservesAll();
      76       13755 :   }
      77             : 
      78          17 :   StringRef getPassName() const override { return "Print Module IR"; }
      79             : };
      80             : 
      81             : class PrintFunctionPassWrapper : public FunctionPass {
      82             :   PrintFunctionPass P;
      83             : 
      84             : public:
      85             :   static char ID;
      86           0 :   PrintFunctionPassWrapper() : FunctionPass(ID) {}
      87             :   PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
      88         324 :       : FunctionPass(ID), P(OS, Banner) {}
      89             : 
      90             :   // This pass just prints a banner followed by the function as it's processed.
      91         251 :   bool runOnFunction(Function &F) override {
      92         251 :     FunctionAnalysisManager DummyFAM;
      93         251 :     P.run(F, DummyFAM);
      94         251 :     return false;
      95             :   }
      96             : 
      97         162 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
      98             :     AU.setPreservesAll();
      99         162 :   }
     100             : 
     101           0 :   StringRef getPassName() const override { return "Print Function IR"; }
     102             : };
     103             : 
     104             : class PrintBasicBlockPass : public BasicBlockPass {
     105             :   raw_ostream &Out;
     106             :   std::string Banner;
     107             : 
     108             : public:
     109             :   static char ID;
     110           0 :   PrintBasicBlockPass() : BasicBlockPass(ID), Out(dbgs()) {}
     111             :   PrintBasicBlockPass(raw_ostream &Out, const std::string &Banner)
     112           0 :       : BasicBlockPass(ID), Out(Out), Banner(Banner) {}
     113             : 
     114           0 :   bool runOnBasicBlock(BasicBlock &BB) override {
     115           0 :     Out << Banner << BB;
     116           0 :     return false;
     117             :   }
     118             : 
     119           0 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
     120             :     AU.setPreservesAll();
     121             :   }
     122             : 
     123           0 :   StringRef getPassName() const override { return "Print BasicBlock IR"; }
     124             : };
     125             : 
     126             : }
     127             : 
     128             : char PrintModulePassWrapper::ID = 0;
     129       64254 : INITIALIZE_PASS(PrintModulePassWrapper, "print-module",
     130             :                 "Print module to stderr", false, true)
     131             : char PrintFunctionPassWrapper::ID = 0;
     132       64254 : INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function",
     133             :                 "Print function to stderr", false, true)
     134             : char PrintBasicBlockPass::ID = 0;
     135       64254 : INITIALIZE_PASS(PrintBasicBlockPass, "print-bb", "Print BB to stderr", false,
     136             :                 true)
     137             : 
     138       13755 : ModulePass *llvm::createPrintModulePass(llvm::raw_ostream &OS,
     139             :                                         const std::string &Banner,
     140             :                                         bool ShouldPreserveUseListOrder) {
     141       13755 :   return new PrintModulePassWrapper(OS, Banner, ShouldPreserveUseListOrder);
     142             : }
     143             : 
     144         162 : FunctionPass *llvm::createPrintFunctionPass(llvm::raw_ostream &OS,
     145             :                                             const std::string &Banner) {
     146         162 :   return new PrintFunctionPassWrapper(OS, Banner);
     147             : }
     148             : 
     149           0 : BasicBlockPass *llvm::createPrintBasicBlockPass(llvm::raw_ostream &OS,
     150             :                                                 const std::string &Banner) {
     151           0 :   return new PrintBasicBlockPass(OS, Banner);
     152             : }
     153             : 
     154         446 : bool llvm::isIRPrintingPass(Pass *P) {
     155         446 :   const char *PID = (const char*)P->getPassID();
     156             : 
     157             :   return (PID == &PrintModulePassWrapper::ID)
     158         441 :       || (PID == &PrintFunctionPassWrapper::ID)
     159         887 :       || (PID == &PrintBasicBlockPass::ID);
     160             : }