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
24auto *PIC = PB.getPassInstrumentationCallbacks();
25if (PIC) {
26 PIC->registerClassToPassNameCallback(C: [this, PIC]() {
27 // MSVC requires this to be captured if it's used inside decltype.
28 // Other compilers consider it an unused lambda capture.
29 (void)this;
30#define ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) \
31 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
32#define ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS) \
33 PIC->addClassToPassName(CLASS, NAME);
34
35#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
36 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
37#define MODULE_PASS(NAME, CREATE_PASS) \
38 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
39#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
40 ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS)
41#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
42 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
43#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
44 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
45#define FUNCTION_PASS(NAME, CREATE_PASS) \
46 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
47#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
48 ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS)
49#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
50 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
51#define LOOP_PASS(NAME, CREATE_PASS) \
52 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
53#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
54 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
55#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
56 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
57#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
58 PARAMS) \
59 ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS)
60#include GET_PASS_REGISTRY
61#undef MODULE_ANALYSIS
62#undef MODULE_PASS
63#undef MODULE_PASS_WITH_PARAMS
64#undef FUNCTION_ANALYSIS
65#undef FUNCTION_ALIAS_ANALYSIS
66#undef FUNCTION_PASS
67#undef FUNCTION_PASS_WITH_PARAMS
68#undef LOOP_ANALYSIS
69#undef LOOP_PASS
70#undef MACHINE_FUNCTION_ANALYSIS
71#undef MACHINE_FUNCTION_PASS
72#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
73#undef ADD_CLASS_PASS_TO_PASS_NAME
74#undef ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS
75 });
76}
77
78#define ADD_PASS(NAME, CREATE_PASS) \
79 if (Name == NAME) { \
80 PM.addPass(CREATE_PASS); \
81 return true; \
82 }
83
84#define ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER) \
85 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
86 auto Params = PassBuilder::parsePassParameters(PARSER, Name, NAME); \
87 if (!Params) { \
88 errs() << NAME ": " << toString(Params.takeError()) << '\n'; \
89 return false; \
90 } \
91 PM.addPass(CREATE_PASS(Params.get())); \
92 return true; \
93 }
94
95PB.registerPipelineParsingCallback(C: [=](StringRef Name, ModulePassManager &PM,
96 ArrayRef<PassBuilder::PipelineElement>) {
97#define MODULE_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
98#include GET_PASS_REGISTRY
99#undef MODULE_PASS
100 return false;
101});
102
103PB.registerPipelineParsingCallback(C: [=](StringRef Name, ModulePassManager &PM,
104 ArrayRef<PassBuilder::PipelineElement>) {
105#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
106 ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
107#include GET_PASS_REGISTRY
108#undef MODULE_PASS_WITH_PARAMS
109 return false;
110});
111
112PB.registerPipelineParsingCallback(C: [=](StringRef Name, FunctionPassManager &PM,
113 ArrayRef<PassBuilder::PipelineElement>) {
114#define FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
115#include GET_PASS_REGISTRY
116#undef FUNCTION_PASS
117 return false;
118});
119
120PB.registerPipelineParsingCallback(C: [=](StringRef Name, FunctionPassManager &PM,
121 ArrayRef<PassBuilder::PipelineElement>) {
122#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
123 ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
124#include GET_PASS_REGISTRY
125#undef FUNCTION_PASS_WITH_PARAMS
126 return false;
127});
128
129PB.registerPipelineParsingCallback(C: [=](StringRef Name, LoopPassManager &PM,
130 ArrayRef<PassBuilder::PipelineElement>) {
131#define LOOP_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
132#include GET_PASS_REGISTRY
133 return false;
134});
135
136PB.registerPipelineParsingCallback(C: [=](StringRef Name,
137 MachineFunctionPassManager &PM,
138 ArrayRef<PassBuilder::PipelineElement>) {
139#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
140#include GET_PASS_REGISTRY
141 return false;
142});
143
144PB.registerPipelineParsingCallback(C: [=](StringRef Name, FunctionPassManager &PM,
145 ArrayRef<PassBuilder::PipelineElement>) {
146#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
147 PARAMS) \
148 ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
149#include GET_PASS_REGISTRY
150#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
151 return false;
152});
153
154#undef ADD_PASS
155#undef ADD_PASS_WITH_PARAMS
156
157PB.registerAnalysisRegistrationCallback(C: [](ModuleAnalysisManager &AM) {
158#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
159 AM.registerPass([&] { return CREATE_PASS; });
160#include GET_PASS_REGISTRY
161#undef MODULE_ANALYSIS
162});
163
164PB.registerAnalysisRegistrationCallback(C: [](FunctionAnalysisManager &AM) {
165#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
166 AM.registerPass([&] { return CREATE_PASS; });
167#include GET_PASS_REGISTRY
168#undef FUNCTION_ANALYSIS
169});
170
171PB.registerParseAACallback(C: [](StringRef Name, AAManager &AM) {
172#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
173 if (Name == NAME) { \
174 AM.registerFunctionAnalysis< \
175 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
176 return true; \
177 }
178#include GET_PASS_REGISTRY
179#undef FUNCTION_ALIAS_ANALYSIS
180 return false;
181});
182
183PB.registerAnalysisRegistrationCallback(C: [](LoopAnalysisManager &AM) {
184#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
185 AM.registerPass([&] { return CREATE_PASS; });
186#include GET_PASS_REGISTRY
187#undef LOOP_ANALYSIS
188});
189
190PB.registerAnalysisRegistrationCallback(
191 C: [=](MachineFunctionAnalysisManager &AM) {
192#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
193 AM.registerPass([&] { return CREATE_PASS; });
194#include GET_PASS_REGISTRY
195#undef MACHINE_FUNCTION_ANALYSIS
196 });
197
198#undef GET_PASS_REGISTRY
199#endif // GET_PASS_REGISTRY
200