Skip to content

Commit f86cc24

Browse files
paperchalicepaperchalice
committed
always add callbacks
1 parent 902b09c commit f86cc24

File tree

1 file changed

+51
-193
lines changed

1 file changed

+51
-193
lines changed

‎llvm/include/llvm/Passes/TargetPassRegistry.inc

Lines changed: 51 additions & 193 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,9 @@
77
//===----------------------------------------------------------------------===//
88
//
99
// 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"
1013
//
1114
//===----------------------------------------------------------------------===//
1215

@@ -18,123 +21,8 @@
1821
#error "must provide <Target>PassRegistry.def"
1922
#endif
2023

21-
{
22-
23-
// FIXME: use std::size when MSVC_MIN >= 19.30
24-
25-
static constexpr bool HAVE_MODULE_ANALYSIS_ =
26-
std::array{
27-
"",
28-
#define MODULE_ANALYSIS(NAME, CREATE_PASS) NAME,
29-
#include GET_PASS_REGISTRY
30-
#undef MODULE_ANALYSIS
31-
}
32-
.size() > 1;
33-
34-
static constexpr bool HAVE_MODULE_PASS_ =
35-
std::array{
36-
"",
37-
#define MODULE_PASS(NAME, CREATE_PASS) NAME,
38-
#include GET_PASS_REGISTRY
39-
#undef MODULE_PASS
40-
}
41-
.size() > 1;
42-
43-
static constexpr bool HAVE_MODULE_PASS_WITH_PARAMS_ =
44-
std::array{
45-
"",
46-
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) NAME,
47-
#include GET_PASS_REGISTRY
48-
#undef MODULE_PASS_WITH_PARAMS
49-
}
50-
.size() > 1;
51-
52-
static constexpr bool HAVE_FUNCTION_ANALYSIS_ =
53-
std::array{
54-
"",
55-
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) NAME,
56-
#include GET_PASS_REGISTRY
57-
#undef FUNCTION_ANALYSIS
58-
}
59-
.size() > 1;
60-
61-
static constexpr bool HAVE_FUNCTION_ALIAS_ANALYSIS_ =
62-
std::array{
63-
"",
64-
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) NAME,
65-
#include GET_PASS_REGISTRY
66-
#undef FUNCTION_ALIAS_ANALYSIS
67-
}
68-
.size() > 1;
69-
70-
static constexpr bool HAVE_FUNCTION_PASS_ =
71-
std::array{
72-
"",
73-
#define FUNCTION_PASS(NAME, CREATE_PASS) NAME,
74-
#include GET_PASS_REGISTRY
75-
#undef FUNCTION_PASS
76-
}
77-
.size() > 1;
78-
79-
static constexpr bool HAVE_FUNCTION_PASS_WITH_PARAMS_ =
80-
std::array{
81-
"",
82-
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
83-
NAME,
84-
#include GET_PASS_REGISTRY
85-
#undef FUNCTION_PASS_WITH_PARAMS
86-
}
87-
.size() > 1;
88-
89-
static constexpr bool HAVE_LOOP_ANALYSIS_ =
90-
std::array{
91-
"",
92-
#define LOOP_ANALYSIS(NAME, CREATE_PASS) NAME,
93-
#include GET_PASS_REGISTRY
94-
#undef LOOP_ANALYSIS
95-
}
96-
.size() > 1;
97-
98-
static constexpr bool HAVE_LOOP_PASS_ =
99-
std::array{
100-
"",
101-
#define LOOP_PASS(NAME, CREATE_PASS) NAME,
102-
#include GET_PASS_REGISTRY
103-
#undef LOOP_PASS
104-
}
105-
.size() > 1;
106-
107-
static constexpr bool HAVE_MACHINE_FUNCTION_ANALYSIS_ =
108-
std::array{
109-
"",
110-
#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) NAME,
111-
#include GET_PASS_REGISTRY
112-
#undef MACHINE_FUNCTION_ANALYSIS
113-
}
114-
.size() > 1;
115-
116-
static constexpr bool HAVE_MACHINE_FUNCTION_PASS_ =
117-
std::array{
118-
"",
119-
#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) NAME,
120-
#include GET_PASS_REGISTRY
121-
#undef MACHINE_FUNCTION_PASS
122-
}
123-
.size() > 1;
124-
125-
static constexpr bool HAVE_MACHINE_FUNCTION_PASS_WITH_PARAMS_ =
126-
std::array{
127-
"",
128-
#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
129-
PARAMS) \
130-
NAME,
131-
#include GET_PASS_REGISTRY
132-
#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
133-
}
134-
.size() > 1;
135-
136-
if (PopulateClassToPassNames) {
137-
auto *PIC = PB.getPassInstrumentationCallbacks();
24+
if (PopulateClassToPassNames) {
25+
auto *PIC = PB.getPassInstrumentationCallbacks();
13826

13927
#define ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) \
14028
PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
@@ -165,12 +53,13 @@
16553
ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
16654
#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
16755
PARAMS) \
168-
ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CREATE_PASS)
56+
ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS)
16957
#include GET_PASS_REGISTRY
17058
#undef MODULE_ANALYSIS
17159
#undef MODULE_PASS
17260
#undef MODULE_PASS_WITH_PARAMS
17361
#undef FUNCTION_ANALYSIS
62+
#undef FUNCTION_ALIAS_ANALYSIS
17463
#undef FUNCTION_PASS
17564
#undef FUNCTION_PASS_WITH_PARAMS
17665
#undef LOOP_ANALYSIS
@@ -180,7 +69,7 @@
18069
#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
18170
#undef ADD_CLASS_PASS_TO_PASS_NAME
18271
#undef ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS
183-
}
72+
}
18473

18574
#define ADD_PASS(NAME, CREATE_PASS) \
18675
if (Name == NAME) { \
@@ -197,138 +86,107 @@
19786
return true; \
19887
}
19988

200-
if constexpr (HAVE_MODULE_PASS_) {
201-
PB.registerPipelineParsingCallback(
202-
[=](StringRef Name, ModulePassManager &PM,
203-
ArrayRef<PassBuilder::PipelineElement>) {
89+
PB.registerPipelineParsingCallback([=](StringRef Name, ModulePassManager &PM,
90+
ArrayRef<PassBuilder::PipelineElement>) {
20491
#define MODULE_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
20592
#include GET_PASS_REGISTRY
20693
#undef MODULE_PASS
207-
return false;
208-
});
209-
}
94+
return false;
95+
});
21096

211-
if constexpr (HAVE_MODULE_PASS_WITH_PARAMS_) {
212-
PB.registerPipelineParsingCallback(
213-
[=](StringRef Name, ModulePassManager &PM,
214-
ArrayRef<PassBuilder::PipelineElement>) {
97+
PB.registerPipelineParsingCallback([=](StringRef Name, ModulePassManager &PM,
98+
ArrayRef<PassBuilder::PipelineElement>) {
21599
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
216100
ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
217101
#include GET_PASS_REGISTRY
218102
#undef MODULE_PASS_WITH_PARAMS
219-
return false;
220-
});
221-
}
103+
return false;
104+
});
222105

223-
if constexpr (HAVE_FUNCTION_PASS_) {
224-
PB.registerPipelineParsingCallback(
225-
[=](StringRef Name, FunctionPassManager &PM,
226-
ArrayRef<PassBuilder::PipelineElement>) {
106+
PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM,
107+
ArrayRef<PassBuilder::PipelineElement>) {
227108
#define FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
228109
#include GET_PASS_REGISTRY
229110
#undef FUNCTION_PASS
230-
return false;
231-
});
232-
}
111+
return false;
112+
});
233113

234-
if constexpr (HAVE_FUNCTION_PASS_WITH_PARAMS_) {
235-
PB.registerPipelineParsingCallback(
236-
[=](StringRef Name, FunctionPassManager &PM,
237-
ArrayRef<PassBuilder::PipelineElement>) {
114+
PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM,
115+
ArrayRef<PassBuilder::PipelineElement>) {
238116
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
239117
ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
240118
#include GET_PASS_REGISTRY
241119
#undef FUNCTION_PASS_WITH_PARAMS
242-
return false;
243-
});
244-
}
120+
return false;
121+
});
245122

246-
if constexpr (HAVE_LOOP_PASS_) {
247-
PB.registerPipelineParsingCallback(
248-
[=](StringRef Name, LoopPassManager &PM,
249-
ArrayRef<PassBuilder::PipelineElement>) {
123+
PB.registerPipelineParsingCallback([=](StringRef Name, LoopPassManager &PM,
124+
ArrayRef<PassBuilder::PipelineElement>) {
250125
#define LOOP_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
251126
#include GET_PASS_REGISTRY
252-
return false;
253-
});
254-
}
127+
return false;
128+
});
255129

256-
if constexpr (HAVE_MACHINE_FUNCTION_PASS_) {
257-
PB.registerPipelineParsingCallback(
258-
[=](StringRef Name, MachineFunctionPassManager &PM,
259-
ArrayRef<PassBuilder::PipelineElement>) {
130+
PB.registerPipelineParsingCallback([=](StringRef Name,
131+
MachineFunctionPassManager &PM,
132+
ArrayRef<PassBuilder::PipelineElement>) {
260133
#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
261134
#include GET_PASS_REGISTRY
262-
return false;
263-
});
264-
}
135+
return false;
136+
});
265137

266-
if constexpr (HAVE_MACHINE_FUNCTION_PASS_WITH_PARAMS_) {
267-
PB.registerPipelineParsingCallback(
268-
[=](StringRef Name, FunctionPassManager &PM,
269-
ArrayRef<PassBuilder::PipelineElement>) {
138+
PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM,
139+
ArrayRef<PassBuilder::PipelineElement>) {
270140
#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
271141
PARAMS) \
272142
ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
273143
#include GET_PASS_REGISTRY
274144
#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
275-
return false;
276-
});
277-
}
145+
return false;
146+
});
147+
278148
#undef ADD_PASS
279149
#undef ADD_PASS_WITH_PARAMS
280150

281-
if constexpr (HAVE_MODULE_ANALYSIS_) {
282-
PB.registerAnalysisRegistrationCallback([](ModuleAnalysisManager &AM) {
151+
PB.registerAnalysisRegistrationCallback([](ModuleAnalysisManager &AM) {
283152
#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
284153
AM.registerPass([&] { return CREATE_PASS; });
285154
#include GET_PASS_REGISTRY
286155
#undef MODULE_ANALYSIS
287-
});
288-
}
156+
});
289157

290-
if constexpr (HAVE_FUNCTION_ANALYSIS_) {
291-
PB.registerAnalysisRegistrationCallback([](FunctionAnalysisManager &AM) {
158+
PB.registerAnalysisRegistrationCallback([](FunctionAnalysisManager &AM) {
292159
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
293160
AM.registerPass([&] { return CREATE_PASS; });
294161
#include GET_PASS_REGISTRY
295162
#undef FUNCTION_ANALYSIS
296-
});
297-
}
163+
});
298164

299-
if constexpr (HAVE_FUNCTION_ALIAS_ANALYSIS_) {
300-
PB.registerParseAACallback([](StringRef Name, AAManager &AM) {
301-
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
165+
PB.registerParseAACallback([](StringRef Name, AAManager &AM) {
166+
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
302167
if (Name == NAME) { \
303168
AM.registerFunctionAnalysis< \
304169
std::remove_reference_t<decltype(CREATE_PASS)>>(); \
305170
return true; \
306171
}
307172
#include GET_PASS_REGISTRY
308-
#undef FUNCTION_ANALYSIS
309-
return false;
310-
});
311-
}
173+
#undef FUNCTION_ALIAS_ANALYSIS
174+
return false;
175+
});
312176

313-
if constexpr (HAVE_LOOP_ANALYSIS_) {
314-
PB.registerAnalysisRegistrationCallback([](LoopAnalysisManager &AM) {
177+
PB.registerAnalysisRegistrationCallback([](LoopAnalysisManager &AM) {
315178
#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
316179
AM.registerPass([&] { return CREATE_PASS; });
317180
#include GET_PASS_REGISTRY
318181
#undef LOOP_ANALYSIS
319-
});
320-
}
182+
});
321183

322-
if constexpr (HAVE_MACHINE_FUNCTION_ANALYSIS_) {
323-
PB.registerAnalysisRegistrationCallback(
324-
[](MachineFunctionAnalysisManager &AM) {
184+
PB.registerAnalysisRegistrationCallback([](MachineFunctionAnalysisManager &AM) {
325185
#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
326186
AM.registerPass([&] { return CREATE_PASS; });
327187
#include GET_PASS_REGISTRY
328188
#undef MACHINE_FUNCTION_ANALYSIS
329-
});
330-
}
331-
}
189+
});
332190

333191
#undef GET_PASS_REGISTRY
334192
#endif // GET_PASS_REGISTRY

0 commit comments

Comments
 (0)