LLVM  10.0.0svn
IRPrintingPasses.cpp
Go to the documentation of this file.
1 //===--- IRPrintingPasses.cpp - Module and Function printing passes -------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // PrintModulePass and PrintFunctionPass implementations.
10 //
11 //===----------------------------------------------------------------------===//
12 
14 #include "llvm/IR/Function.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/IR/PassManager.h"
17 #include "llvm/Pass.h"
18 #include "llvm/Support/Debug.h"
20 using namespace llvm;
21 
23 PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner,
24  bool ShouldPreserveUseListOrder)
25  : OS(OS), Banner(Banner),
26  ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
27 
29  if (!Banner.empty())
30  OS << Banner << "\n";
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:80
bool forcePrintModuleIR()
forcePrintModuleIR - returns true if IR printing passes should
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
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:937
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:153
iterator_range< iterator > functions()
Definition: Module.h:609
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
AnalysisID getPassID() const
getPassID - Return the PassID number that corresponds to this pass.
Definition: Pass.h:99
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:284
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:159
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:318
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:4195
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:132
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:214
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:224
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:575
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:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
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.