LLVM 19.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"
20#include "llvm/Pass.h"
21#include "llvm/Support/Debug.h"
23
24using namespace llvm;
25
26namespace {
27
28class PrintModulePassWrapper : public ModulePass {
30 std::string Banner;
31 bool ShouldPreserveUseListOrder;
32
33public:
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 // RemoveDIs: there's no textual representation of the DPValue debug-info,
43 // convert to dbg.values before writing out.
44 bool IsNewDbgInfoFormat = M.IsNewDbgInfoFormat;
45 if (IsNewDbgInfoFormat)
46 M.convertFromNewDbgValues();
47
49 if (!Banner.empty())
50 OS << Banner << "\n";
51 M.print(OS, nullptr, ShouldPreserveUseListOrder);
52 } else {
53 bool BannerPrinted = false;
54 for (const auto &F : M.functions()) {
55 if (llvm::isFunctionInPrintList(F.getName())) {
56 if (!BannerPrinted && !Banner.empty()) {
57 OS << Banner << "\n";
58 BannerPrinted = true;
59 }
60 F.print(OS);
61 }
62 }
63 }
64
65 if (IsNewDbgInfoFormat)
66 M.convertToNewDbgValues();
67
68 return false;
69 }
70
71 void getAnalysisUsage(AnalysisUsage &AU) const override {
72 AU.setPreservesAll();
73 }
74
75 StringRef getPassName() const override { return "Print Module IR"; }
76};
77
78class PrintFunctionPassWrapper : public FunctionPass {
80 std::string Banner;
81
82public:
83 static char ID;
84 PrintFunctionPassWrapper() : FunctionPass(ID), OS(dbgs()) {}
85 PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
86 : FunctionPass(ID), OS(OS), Banner(Banner) {}
87
88 // This pass just prints a banner followed by the function as it's processed.
89 bool runOnFunction(Function &F) override {
90 // RemoveDIs: there's no textual representation of the DPValue debug-info,
91 // convert to dbg.values before writing out.
92 bool IsNewDbgInfoFormat = F.IsNewDbgInfoFormat;
93 if (IsNewDbgInfoFormat)
94 F.convertFromNewDbgValues();
95
96 if (isFunctionInPrintList(F.getName())) {
98 OS << Banner << " (function: " << F.getName() << ")\n"
99 << *F.getParent();
100 else
101 OS << Banner << '\n' << static_cast<Value &>(F);
102 }
103
104 if (IsNewDbgInfoFormat)
105 F.convertToNewDbgValues();
106
107 return false;
108 }
109
110 void getAnalysisUsage(AnalysisUsage &AU) const override {
111 AU.setPreservesAll();
112 }
113
114 StringRef getPassName() const override { return "Print Function IR"; }
115};
116
117} // namespace
118
119char PrintModulePassWrapper::ID = 0;
120INITIALIZE_PASS(PrintModulePassWrapper, "print-module",
121 "Print module to stderr", false, true)
122char PrintFunctionPassWrapper::ID = 0;
123INITIALIZE_PASS(PrintFunctionPassWrapper, "print-function",
124 "Print function to stderr", false, true)
125
127 const std::string &Banner,
128 bool ShouldPreserveUseListOrder) {
129 return new PrintModulePassWrapper(OS, Banner, ShouldPreserveUseListOrder);
130}
131
133 const std::string &Banner) {
134 return new PrintFunctionPassWrapper(OS, Banner);
135}
136
138 const char *PID = (const char *)P->getPassID();
139
140 return (PID == &PrintModulePassWrapper::ID) ||
141 (PID == &PrintFunctionPassWrapper::ID);
142}
aarch64 promote const
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
basic Basic Alias true
Performs the initial survey of the specified function
This file contains an interface for creating legacy passes to print out IR in various granularities.
#define F(x, y, z)
Definition: MD5.cpp:55
Module.h This file contains the declarations for the Module class.
#define P(N)
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:38
raw_pwrite_stream & OS
Represent the analysis usage information of a pass.
void setPreservesAll()
Set by analyses that do not transform their input at all.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:251
virtual bool runOnModule(Module &M)=0
runOnModule - Virtual method overriden by subclasses to process the module being operated on.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:94
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:98
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:81
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
TargetPassConfig.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
bool forcePrintModuleIR()
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
bool isFunctionInPrintList(StringRef FunctionName)
bool isIRPrintingPass(Pass *P)
Return true if a pass is for IR printing.
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.
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.
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858