18 #ifndef LLVM_IR_PASSMANAGERINTERNAL_H
19 #define LLVM_IR_PASSMANAGERINTERNAL_H
28 template <
typename IRUnitT>
class AllAnalysesOn;
29 template <
typename IRUnitT,
typename... ExtraArgTs>
class AnalysisManager;
31 class PreservedAnalyses;
38 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... ExtraArgTs>
49 ExtraArgTs... ExtraArgs) = 0;
60 template <
typename IRUnitT,
typename PassT,
typename PreservedAnalysesT,
61 typename AnalysisManagerT,
typename... ExtraArgTs>
79 PreservedAnalysesT
run(IRUnitT &
IR, AnalysisManagerT &AM,
80 ExtraArgTs... ExtraArgs)
override {
81 return Pass.run(IR, AM, ExtraArgs...);
93 template <
typename IRUnitT,
typename PreservedAnalysesT,
typename Inval
idatorT>
112 virtual bool invalidate(IRUnitT &
IR,
const PreservedAnalysesT &PA,
113 InvalidatorT &Inv) = 0;
119 typedef char EnabledType;
120 struct DisabledType {
127 template <
typename T>
struct Nonce {
typedef EnabledType
Type; };
128 template <
typename T>
129 static typename Nonce<decltype(std::declval<T>().invalidate(
130 std::declval<IRUnitT &>(), std::declval<PreservedAnalyses>()))>::
Type
137 template <
typename T,
typename U>
static DisabledType NonceFunction(
T U::*);
138 struct CheckerBase {
int invalidate; };
139 template <
typename T>
struct Checker : CheckerBase,
T {};
140 template <
typename T>
141 static decltype(NonceFunction(&Checker<T>::invalidate)) check(
rank<1>);
145 template <
typename T>
146 static EnabledType check(
rank<0>);
149 enum {
Value =
sizeof(check<ResultT>(
rank<2>())) ==
sizeof(EnabledType) };
158 template <
typename IRUnitT,
typename PassT,
typename ResultT,
159 typename PreservedAnalysesT,
typename InvalidatorT,
160 bool HasInvalidateHandler =
161 ResultHasInvalidateMethod<IRUnitT, ResultT>::Value>
166 template <
typename IRUnitT,
typename PassT,
typename ResultT,
167 typename PreservedAnalysesT,
typename InvalidatorT>
176 : Result(std::move(Arg.Result)) {}
180 swap(LHS.Result, RHS.Result);
194 InvalidatorT &)
override {
195 auto PAC = PA.template getChecker<PassT>();
196 return !PAC.preserved() &&
197 !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
205 template <
typename IRUnitT,
typename PassT,
typename ResultT,
206 typename PreservedAnalysesT,
typename InvalidatorT>
215 : Result(std::move(Arg.Result)) {}
219 swap(LHS.Result, RHS.Result);
229 InvalidatorT &Inv)
override {
230 return Result.invalidate(IR, PA, Inv);
240 template <
typename IRUnitT,
typename PreservedAnalysesT,
typename InvalidatorT,
241 typename... ExtraArgTs>
248 virtual std::unique_ptr<
251 ExtraArgTs... ExtraArgs) = 0;
262 template <
typename IRUnitT,
typename PassT,
typename PreservedAnalysesT,
263 typename InvalidatorT,
typename... ExtraArgTs>
265 InvalidatorT, ExtraArgTs...> {
284 PreservedAnalysesT, InvalidatorT>
293 ExtraArgTs... ExtraArgs)
override {
294 return make_unique<ResultModelT>(
Pass.run(IR, AM, ExtraArgs...));
309 #endif // LLVM_IR_PASSMANAGERINTERNAL_H
Pass interface - Implemented by all 'passes'.
Wrapper to model the analysis pass concept.
friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS)
Template for the abstract base class used to dispatch polymorphically over pass objects.
AnalysisResultModel(const AnalysisResultModel &Arg)
virtual StringRef name()=0
Polymorphic method to access the name of a pass.
SFINAE metafunction for computing whether ResultT provides an invalidate member function.
virtual ~AnalysisResultConcept()=default
Abstract concept of an analysis pass.
AnalysisResultModel(ResultT Result)
virtual bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA, InvalidatorT &Inv)=0
Method to try and mark a result as invalid.
AnalysisResultModel(AnalysisResultModel &&Arg)
virtual ~AnalysisPassConcept()=default
AnalysisResultModel(ResultT Result)
PassModel & operator=(PassModel RHS)
friend void swap(PassModel &LHS, PassModel &RHS)
Function Alias Analysis false
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.
bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA, InvalidatorT &Inv) override
The model delegates to the ResultT method.
virtual StringRef name()=0
Polymorphic method to access the name of a pass.
A set of analyses that are preserved following a run of a transformation pass.
The instances of the Type class are immutable: once they are created, they are never changed...
friend void swap(AnalysisPassModel &LHS, AnalysisPassModel &RHS)
Wrapper to model the analysis result concept.
StringRef name() override
Polymorphic method to access the name of a pass.
StringRef name() override
The model delegates to a static PassT::name method.
PreservedAnalysesT run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs...ExtraArgs) override
The polymorphic API which runs the pass over a given IR entity.
AnalysisPassModel(const AnalysisPassModel &Arg)
virtual ~PassConcept()=default
AnalysisPassModel & operator=(AnalysisPassModel RHS)
AnalysisResultModel(AnalysisResultModel &&Arg)
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.
A template wrapper used to implement the polymorphic API.
AnalysisResultModel & operator=(AnalysisResultModel RHS)
Abstract concept of an analysis result.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS)
virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs...ExtraArgs)=0
The polymorphic API which runs the pass over a given IR entity.
AnalysisPassModel(PassT Pass)
PassModel(const PassModel &Arg)
AnalysisResultModel & operator=(AnalysisResultModel RHS)
bool invalidate(IRUnitT &, const PreservedAnalysesT &PA, InvalidatorT &) override
The model bases invalidation solely on being in the preserved set.
AnalysisResultModel(const AnalysisResultModel &Arg)
AnalysisResultModel< IRUnitT, PassT, typename PassT::Result, PreservedAnalysesT, InvalidatorT > ResultModelT
LLVM Value Representation.
PassModel(PassModel &&Arg)
AnalysisPassModel(AnalysisPassModel &&Arg)
StringRef - Represent a constant reference to a string, i.e.
A container for analyses that lazily runs them and caches their results.
Utility type to build an inheritance chain that makes it easy to rank overload candidates.
Statically lint checks LLVM IR