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 | |
24 | if (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 | |
91 | PB.registerPipelineParsingCallback(C: [=](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 | |
99 | PB.registerPipelineParsingCallback(C: [=](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 | |
108 | PB.registerPipelineParsingCallback(C: [=](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 | |
116 | PB.registerPipelineParsingCallback(C: [=](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 | |
125 | PB.registerPipelineParsingCallback(C: [=](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 | |
132 | PB.registerPipelineParsingCallback(C: [=](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 | |
140 | PB.registerPipelineParsingCallback(C: [=](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 | |
153 | PB.registerAnalysisRegistrationCallback(C: [](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 | |
160 | PB.registerAnalysisRegistrationCallback(C: [](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 | |
167 | PB.registerParseAACallback(C: [](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 | |
179 | PB.registerAnalysisRegistrationCallback(C: [](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 | |
186 | PB.registerAnalysisRegistrationCallback(C: [](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 |
195 | |