LLVM 19.0.0git
TargetPassRegistry.inc
Go to the documentation of this file.
1//===- TargetPassRegistry.inc - Registry of passes --------------*- C++ -*-===//
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// This file is used as the registry of passes in registerPassBuilderCallbacks
10// Just put the following lines in the body of registerPassBuilderCallbacks:
11// #define GET_PASS_REGISTRY "<Target>PassRegistry.def"
12// #include "llvm/Passes/TargetPassRegistry.inc"
13//
14//===----------------------------------------------------------------------===//
15
16// NOTE: NO INCLUDE GUARD DESIRED!
17
18#ifdef GET_PASS_REGISTRY
19
20#if !__has_include(GET_PASS_REGISTRY)
21#error "must provide <Target>PassRegistry.def"
22#endif
23
24if (PopulateClassToPassNames) {
25 auto *PIC = PB.getPassInstrumentationCallbacks();
26
27#define ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) \
28 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
29#define ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS) \
30 PIC->addClassToPassName(CLASS, NAME);
31
32#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
33 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
34#define MODULE_PASS(NAME, CREATE_PASS) \
35 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
36#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
37 ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS)
38#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
39 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
40#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
41 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
42#define FUNCTION_PASS(NAME, CREATE_PASS) \
43 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
44#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
45 ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS)
46#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
47 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
48#define LOOP_PASS(NAME, CREATE_PASS) \
49 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
50#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
51 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
52#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
53 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
54#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
55 PARAMS) \
56 ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS)
57#include GET_PASS_REGISTRY
58#undef MODULE_ANALYSIS
59#undef MODULE_PASS
60#undef MODULE_PASS_WITH_PARAMS
61#undef FUNCTION_ANALYSIS
62#undef FUNCTION_ALIAS_ANALYSIS
63#undef FUNCTION_PASS
64#undef FUNCTION_PASS_WITH_PARAMS
65#undef LOOP_ANALYSIS
66#undef LOOP_PASS
67#undef MACHINE_FUNCTION_ANALYSIS
68#undef MACHINE_FUNCTION_PASS
69#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
70#undef ADD_CLASS_PASS_TO_PASS_NAME
71#undef ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS
72}
73
74#define ADD_PASS(NAME, CREATE_PASS) \
75 if (Name == NAME) { \
76 PM.addPass(CREATE_PASS); \
77 return true; \
78 }
79
80#define ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER) \
81 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
82 auto Params = PassBuilder::parsePassParameters(PARSER, Name, NAME); \
83 if (!Params) { \
84 errs() << NAME ": " << toString(Params.takeError()) << '\n'; \
85 return false; \
86 } \
87 PM.addPass(CREATE_PASS(Params.get())); \
88 return true; \
89 }
90
91PB.registerPipelineParsingCallback([=](StringRef Name, ModulePassManager &PM,
92 ArrayRef<PassBuilder::PipelineElement>) {
93#define MODULE_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
94#include GET_PASS_REGISTRY
95#undef MODULE_PASS
96 return false;
97});
98
99PB.registerPipelineParsingCallback([=](StringRef Name, ModulePassManager &PM,
100 ArrayRef<PassBuilder::PipelineElement>) {
101#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
102 ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
103#include GET_PASS_REGISTRY
104#undef MODULE_PASS_WITH_PARAMS
105 return false;
106});
107
108PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM,
109 ArrayRef<PassBuilder::PipelineElement>) {
110#define FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
111#include GET_PASS_REGISTRY
112#undef FUNCTION_PASS
113 return false;
114});
115
116PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM,
117 ArrayRef<PassBuilder::PipelineElement>) {
118#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
119 ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
120#include GET_PASS_REGISTRY
121#undef FUNCTION_PASS_WITH_PARAMS
122 return false;
123});
124
125PB.registerPipelineParsingCallback([=](StringRef Name, LoopPassManager &PM,
126 ArrayRef<PassBuilder::PipelineElement>) {
127#define LOOP_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
128#include GET_PASS_REGISTRY
129 return false;
130});
131
132PB.registerPipelineParsingCallback([=](StringRef Name,
133 MachineFunctionPassManager &PM,
134 ArrayRef<PassBuilder::PipelineElement>) {
135#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
136#include GET_PASS_REGISTRY
137 return false;
138});
139
140PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM,
141 ArrayRef<PassBuilder::PipelineElement>) {
142#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
143 PARAMS) \
144 ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
145#include GET_PASS_REGISTRY
146#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
147 return false;
148});
149
150#undef ADD_PASS
151#undef ADD_PASS_WITH_PARAMS
152
153PB.registerAnalysisRegistrationCallback([](ModuleAnalysisManager &AM) {
154#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
155 AM.registerPass([&] { return CREATE_PASS; });
156#include GET_PASS_REGISTRY
157#undef MODULE_ANALYSIS
158});
159
160PB.registerAnalysisRegistrationCallback([](FunctionAnalysisManager &AM) {
161#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
162 AM.registerPass([&] { return CREATE_PASS; });
163#include GET_PASS_REGISTRY
164#undef FUNCTION_ANALYSIS
165});
166
167PB.registerParseAACallback([](StringRef Name, AAManager &AM) {
168#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
169 if (Name == NAME) { \
170 AM.registerFunctionAnalysis< \
171 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
172 return true; \
173 }
174#include GET_PASS_REGISTRY
175#undef FUNCTION_ALIAS_ANALYSIS
176 return false;
177});
178
179PB.registerAnalysisRegistrationCallback([](LoopAnalysisManager &AM) {
180#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
181 AM.registerPass([&] { return CREATE_PASS; });
182#include GET_PASS_REGISTRY
183#undef LOOP_ANALYSIS
184});
185
186PB.registerAnalysisRegistrationCallback([](MachineFunctionAnalysisManager &AM) {
187#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
188 AM.registerPass([&] { return CREATE_PASS; });
189#include GET_PASS_REGISTRY
190#undef MACHINE_FUNCTION_ANALYSIS
191});
192
193#undef GET_PASS_REGISTRY
194#endif // GET_PASS_REGISTRY
Name
std::string Name
Definition: ELFObjHandler.cpp:77
PIC
PassInstrumentationCallbacks PIC
Definition: PassBuilderBindings.cpp:55
PB
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
Generated on Sat Apr 27 2024 00:38:38 for LLVM by doxygen 1.9.6