LLVM  8.0.0svn
IRPrintingPasses.cpp
Go to the documentation of this file.
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 
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"
21 using namespace llvm;
22 
24 PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner,
25  bool ShouldPreserveUseListOrder)
26  : OS(OS), Banner(Banner),
27  ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
28 
30  OS << Banner;
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 
42 PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
43  : OS(OS), Banner(Banner) {}
44 
47  if (isFunctionInPrintList(F.getName())) {
48  if (forcePrintModuleIR())
49  OS << Banner << " (function: " << F.getName() << ")\n" << *F.getParent();
50  else
51  OS << Banner << static_cast<Value &>(F);
52  }
53  return PreservedAnalyses::all();
54 }
55 
56 namespace {
57 
58 class PrintModulePassWrapper : public ModulePass {
60 
61 public:
62  static char ID;
63  PrintModulePassWrapper() : ModulePass(ID) {}
64  PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner,
65  bool ShouldPreserveUseListOrder)
66  : ModulePass(ID), P(OS, Banner, ShouldPreserveUseListOrder) {}
67 
68  bool runOnModule(Module &M) override {
69  ModuleAnalysisManager DummyMAM;
70  P.run(M, DummyMAM);
71  return false;
72  }
73 
74  void getAnalysisUsage(AnalysisUsage &AU) const override {
75  AU.setPreservesAll();
76  }
77 
78  StringRef getPassName() const override { return "Print Module IR"; }
79 };
80 
81 class PrintFunctionPassWrapper : public FunctionPass {
83 
84 public:
85  static char ID;
86  PrintFunctionPassWrapper() : FunctionPass(ID) {}
87  PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
88  : FunctionPass(ID), P(OS, Banner) {}
89 
90  // This pass just prints a banner followed by the function as it's processed.
91  bool runOnFunction(Function &F) override {
92  FunctionAnalysisManager DummyFAM;
93  P.run(F, DummyFAM);
94  return false;
95  }
96 
97  void getAnalysisUsage(AnalysisUsage &AU) const override {
98  AU.setPreservesAll();
99  }
100 
101  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  PrintBasicBlockPass() : BasicBlockPass(ID), Out(dbgs()) {}
111  PrintBasicBlockPass(raw_ostream &Out, const std::string &Banner)
112  : BasicBlockPass(ID), Out(Out), Banner(Banner) {}
113 
114  bool runOnBasicBlock(BasicBlock &BB) override {
115  Out << Banner << BB;
116  return false;
117  }
118 
119  void getAnalysisUsage(AnalysisUsage &AU) const override {
120  AU.setPreservesAll();
121  }
122 
123  StringRef getPassName() const override { return "Print BasicBlock IR"; }
124 };
125 
126 }
127 
129 INITIALIZE_PASS(PrintModulePassWrapper, "print-module",
130  "Print module to stderr", false, true)
132 INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function",
133  "Print function to stderr", false, true)
134 char PrintBasicBlockPass::ID = 0;
135 INITIALIZE_PASS(PrintBasicBlockPass, "print-bb", "Print BB to stderr", false,
136  true)
137 
139  const std::string &Banner,
140  bool ShouldPreserveUseListOrder) {
141  return new PrintModulePassWrapper(OS, Banner, ShouldPreserveUseListOrder);
142 }
143 
145  const std::string &Banner) {
146  return new PrintFunctionPassWrapper(OS, Banner);
147 }
148 
150  const std::string &Banner) {
151  return new PrintBasicBlockPass(OS, Banner);
152 }
153 
155  const char *PID = (const char*)P->getPassID();
156 
157  return (PID == &PrintModulePassWrapper::ID)
158  || (PID == &PrintFunctionPassWrapper::ID)
159  || (PID == &PrintBasicBlockPass::ID);
160 }
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:81
bool forcePrintModuleIR()
forcePrintModuleIR - returns true if IR printing passes should
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
Pass for printing a Module as LLVM&#39;s text IR assembly.
FunctionPass * createPrintFunctionPass(raw_ostream &OS, const std::string &Banner="")
Create and return a pass that prints functions to the specified raw_ostream as they are processed...
F(f)
Definition: BitVector.h:938
bool isIRPrintingPass(Pass *P)
Return true if a pass is for IR printing.
static bool runOnFunction(Function &F, bool PostInlining)
#define P(N)
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:154
iterator_range< iterator > functions()
Definition: Module.h:595
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
AnalysisID getPassID() const
getPassID - Return the PassID number that corresponds to this pass.
Definition: Pass.h:100
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:285
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:160
INITIALIZE_PASS(PrintModulePassWrapper, "print-module", "Print module to stderr", false, true) char PrintFunctionPassWrapper INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function", "Print function to stderr", false, true) char PrintBasicBlockPass INITIALIZE_PASS(PrintBasicBlockPass, "print-bb", "Print BB to stderr", false, true) ModulePass *llvm
BasicBlockPass class - This class is used to implement most local optimizations.
Definition: Pass.h:319
void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW, bool ShouldPreserveUseListOrder=false, bool IsForDebug=false) const
Print the module to an output stream with an optional AssemblyAnnotationWriter.
Definition: AsmWriter.cpp:4012
Module.h This file contains the declarations for the Module class.
BasicBlockPass * createPrintBasicBlockPass(raw_ostream &OS, const std::string &Banner="")
Create and return a pass that writes the BB to the specified raw_ostream.
bool isFunctionInPrintList(StringRef FunctionName)
isFunctionInPrintList - returns true if a function should be printed via
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
static bool runOnBasicBlock(MachineBasicBlock *MBB, std::vector< StringRef > &bbNames, std::vector< unsigned > &renamedInOtherBB, unsigned &basicBlockNum, unsigned &VRegGapIndex, NamedVRegCursor &NVC)
void setPreservesAll()
Set by analyses that do not transform their input at all.
PreservedAnalyses run(Module &M, AnalysisManager< Module > &)
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:225
ModulePass * createPrintModulePass(raw_ostream &OS, const std::string &Banner="", bool ShouldPreserveUseListOrder=false)
Create and return a pass that writes the module to the specified raw_ostream.
This file defines passes to print out IR in various granularities.
aarch64 promote const
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:566
PreservedAnalyses run(Function &F, AnalysisManager< Function > &)
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A container for analyses that lazily runs them and caches their results.
This header defines various interfaces for pass management in LLVM.
Pass for printing a Function as LLVM&#39;s text IR assembly.