LLVM  16.0.0git
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 for the legacy pass
10 // manager.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/IR/Function.h"
17 #include "llvm/IR/Module.h"
18 #include "llvm/IR/PrintPasses.h"
19 #include "llvm/InitializePasses.h"
20 #include "llvm/Pass.h"
21 #include "llvm/Support/Debug.h"
23 
24 using namespace llvm;
25 
26 namespace {
27 
28 class PrintModulePassWrapper : public ModulePass {
29  raw_ostream &OS;
30  std::string Banner;
31  bool ShouldPreserveUseListOrder;
32 
33 public:
34  static char ID;
35  PrintModulePassWrapper() : ModulePass(ID), OS(dbgs()) {}
36  PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner,
37  bool ShouldPreserveUseListOrder)
38  : ModulePass(ID), OS(OS), Banner(Banner),
39  ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
40 
41  bool runOnModule(Module &M) override {
42  if (llvm::isFunctionInPrintList("*")) {
43  if (!Banner.empty())
44  OS << Banner << "\n";
45  M.print(OS, nullptr, ShouldPreserveUseListOrder);
46  } else {
47  bool BannerPrinted = false;
48  for (const auto &F : M.functions()) {
49  if (llvm::isFunctionInPrintList(F.getName())) {
50  if (!BannerPrinted && !Banner.empty()) {
51  OS << Banner << "\n";
52  BannerPrinted = true;
53  }
54  F.print(OS);
55  }
56  }
57  }
58  return false;
59  }
60 
61  void getAnalysisUsage(AnalysisUsage &AU) const override {
62  AU.setPreservesAll();
63  }
64 
65  StringRef getPassName() const override { return "Print Module IR"; }
66 };
67 
68 class PrintFunctionPassWrapper : public FunctionPass {
69  raw_ostream &OS;
70  std::string Banner;
71 
72 public:
73  static char ID;
74  PrintFunctionPassWrapper() : FunctionPass(ID), OS(dbgs()) {}
75  PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
76  : FunctionPass(ID), OS(OS), Banner(Banner) {}
77 
78  // This pass just prints a banner followed by the function as it's processed.
79  bool runOnFunction(Function &F) override {
80  if (isFunctionInPrintList(F.getName())) {
81  if (forcePrintModuleIR())
82  OS << Banner << " (function: " << F.getName() << ")\n"
83  << *F.getParent();
84  else
85  OS << Banner << '\n' << static_cast<Value &>(F);
86  }
87  return false;
88  }
89 
90  void getAnalysisUsage(AnalysisUsage &AU) const override {
91  AU.setPreservesAll();
92  }
93 
94  StringRef getPassName() const override { return "Print Function IR"; }
95 };
96 
97 } // namespace
98 
100 INITIALIZE_PASS(PrintModulePassWrapper, "print-module",
101  "Print module to stderr", false, true)
102 char PrintFunctionPassWrapper::ID = 0;
103 INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function",
104  "Print function to stderr", false, true)
105 
107  const std::string &Banner,
108  bool ShouldPreserveUseListOrder) {
109  return new PrintModulePassWrapper(OS, Banner, ShouldPreserveUseListOrder);
110 }
111 
113  const std::string &Banner) {
114  return new PrintFunctionPassWrapper(OS, Banner);
115 }
116 
118  const char *PID = (const char *)P->getPassID();
119 
120  return (PID == &PrintModulePassWrapper::ID) ||
122 }
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::AArch64PACKey::ID
ID
Definition: AArch64BaseInfo.h:818
llvm::ModulePass
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:248
llvm::Function
Definition: Function.h:60
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
Pass.h
to
Should compile to
Definition: README.txt:449
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1794
Module.h
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
false
Definition: StackSlotColoring.cpp:141
IRPrintingPasses.h
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
PrintPasses.h
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::isFunctionInPrintList
bool isFunctionInPrintList(StringRef FunctionName)
Definition: PrintPasses.cpp:152
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::print
Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr)
Definition: GCNRegPressure.cpp:138
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
INITIALIZE_PASS
INITIALIZE_PASS(PrintModulePassWrapper, "print-module", "Print module to stderr", false, true) char PrintFunctionPassWrapper INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function", "Print function to stderr", false, true) ModulePass *llvm
Definition: IRPrintingPasses.cpp:103
llvm::rdf::Print
Print(const T &, const DataFlowGraph &) -> Print< T >
runOnFunction
static bool runOnFunction(Function &F, bool PostInlining)
Definition: EntryExitInstrumenter.cpp:85
std
Definition: BitVector.h:851
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::isIRPrintingPass
bool isIRPrintingPass(Pass *P)
Return true if a pass is for IR printing.
Definition: IRPrintingPasses.cpp:117
Function.h
llvm::Pass
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:91
llvm::forcePrintModuleIR
bool forcePrintModuleIR()
Definition: PrintPasses.cpp:142
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:308
raw_ostream.h
InitializePasses.h
Debug.h
llvm::createPrintFunctionPass
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.
Definition: IRPrintingPasses.cpp:112
llvm::createPrintModulePass
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.
INITIALIZE_PASS
TargetPassConfig.
Definition: TargetPassConfig.cpp:368