Skip to content

Commit 0a98ff8

Browse files
paperchalicepaperchalice
committed
[AArch64] Add AArch64PassRegistry.def
1 parent 5a3cc7b commit 0a98ff8

File tree

4 files changed

+2063
-0
lines changed

4 files changed

+2063
-0
lines changed

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

Lines changed: 304 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,304 @@
1+
//===- TargetPassRegistry.def - 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+
//
11+
//===----------------------------------------------------------------------===//
12+
13+
// NOTE: NO INCLUDE GUARD DESIRED!
14+
15+
#ifdef GET_PASS_REGISTRY
16+
17+
#if !__has_include(GET_PASS_REGISTRY)
18+
#error "must provide <Target>PassRegistry.def"
19+
#endif
20+
21+
static constexpr bool HAVE_MODULE_ANALYSIS_ = std::size({
22+
"",
23+
#define MODULE_ANALYSIS(NAME, CREATE_PASS) NAME,
24+
#include GET_PASS_REGISTRY
25+
#undef MODULE_ANALYSIS
26+
}) > 1;
27+
28+
static constexpr bool HAVE_MODULE_PASS_ = std::size({
29+
"",
30+
#define MODULE_PASS(NAME, CREATE_PASS) NAME,
31+
#include GET_PASS_REGISTRY
32+
#undef MODULE_PASS
33+
}) > 1;
34+
35+
static constexpr bool HAVE_MODULE_PASS_WITH_PARAMS_ = std::size({
36+
"",
37+
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) NAME,
38+
#include GET_PASS_REGISTRY
39+
#undef MODULE_PASS_WITH_PARAMS
40+
}) > 1;
41+
42+
static constexpr bool HAVE_FUNCTION_ANALYSIS_ = std::size({
43+
"",
44+
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) NAME,
45+
#include GET_PASS_REGISTRY
46+
#undef FUNCTION_ANALYSIS
47+
}) > 1;
48+
49+
static constexpr bool HAVE_FUNCTION_ALIAS_ANALYSIS_ = std::size({
50+
"",
51+
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) NAME,
52+
#include GET_PASS_REGISTRY
53+
#undef FUNCTION_ALIAS_ANALYSIS
54+
}) > 1;
55+
56+
static constexpr bool HAVE_FUNCTION_PASS_ = std::size({
57+
"",
58+
#define FUNCTION_PASS(NAME, CREATE_PASS) NAME,
59+
#include GET_PASS_REGISTRY
60+
#undef FUNCTION_PASS
61+
}) > 1;
62+
63+
static constexpr bool HAVE_FUNCTION_PASS_WITH_PARAMS_ = std::size({
64+
"",
65+
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
66+
NAME,
67+
#include GET_PASS_REGISTRY
68+
#undef FUNCTION_PASS_WITH_PARAMS
69+
}) > 1;
70+
71+
static constexpr bool HAVE_LOOP_ANALYSIS_ = std::size({
72+
"",
73+
#define LOOP_ANALYSIS(NAME, CREATE_PASS) NAME,
74+
#include GET_PASS_REGISTRY
75+
#undef LOOP_ANALYSIS
76+
}) > 1;
77+
78+
static constexpr bool HAVE_LOOP_PASS_ = std::size({
79+
"",
80+
#define LOOP_PASS(NAME, CREATE_PASS) NAME,
81+
#include GET_PASS_REGISTRY
82+
#undef LOOP_PASS
83+
}) > 1;
84+
85+
static constexpr bool HAVE_MACHINE_FUNCTION_ANALYSIS_ = std::size({
86+
"",
87+
#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) NAME,
88+
#include GET_PASS_REGISTRY
89+
#undef MACHINE_FUNCTION_ANALYSIS
90+
}) > 1;
91+
92+
static constexpr bool HAVE_MACHINE_FUNCTION_PASS_ = std::size({
93+
"",
94+
#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) NAME,
95+
#include GET_PASS_REGISTRY
96+
#undef MACHINE_FUNCTION_PASS
97+
}) > 1;
98+
99+
static constexpr bool HAVE_MACHINE_FUNCTION_PASS_WITH_PARAMS_ = std::size({
100+
"",
101+
#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
102+
PARAMS) \
103+
NAME,
104+
#include GET_PASS_REGISTRY
105+
#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
106+
}) > 1;
107+
108+
if (PopulateClassToPassNames) {
109+
auto *PIC = PB.getPassInstrumentationCallbacks();
110+
111+
#define ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) \
112+
PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
113+
#define ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS) \
114+
PIC->addClassToPassName(CLASS, NAME);
115+
116+
#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
117+
ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
118+
#define MODULE_PASS(NAME, CREATE_PASS) \
119+
ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
120+
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
121+
ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS)
122+
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
123+
ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
124+
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
125+
ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
126+
#define FUNCTION_PASS(NAME, CREATE_PASS) \
127+
ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
128+
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
129+
ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS)
130+
#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
131+
ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
132+
#define LOOP_PASS(NAME, CREATE_PASS) \
133+
ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
134+
#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
135+
ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
136+
#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
137+
ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS)
138+
#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
139+
PARAMS) \
140+
ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CREATE_PASS)
141+
#include GET_PASS_REGISTRY
142+
#undef MODULE_ANALYSIS
143+
#undef MODULE_PASS
144+
#undef MODULE_PASS_WITH_PARAMS
145+
#undef FUNCTION_ANALYSIS
146+
#undef FUNCTION_PASS
147+
#undef FUNCTION_PASS_WITH_PARAMS
148+
#undef LOOP_ANALYSIS
149+
#undef LOOP_PASS
150+
#undef MACHINE_FUNCTION_ANALYSIS
151+
#undef MACHINE_FUNCTION_PASS
152+
#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
153+
#undef ADD_CLASS_PASS_TO_PASS_NAME
154+
#undef ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS
155+
}
156+
157+
#define ADD_PASS(NAME, CREATE_PASS) \
158+
if (Name == NAME) { \
159+
PM.addPass(CREATE_PASS); \
160+
return true; \
161+
}
162+
163+
#define ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER) \
164+
if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
165+
auto Params = PassBuilder::parsePassParameters(PARSER, Name, NAME); \
166+
if (!Params) \
167+
return false; \
168+
PM.addPass(CREATE_PASS(Params.get())); \
169+
return true; \
170+
}
171+
172+
if constexpr (HAVE_MODULE_PASS_) {
173+
PB.registerPipelineParsingCallback(
174+
[=](StringRef Name, ModulePassManager &PM,
175+
ArrayRef<PassBuilder::PipelineElement>) {
176+
#define MODULE_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
177+
#include GET_PASS_REGISTRY
178+
#undef MODULE_PASS
179+
return false;
180+
});
181+
}
182+
183+
if constexpr (HAVE_MODULE_PASS_WITH_PARAMS_) {
184+
PB.registerPipelineParsingCallback(
185+
[=](StringRef Name, ModulePassManager &PM,
186+
ArrayRef<PassBuilder::PipelineElement>) {
187+
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
188+
ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
189+
#include GET_PASS_REGISTRY
190+
#undef MODULE_PASS_WITH_PARAMS
191+
return false;
192+
});
193+
}
194+
195+
if constexpr (HAVE_FUNCTION_PASS_) {
196+
PB.registerPipelineParsingCallback(
197+
[=](StringRef Name, FunctionPassManager &PM,
198+
ArrayRef<PassBuilder::PipelineElement>) {
199+
#define FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
200+
#include GET_PASS_REGISTRY
201+
#undef FUNCTION_PASS
202+
return false;
203+
});
204+
}
205+
206+
if constexpr (HAVE_FUNCTION_PASS_WITH_PARAMS_) {
207+
PB.registerPipelineParsingCallback(
208+
[=](StringRef Name, FunctionPassManager &PM,
209+
ArrayRef<PassBuilder::PipelineElement>) {
210+
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
211+
ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
212+
#include GET_PASS_REGISTRY
213+
#undef FUNCTION_PASS_WITH_PARAMS
214+
return false;
215+
});
216+
}
217+
218+
if constexpr (HAVE_LOOP_PASS_) {
219+
PB.registerPipelineParsingCallback(
220+
[=](StringRef Name, LoopPassManager &PM,
221+
ArrayRef<PassBuilder::PipelineElement>) {
222+
#define LOOP_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
223+
#include GET_PASS_REGISTRY
224+
return false;
225+
});
226+
}
227+
228+
if constexpr (HAVE_MACHINE_FUNCTION_PASS_) {
229+
PB.registerPipelineParsingCallback(
230+
[=](StringRef Name, MachineFunctionPassManager &PM,
231+
ArrayRef<PassBuilder::PipelineElement>) {
232+
#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
233+
#include GET_PASS_REGISTRY
234+
return false;
235+
});
236+
}
237+
238+
if constexpr (HAVE_MACHINE_FUNCTION_PASS_WITH_PARAMS_) {
239+
PB.registerPipelineParsingCallback(
240+
[=](StringRef Name, FunctionPassManager &PM,
241+
ArrayRef<PassBuilder::PipelineElement>) {
242+
#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
243+
PARAMS) \
244+
ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
245+
#include GET_PASS_REGISTRY
246+
#undef MACHINE_FUNCTION_PASS_WITH_PARAMS
247+
return false;
248+
});
249+
}
250+
#undef ADD_PASS
251+
#undef ADD_PASS_WITH_PARAMS
252+
253+
if constexpr (HAVE_MODULE_ANALYSIS_) {
254+
PB.registerAnalysisRegistrationCallback([](ModuleAnalysisManager &AM) {
255+
#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
256+
AM.registerPass([&] { return CREATE_PASS; });
257+
#include GET_PASS_REGISTRY
258+
#undef MODULE_ANALYSIS
259+
});
260+
}
261+
262+
if constexpr (HAVE_FUNCTION_ANALYSIS_) {
263+
PB.registerAnalysisRegistrationCallback([](FunctionAnalysisManager &AM) {
264+
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
265+
AM.registerPass([&] { return CREATE_PASS; });
266+
#include GET_PASS_REGISTRY
267+
#undef FUNCTION_ANALYSIS
268+
});
269+
}
270+
271+
if constexpr (HAVE_FUNCTION_ALIAS_ANALYSIS_) {
272+
PB.registerParseAACallback([](StringRef Name, AAManager &AM) {
273+
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
274+
if (Name == NAME) { \
275+
AM.registerFunctionAnalysis< \
276+
std::remove_reference_t<decltype(CREATE_PASS)>>(); \
277+
return true; \
278+
}
279+
#include GET_PASS_REGISTRY
280+
#undef FUNCTION_ANALYSIS
281+
return false;
282+
});
283+
}
284+
285+
if constexpr (HAVE_LOOP_ANALYSIS_) {
286+
PB.registerAnalysisRegistrationCallback([](LoopAnalysisManager &AM) {
287+
#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
288+
AM.registerPass([&] { return CREATE_PASS; });
289+
#include GET_PASS_REGISTRY
290+
#undef LOOP_ANALYSIS
291+
});
292+
}
293+
294+
if constexpr (HAVE_MACHINE_FUNCTION_ANALYSIS_) {
295+
PB.registerAnalysisRegistrationCallback(
296+
[](MachineFunctionAnalysisManager &AM) {
297+
#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
298+
AM.registerPass([&] { return CREATE_PASS; });
299+
#include GET_PASS_REGISTRY
300+
#undef MACHINE_FUNCTION_ANALYSIS
301+
});
302+
}
303+
#undef GET_PASS_REGISTRY
304+
#endif // GET_PASS_REGISTRY

‎llvm/lib/Target/AArch64/AArch64PassRegistry.def

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
//===- AArch64PassRegistry.def - Registry of AArch64 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 that are part of the
10+
// AArch64 backend.
11+
//
12+
//===----------------------------------------------------------------------===//
13+
14+
// NOTE: NO INCLUDE GUARD DESIRED!
15+
16+
#ifndef LOOP_PASS
17+
#define LOOP_PASS(NAME, CREATE_PASS)
18+
#endif
19+
LOOP_PASS("aarch64-lit", AArch64LoopIdiomTransformPass())
20+
#undef LOOP_PASS

‎llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -547,6 +547,10 @@ class AArch64PassConfig : public TargetPassConfig {
547547

548548
void AArch64TargetMachine::registerPassBuilderCallbacks(
549549
PassBuilder &PB, bool PopulateClassToPassNames) {
550+
551+
#define GET_PASS_REGISTRY "AArch64PassRegistry.def"
552+
#include "llvm/Passes/TargetPassRegistry.inc"
553+
550554
PB.registerLateLoopOptimizationsEPCallback(
551555
[=](LoopPassManager &LPM, OptimizationLevel Level) {
552556
LPM.addPass(AArch64LoopIdiomTransformPass());

0 commit comments

Comments
 (0)