Skip to content

Commit c7a2423

Browse files
paperchalicepaperchalice
committed
always add callbacks
1 parent 12edbe2 commit c7a2423

File tree

1 file changed

+48
-191
lines changed

1 file changed

+48
-191
lines changed

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

Lines changed: 48 additions & 191 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,7 +53,7 @@
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
@@ -180,7 +68,7 @@
18068
#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
18169
#undef ADD_CLASS_PASS_TO_PASS_NAME
18270
#undef ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS
183-
}
71+
}
18472

18573
#define ADD_PASS(NAME, CREATE_PASS) \
18674
if (Name == NAME) { \
@@ -197,107 +85,83 @@
19785
return true; \
19886
}
19987

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

211-
if constexpr (HAVE_MODULE_PASS_WITH_PARAMS_) {
212-
PB.registerPipelineParsingCallback(
213-
[=](StringRef Name, ModulePassManager &PM,
214-
ArrayRef<PassBuilder::PipelineElement>) {
96+
PB.registerPipelineParsingCallback([=](StringRef Name, ModulePassManager &PM,
97+
ArrayRef<PassBuilder::PipelineElement>) {
21598
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
21699
ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
217100
#include GET_PASS_REGISTRY
218101
#undef MODULE_PASS_WITH_PARAMS
219-
return false;
220-
});
221-
}
102+
return false;
103+
});
222104

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

234-
if constexpr (HAVE_FUNCTION_PASS_WITH_PARAMS_) {
235-
PB.registerPipelineParsingCallback(
236-
[=](StringRef Name, FunctionPassManager &PM,
237-
ArrayRef<PassBuilder::PipelineElement>) {
113+
PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM,
114+
ArrayRef<PassBuilder::PipelineElement>) {
238115
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
239116
ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
240117
#include GET_PASS_REGISTRY
241118
#undef FUNCTION_PASS_WITH_PARAMS
242-
return false;
243-
});
244-
}
119+
return false;
120+
});
245121

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

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

266-
if constexpr (HAVE_MACHINE_FUNCTION_PASS_WITH_PARAMS_) {
267-
PB.registerPipelineParsingCallback(
268-
[=](StringRef Name, FunctionPassManager &PM,
269-
ArrayRef<PassBuilder::PipelineElement>) {
137+
PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM,
138+
ArrayRef<PassBuilder::PipelineElement>) {
270139
#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
271140
PARAMS) \
272141
ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
273142
#include GET_PASS_REGISTRY
274143
#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
275-
return false;
276-
});
277-
}
144+
return false;
145+
});
146+
278147
#undef ADD_PASS
279148
#undef ADD_PASS_WITH_PARAMS
280149

281-
if constexpr (HAVE_MODULE_ANALYSIS_) {
282-
PB.registerAnalysisRegistrationCallback([](ModuleAnalysisManager &AM) {
150+
PB.registerAnalysisRegistrationCallback([](ModuleAnalysisManager &AM) {
283151
#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
284152
AM.registerPass([&] { return CREATE_PASS; });
285153
#include GET_PASS_REGISTRY
286154
#undef MODULE_ANALYSIS
287-
});
288-
}
155+
});
289156

290-
if constexpr (HAVE_FUNCTION_ANALYSIS_) {
291-
PB.registerAnalysisRegistrationCallback([](FunctionAnalysisManager &AM) {
157+
PB.registerAnalysisRegistrationCallback([](FunctionAnalysisManager &AM) {
292158
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
293159
AM.registerPass([&] { return CREATE_PASS; });
294160
#include GET_PASS_REGISTRY
295161
#undef FUNCTION_ANALYSIS
296-
});
297-
}
162+
});
298163

299-
if constexpr (HAVE_FUNCTION_ALIAS_ANALYSIS_) {
300-
PB.registerParseAACallback([](StringRef Name, AAManager &AM) {
164+
PB.registerParseAACallback([](StringRef Name, AAManager &AM) {
301165
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
302166
if (Name == NAME) { \
303167
AM.registerFunctionAnalysis< \
@@ -306,29 +170,22 @@
306170
}
307171
#include GET_PASS_REGISTRY
308172
#undef FUNCTION_ANALYSIS
309-
return false;
310-
});
311-
}
173+
return false;
174+
});
312175

313-
if constexpr (HAVE_LOOP_ANALYSIS_) {
314-
PB.registerAnalysisRegistrationCallback([](LoopAnalysisManager &AM) {
176+
PB.registerAnalysisRegistrationCallback([](LoopAnalysisManager &AM) {
315177
#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
316178
AM.registerPass([&] { return CREATE_PASS; });
317179
#include GET_PASS_REGISTRY
318180
#undef LOOP_ANALYSIS
319-
});
320-
}
181+
});
321182

322-
if constexpr (HAVE_MACHINE_FUNCTION_ANALYSIS_) {
323-
PB.registerAnalysisRegistrationCallback(
324-
[](MachineFunctionAnalysisManager &AM) {
183+
PB.registerAnalysisRegistrationCallback([](MachineFunctionAnalysisManager &AM) {
325184
#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
326185
AM.registerPass([&] { return CREATE_PASS; });
327186
#include GET_PASS_REGISTRY
328187
#undef MACHINE_FUNCTION_ANALYSIS
329-
});
330-
}
331-
}
188+
});
332189

333190
#undef GET_PASS_REGISTRY
334191
#endif // GET_PASS_REGISTRY

0 commit comments

Comments
 (0)