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