1 | //===- llvm/PassSupport.h - Pass Support code -------------------*- 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 defines stuff that is used to define and "use" Passes. This file |
10 | // is automatically #included by Pass.h, so: |
11 | // |
12 | // NO .CPP FILES SHOULD INCLUDE THIS FILE DIRECTLY |
13 | // |
14 | // Instead, #include Pass.h. |
15 | // |
16 | // This file defines Pass registration code and classes used for it. |
17 | // |
18 | //===----------------------------------------------------------------------===// |
19 | |
20 | #if !defined(LLVM_PASS_H) || defined(LLVM_PASSSUPPORT_H) |
21 | #error "Do not include <PassSupport.h>; include <Pass.h> instead" |
22 | #endif |
23 | |
24 | #ifndef LLVM_PASSSUPPORT_H |
25 | #define LLVM_PASSSUPPORT_H |
26 | |
27 | #include "llvm/ADT/StringRef.h" |
28 | #include "llvm/PassInfo.h" |
29 | #include "llvm/PassRegistry.h" |
30 | #include "llvm/Support/Threading.h" |
31 | #include <functional> |
32 | |
33 | namespace llvm { |
34 | |
35 | class Pass; |
36 | |
37 | #define INITIALIZE_PASS(passName, arg, name, cfg, analysis) \ |
38 | static void *initialize##passName##PassOnce(PassRegistry &Registry) { \ |
39 | PassInfo *PI = new PassInfo( \ |
40 | name, arg, &passName::ID, \ |
41 | PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis); \ |
42 | Registry.registerPass(*PI, true); \ |
43 | return PI; \ |
44 | } \ |
45 | static llvm::once_flag Initialize##passName##PassFlag; \ |
46 | void llvm::initialize##passName##Pass(PassRegistry &Registry) { \ |
47 | llvm::call_once(Initialize##passName##PassFlag, \ |
48 | initialize##passName##PassOnce, std::ref(Registry)); \ |
49 | } |
50 | |
51 | #define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis) \ |
52 | static void *initialize##passName##PassOnce(PassRegistry &Registry) { |
53 | |
54 | #define INITIALIZE_PASS_DEPENDENCY(depName) initialize##depName##Pass(Registry); |
55 | #define INITIALIZE_AG_DEPENDENCY(depName) \ |
56 | initialize##depName##AnalysisGroup(Registry); |
57 | |
58 | #define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis) \ |
59 | PassInfo *PI = new PassInfo( \ |
60 | name, arg, &passName::ID, \ |
61 | PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis); \ |
62 | Registry.registerPass(*PI, true); \ |
63 | return PI; \ |
64 | } \ |
65 | static llvm::once_flag Initialize##passName##PassFlag; \ |
66 | void llvm::initialize##passName##Pass(PassRegistry &Registry) { \ |
67 | llvm::call_once(Initialize##passName##PassFlag, \ |
68 | initialize##passName##PassOnce, std::ref(Registry)); \ |
69 | } |
70 | |
71 | #define INITIALIZE_PASS_WITH_OPTIONS(PassName, Arg, Name, Cfg, Analysis) \ |
72 | INITIALIZE_PASS_BEGIN(PassName, Arg, Name, Cfg, Analysis) \ |
73 | PassName::registerOptions(); \ |
74 | INITIALIZE_PASS_END(PassName, Arg, Name, Cfg, Analysis) |
75 | |
76 | #define INITIALIZE_PASS_WITH_OPTIONS_BEGIN(PassName, Arg, Name, Cfg, Analysis) \ |
77 | INITIALIZE_PASS_BEGIN(PassName, Arg, Name, Cfg, Analysis) \ |
78 | PassName::registerOptions(); |
79 | |
80 | template <typename PassName> Pass *callDefaultCtor() { return new PassName(); } |
81 | |
82 | //===--------------------------------------------------------------------------- |
83 | /// RegisterPass<t> template - This template class is used to notify the system |
84 | /// that a Pass is available for use, and registers it into the internal |
85 | /// database maintained by the PassManager. Unless this template is used, opt, |
86 | /// for example will not be able to see the pass and attempts to create the pass |
87 | /// will fail. This template is used in the follow manner (at global scope, in |
88 | /// your .cpp file): |
89 | /// |
90 | /// static RegisterPass<YourPassClassName> tmp("passopt", "My Pass Name"); |
91 | /// |
92 | /// This statement will cause your pass to be created by calling the default |
93 | /// constructor exposed by the pass. |
94 | template <typename passName> struct RegisterPass : public PassInfo { |
95 | // Register Pass using default constructor... |
96 | RegisterPass(StringRef PassArg, StringRef Name, bool CFGOnly = false, |
97 | bool is_analysis = false) |
98 | : PassInfo(Name, PassArg, &passName::ID, |
99 | PassInfo::NormalCtor_t(callDefaultCtor<passName>), CFGOnly, |
100 | is_analysis) { |
101 | PassRegistry::getPassRegistry()->registerPass(*this); |
102 | } |
103 | }; |
104 | |
105 | /// RegisterAnalysisGroup - Register a Pass as a member of an analysis _group_. |
106 | /// Analysis groups are used to define an interface (which need not derive from |
107 | /// Pass) that is required by passes to do their job. Analysis Groups differ |
108 | /// from normal analyses because any available implementation of the group will |
109 | /// be used if it is available. |
110 | /// |
111 | /// If no analysis implementing the interface is available, a default |
112 | /// implementation is created and added. A pass registers itself as the default |
113 | /// implementation by specifying 'true' as the second template argument of this |
114 | /// class. |
115 | /// |
116 | /// In addition to registering itself as an analysis group member, a pass must |
117 | /// register itself normally as well. Passes may be members of multiple groups |
118 | /// and may still be "required" specifically by name. |
119 | /// |
120 | /// The actual interface may also be registered as well (by not specifying the |
121 | /// second template argument). The interface should be registered to associate |
122 | /// a nice name with the interface. |
123 | class RegisterAGBase : public PassInfo { |
124 | public: |
125 | RegisterAGBase(StringRef Name, const void *InterfaceID, |
126 | const void *PassID = nullptr, bool isDefault = false); |
127 | }; |
128 | |
129 | template <typename Interface, bool Default = false> |
130 | struct RegisterAnalysisGroup : public RegisterAGBase { |
131 | explicit RegisterAnalysisGroup(PassInfo &RPB) |
132 | : RegisterAGBase(RPB.getPassName(), &Interface::ID, RPB.getTypeInfo(), |
133 | Default) {} |
134 | |
135 | explicit RegisterAnalysisGroup(const char *Name) |
136 | : RegisterAGBase(Name, &Interface::ID) {} |
137 | }; |
138 | |
139 | #define INITIALIZE_ANALYSIS_GROUP(agName, name, defaultPass) \ |
140 | static void *initialize##agName##AnalysisGroupOnce(PassRegistry &Registry) { \ |
141 | initialize##defaultPass##Pass(Registry); \ |
142 | PassInfo *AI = new PassInfo(name, &agName::ID); \ |
143 | Registry.registerAnalysisGroup(&agName::ID, 0, *AI, false, true); \ |
144 | return AI; \ |
145 | } \ |
146 | static llvm::once_flag Initialize##agName##AnalysisGroupFlag; \ |
147 | void llvm::initialize##agName##AnalysisGroup(PassRegistry &Registry) { \ |
148 | llvm::call_once(Initialize##agName##AnalysisGroupFlag, \ |
149 | initialize##agName##AnalysisGroupOnce, \ |
150 | std::ref(Registry)); \ |
151 | } |
152 | |
153 | #define INITIALIZE_AG_PASS(passName, agName, arg, name, cfg, analysis, def) \ |
154 | static void *initialize##passName##PassOnce(PassRegistry &Registry) { \ |
155 | if (!def) \ |
156 | initialize##agName##AnalysisGroup(Registry); \ |
157 | PassInfo *PI = new PassInfo( \ |
158 | name, arg, &passName::ID, \ |
159 | PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis); \ |
160 | Registry.registerPass(*PI, true); \ |
161 | \ |
162 | PassInfo *AI = new PassInfo(name, &agName::ID); \ |
163 | Registry.registerAnalysisGroup(&agName::ID, &passName::ID, *AI, def, \ |
164 | true); \ |
165 | return AI; \ |
166 | } \ |
167 | static llvm::once_flag Initialize##passName##PassFlag; \ |
168 | void llvm::initialize##passName##Pass(PassRegistry &Registry) { \ |
169 | llvm::call_once(Initialize##passName##PassFlag, \ |
170 | initialize##passName##PassOnce, std::ref(Registry)); \ |
171 | } |
172 | |
173 | #define INITIALIZE_AG_PASS_BEGIN(passName, agName, arg, n, cfg, analysis, def) \ |
174 | static void *initialize##passName##PassOnce(PassRegistry &Registry) { \ |
175 | if (!def) \ |
176 | initialize##agName##AnalysisGroup(Registry); |
177 | |
178 | #define INITIALIZE_AG_PASS_END(passName, agName, arg, n, cfg, analysis, def) \ |
179 | PassInfo *PI = new PassInfo( \ |
180 | n, arg, &passName::ID, \ |
181 | PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis); \ |
182 | Registry.registerPass(*PI, true); \ |
183 | \ |
184 | PassInfo *AI = new PassInfo(n, &agName::ID); \ |
185 | Registry.registerAnalysisGroup(&agName::ID, &passName::ID, *AI, def, true); \ |
186 | return AI; \ |
187 | } \ |
188 | static llvm::once_flag Initialize##passName##PassFlag; \ |
189 | void llvm::initialize##passName##Pass(PassRegistry &Registry) { \ |
190 | llvm::call_once(Initialize##passName##PassFlag, \ |
191 | initialize##passName##PassOnce, std::ref(Registry)); \ |
192 | } |
193 | |
194 | //===--------------------------------------------------------------------------- |
195 | /// PassRegistrationListener class - This class is meant to be derived from by |
196 | /// clients that are interested in which passes get registered and unregistered |
197 | /// at runtime (which can be because of the RegisterPass constructors being run |
198 | /// as the program starts up, or may be because a shared object just got |
199 | /// loaded). |
200 | struct PassRegistrationListener { |
201 | PassRegistrationListener() = default; |
202 | virtual ~PassRegistrationListener() = default; |
203 | |
204 | /// Callback functions - These functions are invoked whenever a pass is loaded |
205 | /// or removed from the current executable. |
206 | virtual void passRegistered(const PassInfo *) {} |
207 | |
208 | /// enumeratePasses - Iterate over the registered passes, calling the |
209 | /// passEnumerate callback on each PassInfo object. |
210 | void enumeratePasses(); |
211 | |
212 | /// passEnumerate - Callback function invoked when someone calls |
213 | /// enumeratePasses on this PassRegistrationListener object. |
214 | virtual void passEnumerate(const PassInfo *) {} |
215 | }; |
216 | |
217 | } // end namespace llvm |
218 | |
219 | #endif // LLVM_PASSSUPPORT_H |
220 | |