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!");
376 StringRef Name = getTypeName<DerivedT>();
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...));
525 AM.invalidate(
IR, PassPA);
541 template <
typename PassT>
543 std::enable_if_t<!std::is_same<PassT, PassManager>::value>
550 Passes.push_back(std::unique_ptr<PassConceptT>(
551 new PassModelT(std::forward<PassT>(
Pass))));
559 template <
typename PassT>
561 std::enable_if_t<std::is_same<PassT, PassManager>::value>
563 for (
auto &
P :
Pass.Passes)
576 std::vector<std::unique_ptr<PassConceptT>>
Passes;
605 : Callbacks(Callbacks) {}
609 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... ExtraArgTs>
610 Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
620 template <
typename IRUnitT,
typename... ExtraArgTs>
class AnalysisManager {
626 using ResultConceptT =
627 detail::AnalysisResultConcept<IRUnitT, PreservedAnalyses, Invalidator>;
629 detail::AnalysisPassConcept<IRUnitT, PreservedAnalyses, Invalidator,
638 using AnalysisResultListT =
639 std::list<std::pair<AnalysisKey *, std::unique_ptr<ResultConceptT>>>;
642 using AnalysisResultListMapT = DenseMap<IRUnitT *, AnalysisResultListT>;
647 using AnalysisResultMapT =
648 DenseMap<std::pair<AnalysisKey *, IRUnitT *>,
649 typename AnalysisResultListT::iterator>;
678 template <
typename PassT>
684 return invalidateImpl<ResultModelT>(
PassT::ID(),
IR, PA);
694 return invalidateImpl<>(
ID,
IR, PA);
700 template <
typename ResultT = ResultConceptT>
705 auto IMapI = IsResultInvalidated.find(
ID);
706 if (IMapI != IsResultInvalidated.end())
707 return IMapI->second;
712 "Trying to invalidate a dependent result that isn't in the "
713 "manager's cache is always an error, likely due to a stale result "
716 auto &Result =
static_cast<ResultT &
>(*RI->second->second);
723 std::tie(IMapI, Inserted) =
724 IsResultInvalidated.insert({
ID, Result.invalidate(
IR, PA, *
this)});
726 assert(Inserted &&
"Should not have already inserted this ID, likely "
727 "indicates a dependency cycle!");
728 return IMapI->second;
731 Invalidator(SmallDenseMap<AnalysisKey *, bool, 8> &IsResultInvalidated,
732 const AnalysisResultMapT &
Results)
735 SmallDenseMap<AnalysisKey *, bool, 8> &IsResultInvalidated;
736 const AnalysisResultMapT &
Results;
747 "The storage and index of analysis results disagree on how many "
749 return AnalysisResults.
empty();
766 AnalysisResults.
clear();
767 AnalysisResultLists.
clear();
773 template <
typename PassT>
774 typename PassT::Result &
getResult(IRUnitT &
IR, ExtraArgTs... ExtraArgs) {
776 "This analysis pass was not registered prior to being queried");
784 return static_cast<ResultModelT &
>(ResultConcept).Result;
792 template <
typename PassT>
795 "This analysis pass was not registered prior to being queried");
805 return &
static_cast<ResultModelT *
>(ResultConcept)->Result;
809 template <
typename PassT>
813 Invalidator Inv(IsResultInvalidated, AnalysisResults);
814 assert(!Result->invalidate(
IR, PA, Inv) &&
815 "Cached result cannot be invalidated");
835 template <
typename PassBuilderT>
840 Invalidator, ExtraArgTs...>;
842 auto &PassPtr = AnalysisPasses[
PassT::ID()];
863 "Analysis passes must be registered prior to being queried!");
868 const PassConceptT &lookUpPass(AnalysisKey *
ID)
const {
871 "Analysis passes must be registered prior to being queried!");
876 ResultConceptT &getResultImpl(AnalysisKey *
ID, IRUnitT &
IR,
877 ExtraArgTs... ExtraArgs);
880 ResultConceptT *getCachedResultImpl(AnalysisKey *
ID, IRUnitT &
IR)
const {
883 return RI == AnalysisResults.
end() ? nullptr : &*RI->second->second;
887 using AnalysisPassMapT =
888 DenseMap<AnalysisKey *, std::unique_ptr<PassConceptT>>;
891 AnalysisPassMapT AnalysisPasses;
897 AnalysisResultListMapT AnalysisResultLists;
901 AnalysisResultMapT AnalysisResults;
904 extern template class AnalysisManager<Module>;
930 template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
933 InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {
937 explicit Result(AnalysisManagerT &InnerAM) : InnerAM(&InnerAM) {}
943 Arg.InnerAM =
nullptr;
957 InnerAM =
RHS.InnerAM;
961 RHS.InnerAM =
nullptr;
983 AnalysisManagerT *InnerAM;
987 : InnerAM(&InnerAM) {}
1005 AnalysisManagerT *InnerAM;
1008 template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
1010 InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>
::Key;
1055 template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
1058 OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>> {
1063 explicit Result(
const AnalysisManagerT &OuterAM) : OuterAM(&OuterAM) {}
1067 template <
typename PassT,
typename IRUnitTParam>
1069 typename PassT::Result *Res =
1070 OuterAM->template getCachedResult<PassT>(
IR);
1072 OuterAM->template verifyNotInvalidated<PassT>(
IR, Res);
1077 template <
typename PassT,
typename IRUnitTParam>
1079 typename PassT::Result *Res =
1080 OuterAM->template getCachedResult<PassT>(
IR);
1081 return Res !=
nullptr;
1091 for (
auto &KeyValuePair : OuterAnalysisInvalidationMap) {
1093 auto &InnerIDs = KeyValuePair.second;
1097 if (InnerIDs.empty())
1098 DeadKeys.push_back(OuterID);
1101 for (
auto *OuterID : DeadKeys)
1102 OuterAnalysisInvalidationMap.
erase(OuterID);
1110 template <
typename OuterAnalysisT,
typename Inval
idatedAnalysisT>
1115 auto &InvalidatedIDList = OuterAnalysisInvalidationMap[OuterID];
1121 InvalidatedIDList.push_back(InvalidatedID);
1128 return OuterAnalysisInvalidationMap;
1132 const AnalysisManagerT *OuterAM;
1137 OuterAnalysisInvalidationMap;
1141 : OuterAM(&OuterAM) {}
1157 const AnalysisManagerT *OuterAM;
1160 template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
1162 OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>
::Key;
1199 bool EagerlyInvalidate)
1210 std::unique_ptr<PassConceptT>
Pass;
1211 bool EagerlyInvalidate;
1216 template <
typename FunctionPassT>
1217 ModuleToFunctionPassAdaptor
1219 bool EagerlyInvalidate =
false) {
1226 std::unique_ptr<ModuleToFunctionPassAdaptor::PassConceptT>(
1227 new PassModelT(std::forward<FunctionPassT>(
Pass))),
1240 template <
typename AnalysisT,
typename IRUnitT,
1241 typename AnalysisManagerT = AnalysisManager<IRUnitT>,
1242 typename... ExtraArgTs>
1244 :
PassInfoMixin<RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
1253 ExtraArgTs &&...
Args) {
1254 (void)AM.template getResult<AnalysisT>(
Arg,
1255 std::forward<ExtraArgTs>(
Args)...);
1262 auto PassName = MapClassName2PassName(ClassName);
1263 OS <<
"require<" <<
PassName <<
">";
1270 template <
typename AnalysisT>
1279 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... ExtraArgTs>
1288 auto PassName = MapClassName2PassName(ClassName);
1289 OS <<
"invalidate<" <<
PassName <<
">";
1299 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... ExtraArgTs>
1309 template <
typename PassT>
1313 : Count(Count), P(
std::forward<PassT>(P)) {}
1315 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... Ts>
1323 detail::getAnalysisResult<PassInstrumentationAnalysis>(
1324 AM,
IR, std::tuple<Ts...>(
Args...));
1327 for (
int i = 0;
i < Count; ++
i) {
1342 OS <<
"repeat<" << Count <<
">(";
1343 P.printPipeline(OS, MapClassName2PassName);
1352 template <
typename PassT>
1359 #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)
print lazy value Lazy Value Info Printer Pass
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.
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.