1 | //===- PassManager internal APIs and implementation details -----*- 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 | /// \file |
9 | /// |
10 | /// This header provides internal APIs and implementation details used by the |
11 | /// pass management interfaces exposed in PassManager.h. To understand more |
12 | /// context of why these particular interfaces are needed, see that header |
13 | /// file. None of these APIs should be used elsewhere. |
14 | /// |
15 | //===----------------------------------------------------------------------===// |
16 | |
17 | #ifndef LLVM_IR_PASSMANAGERINTERNAL_H |
18 | #define LLVM_IR_PASSMANAGERINTERNAL_H |
19 | |
20 | #include "llvm/ADT/STLExtras.h" |
21 | #include "llvm/ADT/StringRef.h" |
22 | #include "llvm/Support/raw_ostream.h" |
23 | #include <memory> |
24 | #include <utility> |
25 | |
26 | namespace llvm { |
27 | |
28 | template <typename IRUnitT> class AllAnalysesOn; |
29 | template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager; |
30 | class PreservedAnalyses; |
31 | |
32 | // Implementation details of the pass manager interfaces. |
33 | namespace detail { |
34 | |
35 | /// Template for the abstract base class used to dispatch |
36 | /// polymorphically over pass objects. |
37 | template <typename IRUnitT, typename AnalysisManagerT, typename... ExtraArgTs> |
38 | struct PassConcept { |
39 | // Boiler plate necessary for the container of derived classes. |
40 | virtual ~PassConcept() = default; |
41 | |
42 | /// The polymorphic API which runs the pass over a given IR entity. |
43 | /// |
44 | /// Note that actual pass object can omit the analysis manager argument if |
45 | /// desired. Also that the analysis manager may be null if there is no |
46 | /// analysis manager in the pass pipeline. |
47 | virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, |
48 | ExtraArgTs... ) = 0; |
49 | |
50 | virtual void |
51 | printPipeline(raw_ostream &OS, |
52 | function_ref<StringRef(StringRef)> MapClassName2PassName) = 0; |
53 | /// Polymorphic method to access the name of a pass. |
54 | virtual StringRef name() const = 0; |
55 | |
56 | /// Polymorphic method to to let a pass optionally exempted from skipping by |
57 | /// PassInstrumentation. |
58 | /// To opt-in, pass should implement `static bool isRequired()`. It's no-op |
59 | /// to have `isRequired` always return false since that is the default. |
60 | virtual bool isRequired() const = 0; |
61 | }; |
62 | |
63 | /// A template wrapper used to implement the polymorphic API. |
64 | /// |
65 | /// Can be instantiated for any object which provides a \c run method accepting |
66 | /// an \c IRUnitT& and an \c AnalysisManager<IRUnit>&. It requires the pass to |
67 | /// be a copyable object. |
68 | template <typename IRUnitT, typename PassT, typename PreservedAnalysesT, |
69 | typename AnalysisManagerT, typename... ExtraArgTs> |
70 | struct PassModel : PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...> { |
71 | explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {} |
72 | // We have to explicitly define all the special member functions because MSVC |
73 | // refuses to generate them. |
74 | PassModel(const PassModel &Arg) : Pass(Arg.Pass) {} |
75 | PassModel(PassModel &&Arg) : Pass(std::move(Arg.Pass)) {} |
76 | |
77 | friend void swap(PassModel &LHS, PassModel &RHS) { |
78 | using std::swap; |
79 | swap(LHS.Pass, RHS.Pass); |
80 | } |
81 | |
82 | PassModel &operator=(PassModel RHS) { |
83 | swap(*this, RHS); |
84 | return *this; |
85 | } |
86 | |
87 | PreservedAnalysesT run(IRUnitT &IR, AnalysisManagerT &AM, |
88 | ExtraArgTs... ) override { |
89 | return Pass.run(IR, AM, ExtraArgs...); |
90 | } |
91 | |
92 | void printPipeline( |
93 | raw_ostream &OS, |
94 | function_ref<StringRef(StringRef)> MapClassName2PassName) override { |
95 | Pass.printPipeline(OS, MapClassName2PassName); |
96 | } |
97 | |
98 | StringRef name() const override { return PassT::name(); } |
99 | |
100 | template <typename T> |
101 | using has_required_t = decltype(std::declval<T &>().isRequired()); |
102 | |
103 | template <typename T> |
104 | static std::enable_if_t<is_detected<has_required_t, T>::value, bool> |
105 | passIsRequiredImpl() { |
106 | return T::isRequired(); |
107 | } |
108 | template <typename T> |
109 | static std::enable_if_t<!is_detected<has_required_t, T>::value, bool> |
110 | passIsRequiredImpl() { |
111 | return false; |
112 | } |
113 | |
114 | bool isRequired() const override { return passIsRequiredImpl<PassT>(); } |
115 | |
116 | PassT Pass; |
117 | }; |
118 | |
119 | /// Abstract concept of an analysis result. |
120 | /// |
121 | /// This concept is parameterized over the IR unit that this result pertains |
122 | /// to. |
123 | template <typename IRUnitT, typename PreservedAnalysesT, typename InvalidatorT> |
124 | struct AnalysisResultConcept { |
125 | virtual ~AnalysisResultConcept() = default; |
126 | |
127 | /// Method to try and mark a result as invalid. |
128 | /// |
129 | /// When the outer analysis manager detects a change in some underlying |
130 | /// unit of the IR, it will call this method on all of the results cached. |
131 | /// |
132 | /// \p PA is a set of preserved analyses which can be used to avoid |
133 | /// invalidation because the pass which changed the underlying IR took care |
134 | /// to update or preserve the analysis result in some way. |
135 | /// |
136 | /// \p Inv is typically a \c AnalysisManager::Invalidator object that can be |
137 | /// used by a particular analysis result to discover if other analyses |
138 | /// results are also invalidated in the event that this result depends on |
139 | /// them. See the documentation in the \c AnalysisManager for more details. |
140 | /// |
141 | /// \returns true if the result is indeed invalid (the default). |
142 | virtual bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA, |
143 | InvalidatorT &Inv) = 0; |
144 | }; |
145 | |
146 | /// SFINAE metafunction for computing whether \c ResultT provides an |
147 | /// \c invalidate member function. |
148 | template <typename IRUnitT, typename ResultT> class ResultHasInvalidateMethod { |
149 | using EnabledType = char; |
150 | struct DisabledType { |
151 | char a, b; |
152 | }; |
153 | |
154 | // Purely to help out MSVC which fails to disable the below specialization, |
155 | // explicitly enable using the result type's invalidate routine if we can |
156 | // successfully call that routine. |
157 | template <typename T> struct Nonce { using Type = EnabledType; }; |
158 | template <typename T> |
159 | static typename Nonce<decltype(std::declval<T>().invalidate( |
160 | std::declval<IRUnitT &>(), std::declval<PreservedAnalyses>()))>::Type |
161 | check(rank<2>); |
162 | |
163 | // First we define an overload that can only be taken if there is no |
164 | // invalidate member. We do this by taking the address of an invalidate |
165 | // member in an adjacent base class of a derived class. This would be |
166 | // ambiguous if there were an invalidate member in the result type. |
167 | template <typename T, typename U> static DisabledType NonceFunction(T U::*); |
168 | struct CheckerBase { int invalidate; }; |
169 | template <typename T> struct Checker : CheckerBase, T {}; |
170 | template <typename T> |
171 | static decltype(NonceFunction(&Checker<T>::invalidate)) check(rank<1>); |
172 | |
173 | // Now we have the fallback that will only be reached when there is an |
174 | // invalidate member, and enables the trait. |
175 | template <typename T> |
176 | static EnabledType check(rank<0>); |
177 | |
178 | public: |
179 | enum { Value = sizeof(check<ResultT>(rank<2>())) == sizeof(EnabledType) }; |
180 | }; |
181 | |
182 | /// Wrapper to model the analysis result concept. |
183 | /// |
184 | /// By default, this will implement the invalidate method with a trivial |
185 | /// implementation so that the actual analysis result doesn't need to provide |
186 | /// an invalidation handler. It is only selected when the invalidation handler |
187 | /// is not part of the ResultT's interface. |
188 | template <typename IRUnitT, typename PassT, typename ResultT, |
189 | typename PreservedAnalysesT, typename InvalidatorT, |
190 | bool HasInvalidateHandler = |
191 | ResultHasInvalidateMethod<IRUnitT, ResultT>::Value> |
192 | struct AnalysisResultModel; |
193 | |
194 | /// Specialization of \c AnalysisResultModel which provides the default |
195 | /// invalidate functionality. |
196 | template <typename IRUnitT, typename PassT, typename ResultT, |
197 | typename PreservedAnalysesT, typename InvalidatorT> |
198 | struct AnalysisResultModel<IRUnitT, PassT, ResultT, PreservedAnalysesT, |
199 | InvalidatorT, false> |
200 | : AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT> { |
201 | explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {} |
202 | // We have to explicitly define all the special member functions because MSVC |
203 | // refuses to generate them. |
204 | AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {} |
205 | AnalysisResultModel(AnalysisResultModel &&Arg) |
206 | : Result(std::move(Arg.Result)) {} |
207 | |
208 | friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) { |
209 | using std::swap; |
210 | swap(LHS.Result, RHS.Result); |
211 | } |
212 | |
213 | AnalysisResultModel &operator=(AnalysisResultModel RHS) { |
214 | swap(*this, RHS); |
215 | return *this; |
216 | } |
217 | |
218 | /// The model bases invalidation solely on being in the preserved set. |
219 | // |
220 | // FIXME: We should actually use two different concepts for analysis results |
221 | // rather than two different models, and avoid the indirect function call for |
222 | // ones that use the trivial behavior. |
223 | bool invalidate(IRUnitT &, const PreservedAnalysesT &PA, |
224 | InvalidatorT &) override { |
225 | auto PAC = PA.template getChecker<PassT>(); |
226 | return !PAC.preserved() && |
227 | !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>(); |
228 | } |
229 | |
230 | ResultT Result; |
231 | }; |
232 | |
233 | /// Specialization of \c AnalysisResultModel which delegates invalidate |
234 | /// handling to \c ResultT. |
235 | template <typename IRUnitT, typename PassT, typename ResultT, |
236 | typename PreservedAnalysesT, typename InvalidatorT> |
237 | struct AnalysisResultModel<IRUnitT, PassT, ResultT, PreservedAnalysesT, |
238 | InvalidatorT, true> |
239 | : AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT> { |
240 | explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {} |
241 | // We have to explicitly define all the special member functions because MSVC |
242 | // refuses to generate them. |
243 | AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {} |
244 | AnalysisResultModel(AnalysisResultModel &&Arg) |
245 | : Result(std::move(Arg.Result)) {} |
246 | |
247 | friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) { |
248 | using std::swap; |
249 | swap(LHS.Result, RHS.Result); |
250 | } |
251 | |
252 | AnalysisResultModel &operator=(AnalysisResultModel RHS) { |
253 | swap(*this, RHS); |
254 | return *this; |
255 | } |
256 | |
257 | /// The model delegates to the \c ResultT method. |
258 | bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA, |
259 | InvalidatorT &Inv) override { |
260 | return Result.invalidate(IR, PA, Inv); |
261 | } |
262 | |
263 | ResultT Result; |
264 | }; |
265 | |
266 | /// Abstract concept of an analysis pass. |
267 | /// |
268 | /// This concept is parameterized over the IR unit that it can run over and |
269 | /// produce an analysis result. |
270 | template <typename IRUnitT, typename PreservedAnalysesT, typename InvalidatorT, |
271 | typename... ExtraArgTs> |
272 | struct AnalysisPassConcept { |
273 | virtual ~AnalysisPassConcept() = default; |
274 | |
275 | /// Method to run this analysis over a unit of IR. |
276 | /// \returns A unique_ptr to the analysis result object to be queried by |
277 | /// users. |
278 | virtual std::unique_ptr< |
279 | AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT>> |
280 | run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM, |
281 | ExtraArgTs... ) = 0; |
282 | |
283 | /// Polymorphic method to access the name of a pass. |
284 | virtual StringRef name() const = 0; |
285 | }; |
286 | |
287 | /// Wrapper to model the analysis pass concept. |
288 | /// |
289 | /// Can wrap any type which implements a suitable \c run method. The method |
290 | /// must accept an \c IRUnitT& and an \c AnalysisManager<IRUnitT>& as arguments |
291 | /// and produce an object which can be wrapped in a \c AnalysisResultModel. |
292 | template <typename IRUnitT, typename PassT, typename PreservedAnalysesT, |
293 | typename InvalidatorT, typename... ExtraArgTs> |
294 | struct AnalysisPassModel : AnalysisPassConcept<IRUnitT, PreservedAnalysesT, |
295 | InvalidatorT, ExtraArgTs...> { |
296 | explicit AnalysisPassModel(PassT Pass) : Pass(std::move(Pass)) {} |
297 | // We have to explicitly define all the special member functions because MSVC |
298 | // refuses to generate them. |
299 | AnalysisPassModel(const AnalysisPassModel &Arg) : Pass(Arg.Pass) {} |
300 | AnalysisPassModel(AnalysisPassModel &&Arg) : Pass(std::move(Arg.Pass)) {} |
301 | |
302 | friend void swap(AnalysisPassModel &LHS, AnalysisPassModel &RHS) { |
303 | using std::swap; |
304 | swap(LHS.Pass, RHS.Pass); |
305 | } |
306 | |
307 | AnalysisPassModel &operator=(AnalysisPassModel RHS) { |
308 | swap(*this, RHS); |
309 | return *this; |
310 | } |
311 | |
312 | // FIXME: Replace PassT::Result with type traits when we use C++11. |
313 | using ResultModelT = |
314 | AnalysisResultModel<IRUnitT, PassT, typename PassT::Result, |
315 | PreservedAnalysesT, InvalidatorT>; |
316 | |
317 | /// The model delegates to the \c PassT::run method. |
318 | /// |
319 | /// The return is wrapped in an \c AnalysisResultModel. |
320 | std::unique_ptr< |
321 | AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT>> |
322 | run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM, |
323 | ExtraArgTs... ) override { |
324 | return std::make_unique<ResultModelT>( |
325 | Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...)); |
326 | } |
327 | |
328 | /// The model delegates to a static \c PassT::name method. |
329 | /// |
330 | /// The returned string ref must point to constant immutable data! |
331 | StringRef name() const override { return PassT::name(); } |
332 | |
333 | PassT Pass; |
334 | }; |
335 | |
336 | } // end namespace detail |
337 | |
338 | } // end namespace llvm |
339 | |
340 | #endif // LLVM_IR_PASSMANAGERINTERNAL_H |
341 | |