Go to the documentation of this file.
37 #ifndef LLVM_IR_PASSMANAGER_H
38 #define LLVM_IR_PASSMANAGER_H
57 #include <type_traits>
98 template <
typename IRUnitT> AnalysisSetKey AllAnalysesOn<IRUnitT>::SetKey;
100 extern template class AllAnalysesOn<Module>;
101 extern template class AllAnalysesOn<Function>;
160 PA.PreservedIDs.
insert(&AllAnalysesKey);
165 template <
typename AnalysisSetT>
179 NotPreservedAnalysisIDs.erase(
ID);
183 if (!areAllPreserved())
184 PreservedIDs.insert(
ID);
195 if (!areAllPreserved())
196 PreservedIDs.insert(
ID);
216 PreservedIDs.erase(
ID);
217 NotPreservedAnalysisIDs.insert(
ID);
225 if (
Arg.areAllPreserved())
227 if (areAllPreserved()) {
233 for (
auto ID :
Arg.NotPreservedAnalysisIDs) {
234 PreservedIDs.erase(
ID);
235 NotPreservedAnalysisIDs.insert(
ID);
237 for (
auto ID : PreservedIDs)
238 if (!
Arg.PreservedIDs.count(
ID))
239 PreservedIDs.erase(
ID);
247 if (
Arg.areAllPreserved())
249 if (areAllPreserved()) {
255 for (
auto ID :
Arg.NotPreservedAnalysisIDs) {
256 PreservedIDs.erase(
ID);
257 NotPreservedAnalysisIDs.insert(
ID);
259 for (
auto ID : PreservedIDs)
260 if (!
Arg.PreservedIDs.count(
ID))
261 PreservedIDs.erase(
ID);
271 const bool IsAbandoned;
277 : PA(PA),
ID(
ID), IsAbandoned(PA.NotPreservedAnalysisIDs.
count(
ID)) {}
284 return !IsAbandoned && (PA.PreservedIDs.
count(&AllAnalysesKey) ||
300 return !IsAbandoned && (PA.PreservedIDs.
count(&AllAnalysesKey) ||
301 PA.PreservedIDs.
count(SetID));
328 return NotPreservedAnalysisIDs.empty() &&
329 PreservedIDs.count(&AllAnalysesKey);
343 return NotPreservedAnalysisIDs.empty() &&
344 (PreservedIDs.count(&AllAnalysesKey) || PreservedIDs.count(SetID));
365 template <
typename IRUnitT,
typename... ExtraArgTs>
class AnalysisManager;
374 static_assert(std::is_base_of<PassInfoMixin, DerivedT>::value,
375 "Must pass the derived type as the template argument!");
377 Name.consume_front(
"llvm::");
384 auto PassName = MapClassName2PassName(ClassName);
393 template <
typename DerivedT>
411 static_assert(std::is_base_of<AnalysisInfoMixin, DerivedT>::value,
412 "Must pass the derived type as the template argument!");
421 template <
typename PassT,
typename IRUnitT,
typename AnalysisManagerT,
422 typename... ArgTs,
size_t... Ns>
423 typename PassT::Result
425 std::tuple<ArgTs...>
Args,
426 std::index_sequence<Ns...>) {
428 return AM.template getResult<PassT>(
IR, std::get<Ns>(
Args)...);
436 template <
typename PassT,
typename IRUnitT,
typename... AnalysisArgTs,
437 typename... MainArgTs>
438 typename PassT::Result
440 std::tuple<MainArgTs...>
Args) {
442 PassT, IRUnitT>)(AM,
IR,
Args,
443 std::index_sequence_for<AnalysisArgTs...>{});
452 class PassInstrumentationAnalysis;
466 template <
typename IRUnitT,
467 typename AnalysisManagerT = AnalysisManager<IRUnitT>,
468 typename... ExtraArgTs>
470 PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...>> {
488 for (
unsigned Idx = 0, Size =
Passes.size(); Idx != Size; ++Idx) {
490 P->printPipeline(OS, MapClassName2PassName);
499 ExtraArgTs... ExtraArgs) {
507 detail::getAnalysisResult<PassInstrumentationAnalysis>(
508 AM,
IR, std::tuple<ExtraArgTs...>(ExtraArgs...));
510 for (
unsigned Idx = 0, Size =
Passes.size(); Idx != Size; ++Idx) {
522 PassPA =
P->run(
IR, AM, ExtraArgs...);
531 AM.invalidate(
IR, PassPA);
547 template <
typename PassT>
549 std::enable_if_t<!std::is_same<PassT, PassManager>::value>
556 Passes.push_back(std::unique_ptr<PassConceptT>(
557 new PassModelT(std::forward<PassT>(
Pass))));
565 template <
typename PassT>
567 std::enable_if_t<std::is_same<PassT, PassManager>::value>
569 for (
auto &
P :
Pass.Passes)
582 std::vector<std::unique_ptr<PassConceptT>>
Passes;
611 : Callbacks(Callbacks) {}
615 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... ExtraArgTs>
616 Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
626 template <
typename IRUnitT,
typename... ExtraArgTs>
class AnalysisManager {
632 using ResultConceptT =
633 detail::AnalysisResultConcept<IRUnitT, PreservedAnalyses, Invalidator>;
635 detail::AnalysisPassConcept<IRUnitT, PreservedAnalyses, Invalidator,
644 using AnalysisResultListT =
645 std::list<std::pair<AnalysisKey *, std::unique_ptr<ResultConceptT>>>;
648 using AnalysisResultListMapT = DenseMap<IRUnitT *, AnalysisResultListT>;
653 using AnalysisResultMapT =
654 DenseMap<std::pair<AnalysisKey *, IRUnitT *>,
655 typename AnalysisResultListT::iterator>;
684 template <
typename PassT>
690 return invalidateImpl<ResultModelT>(
PassT::ID(),
IR, PA);
700 return invalidateImpl<>(
ID,
IR, PA);
706 template <
typename ResultT = ResultConceptT>
711 auto IMapI = IsResultInvalidated.find(
ID);
712 if (IMapI != IsResultInvalidated.end())
713 return IMapI->second;
718 "Trying to invalidate a dependent result that isn't in the "
719 "manager's cache is always an error, likely due to a stale result "
722 auto &Result =
static_cast<ResultT &
>(*RI->second->second);
729 std::tie(IMapI, Inserted) =
730 IsResultInvalidated.insert({
ID, Result.invalidate(
IR, PA, *
this)});
732 assert(Inserted &&
"Should not have already inserted this ID, likely "
733 "indicates a dependency cycle!");
734 return IMapI->second;
737 Invalidator(SmallDenseMap<AnalysisKey *, bool, 8> &IsResultInvalidated,
738 const AnalysisResultMapT &
Results)
741 SmallDenseMap<AnalysisKey *, bool, 8> &IsResultInvalidated;
742 const AnalysisResultMapT &
Results;
753 "The storage and index of analysis results disagree on how many "
755 return AnalysisResults.
empty();
772 AnalysisResults.
clear();
773 AnalysisResultLists.
clear();
779 template <
typename PassT>
780 typename PassT::Result &
getResult(IRUnitT &
IR, ExtraArgTs... ExtraArgs) {
782 "This analysis pass was not registered prior to being queried");
790 return static_cast<ResultModelT &
>(ResultConcept).Result;
798 template <
typename PassT>
801 "This analysis pass was not registered prior to being queried");
811 return &
static_cast<ResultModelT *
>(ResultConcept)->Result;
815 template <
typename PassT>
819 Invalidator Inv(IsResultInvalidated, AnalysisResults);
820 assert(!Result->invalidate(
IR, PA, Inv) &&
821 "Cached result cannot be invalidated");
841 template <
typename PassBuilderT>
846 Invalidator, ExtraArgTs...>;
848 auto &PassPtr = AnalysisPasses[
PassT::ID()];
869 "Analysis passes must be registered prior to being queried!");
874 const PassConceptT &lookUpPass(AnalysisKey *
ID)
const {
877 "Analysis passes must be registered prior to being queried!");
882 ResultConceptT &getResultImpl(AnalysisKey *
ID, IRUnitT &
IR,
883 ExtraArgTs... ExtraArgs);
886 ResultConceptT *getCachedResultImpl(AnalysisKey *
ID, IRUnitT &
IR)
const {
889 return RI == AnalysisResults.
end() ? nullptr : &*RI->second->second;
893 using AnalysisPassMapT =
894 DenseMap<AnalysisKey *, std::unique_ptr<PassConceptT>>;
897 AnalysisPassMapT AnalysisPasses;
903 AnalysisResultListMapT AnalysisResultLists;
907 AnalysisResultMapT AnalysisResults;
910 extern template class AnalysisManager<Module>;
936 template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
939 InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {
943 explicit Result(AnalysisManagerT &InnerAM) : InnerAM(&InnerAM) {}
949 Arg.InnerAM =
nullptr;
963 InnerAM =
RHS.InnerAM;
967 RHS.InnerAM =
nullptr;
989 AnalysisManagerT *InnerAM;
993 : InnerAM(&InnerAM) {}
1011 AnalysisManagerT *InnerAM;
1014 template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
1016 InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>
::Key;
1061 template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
1064 OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>> {
1069 explicit Result(
const AnalysisManagerT &OuterAM) : OuterAM(&OuterAM) {}
1073 template <
typename PassT,
typename IRUnitTParam>
1075 typename PassT::Result *Res =
1076 OuterAM->template getCachedResult<PassT>(
IR);
1078 OuterAM->template verifyNotInvalidated<PassT>(
IR, Res);
1083 template <
typename PassT,
typename IRUnitTParam>
1085 typename PassT::Result *Res =
1086 OuterAM->template getCachedResult<PassT>(
IR);
1087 return Res !=
nullptr;
1097 for (
auto &KeyValuePair : OuterAnalysisInvalidationMap) {
1099 auto &InnerIDs = KeyValuePair.second;
1103 if (InnerIDs.empty())
1104 DeadKeys.push_back(OuterID);
1107 for (
auto OuterID : DeadKeys)
1108 OuterAnalysisInvalidationMap.
erase(OuterID);
1116 template <
typename OuterAnalysisT,
typename Inval
idatedAnalysisT>
1121 auto &InvalidatedIDList = OuterAnalysisInvalidationMap[OuterID];
1127 InvalidatedIDList.push_back(InvalidatedID);
1134 return OuterAnalysisInvalidationMap;
1138 const AnalysisManagerT *OuterAM;
1143 OuterAnalysisInvalidationMap;
1147 : OuterAM(&OuterAM) {}
1163 const AnalysisManagerT *OuterAM;
1166 template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
1168 OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>
::Key;
1205 bool EagerlyInvalidate)
1216 std::unique_ptr<PassConceptT>
Pass;
1217 bool EagerlyInvalidate;
1222 template <
typename FunctionPassT>
1223 ModuleToFunctionPassAdaptor
1225 bool EagerlyInvalidate =
false) {
1232 std::unique_ptr<ModuleToFunctionPassAdaptor::PassConceptT>(
1233 new PassModelT(std::forward<FunctionPassT>(
Pass))),
1246 template <
typename AnalysisT,
typename IRUnitT,
1247 typename AnalysisManagerT = AnalysisManager<IRUnitT>,
1248 typename... ExtraArgTs>
1250 :
PassInfoMixin<RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
1259 ExtraArgTs &&...
Args) {
1260 (void)AM.template getResult<AnalysisT>(
Arg,
1261 std::forward<ExtraArgTs>(
Args)...);
1268 auto PassName = MapClassName2PassName(ClassName);
1269 OS <<
"require<" <<
PassName <<
">";
1276 template <
typename AnalysisT>
1285 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... ExtraArgTs>
1294 auto PassName = MapClassName2PassName(ClassName);
1295 OS <<
"invalidate<" <<
PassName <<
">";
1305 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... ExtraArgTs>
1315 template <
typename PassT>
1319 : Count(Count), P(
std::forward<PassT>(P)) {}
1321 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... Ts>
1329 detail::getAnalysisResult<PassInstrumentationAnalysis>(
1330 AM,
IR, std::tuple<Ts...>(
Args...));
1333 for (
int i = 0;
i < Count; ++
i) {
1348 OS <<
"repeat<" << Count <<
">(";
1349 P.printPipeline(OS, MapClassName2PassName);
1358 template <
typename PassT>
1365 #endif // LLVM_IR_PASSMANAGER_H
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Runs the function pass across every function in the module.
Trivial adaptor that maps from a module to its functions.
A set of analyses that are preserved following a run of a transformation pass.
Abstract concept of an analysis result.
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
OuterAnalysisManagerProxy(const AnalysisManagerT &OuterAM)
This is an optimization pass for GlobalISel generic memory operations.
iterator erase(const_iterator CI)
The TimeTraceScope is a helper class to call the begin and end functions of the time trace profiler.
bool isEmpty() const
Returns if the pass manager contains any passes.
Result run(IRUnitT &, AnalysisManager< IRUnitT, ExtraArgTs... > &, ExtraArgTs...)
Run the analysis pass and create our proxy result object.
static AnalysisKey * ID()
Returns an opaque, unique ID for this analysis type.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
A CRTP mix-in to automatically provide informational APIs needed for passes.
bool invalidate(IRUnitT &IRUnit, const PreservedAnalyses &PA, typename AnalysisManager< IRUnitT, ExtraArgTs... >::Invalidator &Inv)
When invalidation occurs, remove any registered invalidation events.
OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Trigger the invalidation of some other analysis pass if not already handled and return whether it was...
void invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Invalidate cached analyses for an IR unit.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
InnerAnalysisManagerProxy(AnalysisManagerT &InnerAM)
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
PassT::Result getAnalysisResultUnpackTuple(AnalysisManagerT &AM, IRUnitT &IR, std::tuple< ArgTs... > Args, std::index_sequence< Ns... >)
Actual unpacker of extra arguments in getAnalysisResult, passes only those tuple arguments that are m...
void abandon()
Mark an analysis as abandoned.
PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...)
Run this pass over some unit of IR.
bool cachedResultExists(IRUnitTParam &IR) const
Method provided for unit testing, not intended for general use.
A checker object that makes it easy to query for whether an analysis or some set covering it is prese...
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
#define LLVM_ATTRIBUTE_MINSIZE
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Function Alias Analysis Results
PreservedAnalysisChecker getChecker(AnalysisKey *ID) const
Build a checker for this PreservedAnalyses and the specified analysis ID.
Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...)
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
static AnalysisSetKey * ID()
PassManager & operator=(PassManager &&RHS)
void intersect(const PreservedAnalyses &Arg)
Intersect this set with another in place.
detail::PassConcept< IRUnitT, AnalysisManagerT, ExtraArgTs... > PassConceptT
void preserveSet(AnalysisSetKey *ID)
Mark an analysis set as preserved using its ID.
DenseMapIterator< AnalysisKey *, std::unique_ptr< PassConceptT >, DenseMapInfo< AnalysisKey * >, llvm::detail::DenseMapPair< AnalysisKey *, std::unique_ptr< PassConceptT > >, true > const_iterator
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
PassManager(PassManager &&Arg)
This class provides access to building LLVM's passes.
bool empty() const
Returns true if the analysis manager has an empty results cache.
RepeatedPass< PassT > createRepeatedPass(int Count, PassT &&P)
Result proxy object for OuterAnalysisManagerProxy.
This class implements an extremely fast bulk output stream that can only output to a stream.
PreservedAnalyses run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...)
Run this pass over some unit of IR.
Statically lint checks LLVM IR
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
API to communicate dependencies between analyses during invalidation.
bool preservedSet()
Returns true if the checker's analysis was not abandoned and either.
std::vector< std::unique_ptr< PassConceptT > > Passes
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t< std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
When adding a pass manager pass that has the same type as this pass manager, simply move the passes o...
PassInstrumentationAnalysis(PassInstrumentationCallbacks *Callbacks=nullptr)
PassInstrumentationCallbacks object is shared, owned by something else, not this analysis.
A special type used to provide an address that identifies a set of related analyses.
An efficient, type-erasing, non-owning reference to a callable.
void preserve(AnalysisKey *ID)
Given an analysis's ID, mark the analysis as preserved, adding it to the set.
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
auto count(R &&Range, const E &Element)
Wrapper function around std::count to count the number of times an element Element occurs in the give...
void runAfterPass(const PassT &Pass, const IRUnitT &IR, const PreservedAnalyses &PA) const
AfterPass instrumentation point - takes Pass instance that has just been executed and constant refere...
void preserve()
Mark an analysis as preserved.
Result(const AnalysisManagerT &OuterAM)
Wrapper to model the analysis result concept.
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
static AnalysisSetKey * ID()
void abandon(AnalysisKey *ID)
Mark an analysis as abandoned using its ID.
A special type used by analysis passes to provide an address that identifies that particular analysis...
A utility pass that does nothing, but preserves no analyses.
Template for the abstract base class used to dispatch polymorphically over pass objects.
A no-op pass template which simply forces a specific analysis result to be invalidated.
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA, typename AnalysisManager< IRUnitT, ExtraArgTs... >::Invalidator &Inv)
Handler for invalidation of the outer IR unit, IRUnitT.
iterator find(const_arg_type_t< KeyT > Val)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
This class provides instrumentation entry points for the Pass Manager, doing calls to callbacks regis...
bool allAnalysesInSetPreserved() const
Directly test whether a set of analyses is preserved.
A Module instance is used to store all the information related to an LLVM module.
bool preservedWhenStateless()
Return true if the checker's analysis was not abandoned, i.e.
A CRTP mix-in that provides informational APIs needed for analysis passes.
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
void intersect(PreservedAnalyses &&Arg)
Intersect this set with a temporary other set in place.
RepeatedPass(int Count, PassT &&P)
PassManager()=default
Construct a pass manager.
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
StringRef - Represent a constant reference to a string, i.e.
PassT::Result getAnalysisResult(AnalysisManager< IRUnitT, AnalysisArgTs... > &AM, IRUnitT &IR, std::tuple< MainArgTs... > Args)
Helper for partial unpacking of extra arguments in getAnalysisResult.
bool areAllPreserved() const
Test whether all analyses are preserved (and none are abandoned).
Represents analyses that only rely on functions' control flow.
Result(AnalysisManagerT &InnerAM)
AnalysisManager()
Construct an empty analysis manager.
void verifyNotInvalidated(IRUnitT &IR, typename PassT::Result *Result) const
Verify that the given Result cannot be invalidated, assert otherwise.
PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, Ts &&... Args)
static StringRef name()
Gets the name of the pass we are mixed into.
PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&... Args)
Run this pass over some unit of IR.
Manages a sequence of passes over a particular unit of IR.
LLVM_NODISCARD bool empty() const
A utility pass template that simply runs another pass multiple times.
void clear()
Clear all analysis results cached by this AnalysisManager.
bool preserved()
Returns true if the checker's analysis was not abandoned and either.
Result & operator=(Result &&RHS)
bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const
BeforePass instrumentation point - takes Pass instance to be executed and constant reference to IR it...
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
PassT::Result * getCachedResult(IRUnitT &IR) const
Get the cached result of an analysis pass for a given IR unit.
bool allAnalysesInSetPreserved(AnalysisSetKey *SetID) const
Directly test whether a set of analyses is preserved.
ModuleToFunctionPassAdaptor(std::unique_ptr< PassConceptT > Pass, bool EagerlyInvalidate)
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)
Run all of the passes in this manager over the given unit of IR.
AnalysisManager & operator=(AnalysisManager &&)
Wrapper to model the analysis pass concept.
bool invalidate(AnalysisKey *ID, IRUnitT &IR, const PreservedAnalyses &PA)
A type-erased variant of the above invalidate method with the same core API other than passing an ana...
Pass interface - Implemented by all 'passes'.
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
void registerOuterAnalysisInvalidation()
Register a deferred invalidation event for when the outer analysis manager processes its invalidation...
void preserveSet()
Mark an analysis set as preserved.
DenseMapIterator< AnalysisKey *, std::unique_ptr< PassConceptT >, DenseMapInfo< AnalysisKey * >, llvm::detail::DenseMapPair< AnalysisKey *, std::unique_ptr< PassConceptT > > > iterator
AnalysisManagerT & getManager()
Accessor for the analysis manager.
A template wrapper used to implement the polymorphic API.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
PassT::Result * getCachedResult(IRUnitTParam &IR) const
Get a cached analysis.
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
A container for analyses that lazily runs them and caches their results.
Pseudo-analysis pass that exposes the PassInstrumentation to pass managers.
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
A utility pass template to force an analysis result to be available.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
static PreservedAnalyses allInSet()
Construct a preserved analyses object with a single preserved set.
Result run(IRUnitT &IR, AnalysisManager< IRUnitT, ExtraArgTs... > &AM, ExtraArgTs...)
Run the analysis pass and create our proxy result object.
InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy
Provide the FunctionAnalysisManager to Module proxy.
static const char PassName[]
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
const SmallDenseMap< AnalysisKey *, TinyPtrVector< AnalysisKey * >, 2 > & getOuterInvalidations() const
Access the map from outer analyses to deferred invalidation requiring analyses.