37#ifndef LLVM_IR_PASSMANAGER_H
38#define LLVM_IR_PASSMANAGER_H
76 IR.convertToNewDbgValues();
80 IR.convertFromNewDbgValues();
118template <
typename IRUnitT> AnalysisSetKey AllAnalysesOn<IRUnitT>::SetKey;
120extern template class AllAnalysesOn<Module>;
121extern template class AllAnalysesOn<Function>;
180 PA.PreservedIDs.
insert(&AllAnalysesKey);
185 template <
typename AnalysisSetT>
199 NotPreservedAnalysisIDs.erase(
ID);
203 if (!areAllPreserved())
204 PreservedIDs.insert(
ID);
209 preserveSet(AnalysisSetT::ID());
215 if (!areAllPreserved())
216 PreservedIDs.insert(
ID);
236 PreservedIDs.erase(
ID);
237 NotPreservedAnalysisIDs.insert(
ID);
247 if (areAllPreserved()) {
253 for (
auto *
ID : Arg.NotPreservedAnalysisIDs) {
254 PreservedIDs.erase(
ID);
255 NotPreservedAnalysisIDs.insert(
ID);
257 for (
auto *
ID : PreservedIDs)
258 if (!Arg.PreservedIDs.
count(
ID))
259 PreservedIDs.erase(
ID);
267 if (Arg.areAllPreserved())
269 if (areAllPreserved()) {
270 *
this = std::move(Arg);
275 for (
auto *
ID : Arg.NotPreservedAnalysisIDs) {
276 PreservedIDs.erase(
ID);
277 NotPreservedAnalysisIDs.insert(
ID);
279 for (
auto *
ID : PreservedIDs)
280 if (!Arg.PreservedIDs.count(
ID))
281 PreservedIDs.erase(
ID);
291 const bool IsAbandoned;
297 : PA(PA),
ID(
ID), IsAbandoned(PA.NotPreservedAnalysisIDs.
count(
ID)) {}
304 return !IsAbandoned && (PA.PreservedIDs.
count(&AllAnalysesKey) ||
320 return !IsAbandoned && (PA.PreservedIDs.
count(&AllAnalysesKey) ||
321 PA.PreservedIDs.
count(SetID));
348 return NotPreservedAnalysisIDs.empty() &&
349 PreservedIDs.count(&AllAnalysesKey);
356 return allAnalysesInSetPreserved(AnalysisSetT::ID());
363 return NotPreservedAnalysisIDs.empty() &&
364 (PreservedIDs.count(&AllAnalysesKey) || PreservedIDs.count(SetID));
385template <
typename IRUnitT,
typename... ExtraArgTs>
class AnalysisManager;
394 static_assert(std::is_base_of<PassInfoMixin, DerivedT>::value,
395 "Must pass the derived type as the template argument!");
397 Name.consume_front(
"llvm::");
404 auto PassName = MapClassName2PassName(ClassName);
413template <
typename DerivedT>
431 static_assert(std::is_base_of<AnalysisInfoMixin, DerivedT>::value,
432 "Must pass the derived type as the template argument!");
433 return &DerivedT::Key;
441template <
typename PassT,
typename IRUnitT,
typename AnalysisManagerT,
442 typename... ArgTs,
size_t... Ns>
443typename PassT::Result
445 std::tuple<ArgTs...> Args,
446 std::index_sequence<Ns...>) {
448 return AM.template getResult<PassT>(
IR, std::get<Ns>(Args)...);
456template <
typename PassT,
typename IRUnitT,
typename... AnalysisArgTs,
457 typename... MainArgTs>
458typename PassT::Result
460 std::tuple<MainArgTs...> Args) {
462 PassT, IRUnitT>)(AM,
IR, Args,
463 std::index_sequence_for<AnalysisArgTs...>{});
472class PassInstrumentationAnalysis;
486template <
typename IRUnitT,
487 typename AnalysisManagerT = AnalysisManager<IRUnitT>,
488 typename... ExtraArgTs>
490 PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...>> {
510 P->printPipeline(
OS, MapClassName2PassName);
519 ExtraArgTs... ExtraArgs) {
527 detail::getAnalysisResult<PassInstrumentationAnalysis>(
528 AM,
IR, std::tuple<ExtraArgTs...>(ExtraArgs...));
533 if (ShouldConvertDbgInfo)
547 AM.invalidate(
IR, PassPA);
558 if (ShouldConvertDbgInfo)
570 template <
typename PassT>
572 std::enable_if_t<!std::is_same<PassT, PassManager>::value>
579 Passes.push_back(std::unique_ptr<PassConceptT>(
580 new PassModelT(std::forward<PassT>(
Pass))));
588 template <
typename PassT>
590 std::enable_if_t<std::is_same<PassT, PassManager>::value>
592 for (
auto &
P :
Pass.Passes)
593 Passes.push_back(std::move(
P));
605 std::vector<std::unique_ptr<PassConceptT>>
Passes;
634 : Callbacks(Callbacks) {}
638 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... ExtraArgTs>
639 Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
667 using AnalysisResultListT =
668 std::list<std::pair<AnalysisKey *, std::unique_ptr<ResultConceptT>>>;
678 typename AnalysisResultListT::iterator>;
707 template <
typename PassT>
713 return invalidateImpl<ResultModelT>(PassT::ID(),
IR, PA);
723 return invalidateImpl<>(
ID,
IR, PA);
729 template <
typename ResultT = ResultConceptT>
734 auto IMapI = IsResultInvalidated.find(
ID);
735 if (IMapI != IsResultInvalidated.end())
736 return IMapI->second;
741 "Trying to invalidate a dependent result that isn't in the "
742 "manager's cache is always an error, likely due to a stale result "
745 auto &Result =
static_cast<ResultT &
>(*RI->second->second);
752 std::tie(IMapI, Inserted) =
753 IsResultInvalidated.insert({
ID, Result.invalidate(
IR, PA, *
this)});
755 assert(Inserted &&
"Should not have already inserted this ID, likely "
756 "indicates a dependency cycle!");
757 return IMapI->second;
760 Invalidator(SmallDenseMap<AnalysisKey *, bool, 8> &IsResultInvalidated,
761 const AnalysisResultMapT &
Results)
764 SmallDenseMap<AnalysisKey *, bool, 8> &IsResultInvalidated;
765 const AnalysisResultMapT &
Results;
776 "The storage and index of analysis results disagree on how many "
778 return AnalysisResults.
empty();
795 AnalysisResults.
clear();
796 AnalysisResultLists.
clear();
802 template <
typename PassT>
803 typename PassT::Result &
getResult(IRUnitT &
IR, ExtraArgTs... ExtraArgs) {
805 "This analysis pass was not registered prior to being queried");
807 getResultImpl(PassT::ID(),
IR, ExtraArgs...);
813 return static_cast<ResultModelT &
>(ResultConcept).Result;
821 template <
typename PassT>
824 "This analysis pass was not registered prior to being queried");
834 return &
static_cast<ResultModelT *
>(ResultConcept)->Result;
838 template <
typename PassT>
842 Invalidator Inv(IsResultInvalidated, AnalysisResults);
843 assert(!Result->invalidate(
IR, PA, Inv) &&
844 "Cached result cannot be invalidated");
864 template <
typename PassBuilderT>
871 auto &PassPtr = AnalysisPasses[PassT::ID()];
892 "Analysis passes must be registered prior to being queried!");
897 const PassConceptT &lookUpPass(AnalysisKey *
ID)
const {
900 "Analysis passes must be registered prior to being queried!");
905 ResultConceptT &getResultImpl(AnalysisKey *
ID, IRUnitT &
IR,
906 ExtraArgTs... ExtraArgs);
909 ResultConceptT *getCachedResultImpl(AnalysisKey *
ID, IRUnitT &
IR)
const {
912 return RI == AnalysisResults.
end() ? nullptr : &*RI->second->second;
916 using AnalysisPassMapT =
917 DenseMap<AnalysisKey *, std::unique_ptr<PassConceptT>>;
920 AnalysisPassMapT AnalysisPasses;
926 AnalysisResultListMapT AnalysisResultLists;
930 AnalysisResultMapT AnalysisResults;
933extern template class AnalysisManager<Module>;
959template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
962 InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {
966 explicit Result(AnalysisManagerT &InnerAM) : InnerAM(&InnerAM) {}
972 Arg.InnerAM =
nullptr;
986 InnerAM =
RHS.InnerAM;
990 RHS.InnerAM =
nullptr;
1012 AnalysisManagerT *InnerAM;
1016 : InnerAM(&InnerAM) {}
1034 AnalysisManagerT *InnerAM;
1037template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
1039 InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>::Key;
1048bool FunctionAnalysisManagerModuleProxy::Result::invalidate(
1084template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
1087 OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>> {
1092 explicit Result(
const AnalysisManagerT &OuterAM) : OuterAM(&OuterAM) {}
1096 template <
typename PassT,
typename IRUnitTParam>
1098 typename PassT::Result *Res =
1099 OuterAM->template getCachedResult<PassT>(
IR);
1101 OuterAM->template verifyNotInvalidated<PassT>(
IR, Res);
1106 template <
typename PassT,
typename IRUnitTParam>
1108 typename PassT::Result *Res =
1109 OuterAM->template getCachedResult<PassT>(
IR);
1110 return Res !=
nullptr;
1120 for (
auto &KeyValuePair : OuterAnalysisInvalidationMap) {
1122 auto &InnerIDs = KeyValuePair.second;
1126 if (InnerIDs.empty())
1130 for (
auto *OuterID : DeadKeys)
1131 OuterAnalysisInvalidationMap.erase(OuterID);
1139 template <
typename OuterAnalysisT,
typename Inval
idatedAnalysisT>
1142 AnalysisKey *InvalidatedID = InvalidatedAnalysisT::ID();
1144 auto &InvalidatedIDList = OuterAnalysisInvalidationMap[OuterID];
1150 InvalidatedIDList.push_back(InvalidatedID);
1157 return OuterAnalysisInvalidationMap;
1161 const AnalysisManagerT *OuterAM;
1166 OuterAnalysisInvalidationMap;
1170 : OuterAM(&OuterAM) {}
1186 const AnalysisManagerT *OuterAM;
1189template <
typename AnalysisManagerT,
typename IRUnitT,
typename... ExtraArgTs>
1191 OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>::Key;
1228 bool EagerlyInvalidate)
1239 std::unique_ptr<PassConceptT>
Pass;
1240 bool EagerlyInvalidate;
1245template <
typename FunctionPassT>
1246ModuleToFunctionPassAdaptor
1248 bool EagerlyInvalidate =
false) {
1255 std::unique_ptr<ModuleToFunctionPassAdaptor::PassConceptT>(
1256 new PassModelT(std::forward<FunctionPassT>(
Pass))),
1269template <
typename AnalysisT,
typename IRUnitT,
1270 typename AnalysisManagerT = AnalysisManager<IRUnitT>,
1271 typename... ExtraArgTs>
1273 :
PassInfoMixin<RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
1282 ExtraArgTs &&... Args) {
1283 (void)AM.template getResult<AnalysisT>(Arg,
1284 std::forward<ExtraArgTs>(Args)...);
1290 auto ClassName = AnalysisT::name();
1291 auto PassName = MapClassName2PassName(ClassName);
1299template <
typename AnalysisT>
1308 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... ExtraArgTs>
1316 auto ClassName = AnalysisT::name();
1317 auto PassName = MapClassName2PassName(ClassName);
1328 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... ExtraArgTs>
1338template <
typename PassT>
1342 : Count(Count), P(
std::forward<PassT>(P)) {}
1344 template <
typename IRUnitT,
typename AnalysisManagerT,
typename... Ts>
1352 detail::getAnalysisResult<PassInstrumentationAnalysis>(
1353 AM,
IR, std::tuple<Ts...>(Args...));
1356 for (
int i = 0; i < Count; ++i) {
1371 OS <<
"repeat<" << Count <<
">(";
1372 P.printPipeline(
OS, MapClassName2PassName);
1381template <
typename PassT>
Function Alias Analysis Results
#define LLVM_ATTRIBUTE_MINSIZE
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines the DenseMap class.
Legalize the Machine IR a function s Machine IR
Module.h This file contains the declarations for the Module class.
This file defines the Pass Instrumentation classes that provide instrumentation points into the pass ...
This header provides internal APIs and implementation details used by the pass management interfaces ...
llvm::cl::opt< bool > UseNewDbgInfoFormat
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallPtrSet class.
static const char PassName[]
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
static AnalysisSetKey * ID()
API to communicate dependencies between analyses during invalidation.
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...
bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Trigger the invalidation of some other analysis pass if not already handled and return whether it was...
A container for analyses that lazily runs them and caches their results.
AnalysisManager()
Construct an empty analysis manager.
void clear()
Clear all analysis results cached by this AnalysisManager.
AnalysisManager(AnalysisManager &&)
void verifyNotInvalidated(IRUnitT &IR, typename PassT::Result *Result) const
Verify that the given Result cannot be invalidated, assert otherwise.
AnalysisManager & operator=(AnalysisManager &&)
void invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Invalidate cached analyses for an IR unit.
PassT::Result * getCachedResult(IRUnitT &IR) const
Get the cached result of an analysis pass for a given IR unit.
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
bool empty() const
Returns true if the analysis manager has an empty results cache.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represents analyses that only rely on functions' control flow.
static AnalysisSetKey * ID()
iterator find(const_arg_type_t< KeyT > Val)
DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT > iterator
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT, true > const_iterator
bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA, typename AnalysisManager< IRUnitT, ExtraArgTs... >::Invalidator &Inv)
Handler for invalidation of the outer IR unit, IRUnitT.
Result(AnalysisManagerT &InnerAM)
Result & operator=(Result &&RHS)
AnalysisManagerT & getManager()
Accessor for the analysis manager.
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Result run(IRUnitT &IR, AnalysisManager< IRUnitT, ExtraArgTs... > &AM, ExtraArgTs...)
Run the analysis pass and create our proxy result object.
InnerAnalysisManagerProxy(AnalysisManagerT &InnerAM)
Trivial adaptor that maps from a module to its functions.
ModuleToFunctionPassAdaptor(std::unique_ptr< PassConceptT > Pass, bool EagerlyInvalidate)
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Runs the function pass across every function in the module.
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
A Module instance is used to store all the information related to an LLVM module.
Result proxy object for OuterAnalysisManagerProxy.
Result(const AnalysisManagerT &OuterAM)
PassT::Result * getCachedResult(IRUnitTParam &IR) const
Get a cached analysis.
bool invalidate(IRUnitT &IRUnit, const PreservedAnalyses &PA, typename AnalysisManager< IRUnitT, ExtraArgTs... >::Invalidator &Inv)
When invalidation occurs, remove any registered invalidation events.
bool cachedResultExists(IRUnitTParam &IR) const
Method provided for unit testing, not intended for general use.
const SmallDenseMap< AnalysisKey *, TinyPtrVector< AnalysisKey * >, 2 > & getOuterInvalidations() const
Access the map from outer analyses to deferred invalidation requiring analyses.
void registerOuterAnalysisInvalidation()
Register a deferred invalidation event for when the outer analysis manager processes its invalidation...
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
Result run(IRUnitT &, AnalysisManager< IRUnitT, ExtraArgTs... > &, ExtraArgTs...)
Run the analysis pass and create our proxy result object.
OuterAnalysisManagerProxy(const AnalysisManagerT &OuterAM)
This class provides access to building LLVM's passes.
Pseudo-analysis pass that exposes the PassInstrumentation to pass managers.
Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...)
PassInstrumentationAnalysis(PassInstrumentationCallbacks *Callbacks=nullptr)
PassInstrumentationCallbacks object is shared, owned by something else, not this analysis.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
This class provides instrumentation entry points for the Pass Manager, doing calls to callbacks regis...
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...
bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const
BeforePass instrumentation point - takes Pass instance to be executed and constant reference to IR it...
Manages a sequence of passes over a particular unit of IR.
PassManager(PassManager &&Arg)
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
PassManager & operator=(PassManager &&RHS)
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
std::vector< std::unique_ptr< PassConceptT > > Passes
PassManager()=default
Construct a pass manager.
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...
PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)
Run all of the passes in this manager over the given unit of IR.
bool isEmpty() const
Returns if the pass manager contains any passes.
Pass interface - Implemented by all 'passes'.
A checker object that makes it easy to query for whether an analysis or some set covering it is prese...
bool preserved()
Returns true if the checker's analysis was not abandoned and either.
bool preservedWhenStateless()
Return true if the checker's analysis was not abandoned, i.e.
bool preservedSet()
Returns true if the checker's analysis was not abandoned and either.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
void preserveSet(AnalysisSetKey *ID)
Mark an analysis set as preserved using its ID.
bool areAllPreserved() const
Test whether all analyses are preserved (and none are abandoned).
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
bool allAnalysesInSetPreserved() const
Directly test whether a set of analyses is preserved.
PreservedAnalysisChecker getChecker(AnalysisKey *ID) const
Build a checker for this PreservedAnalyses and the specified analysis ID.
void intersect(const PreservedAnalyses &Arg)
Intersect this set with another in place.
void intersect(PreservedAnalyses &&Arg)
Intersect this set with a temporary other set in place.
void abandon(AnalysisKey *ID)
Mark an analysis as abandoned using its ID.
bool allAnalysesInSetPreserved(AnalysisSetKey *SetID) const
Directly test whether a set of analyses is preserved.
void preserveSet()
Mark an analysis set as preserved.
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
void preserve(AnalysisKey *ID)
Given an analysis's ID, mark the analysis as preserved, adding it to the set.
void abandon()
Mark an analysis as abandoned.
void preserve()
Mark an analysis as preserved.
static PreservedAnalyses allInSet()
Construct a preserved analyses object with a single preserved set.
A utility pass template that simply runs another pass multiple times.
PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, Ts &&... Args)
RepeatedPass(int Count, PassT &&P)
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
An efficient, type-erasing, non-owning reference to a callable.
This class implements an extremely fast bulk output stream that can only output to a stream.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
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...
PassT::Result getAnalysisResult(AnalysisManager< IRUnitT, AnalysisArgTs... > &AM, IRUnitT &IR, std::tuple< MainArgTs... > Args)
Helper for partial unpacking of extra arguments in getAnalysisResult.
This is an optimization pass for GlobalISel generic memory operations.
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
RepeatedPass< PassT > createRepeatedPass(int Count, PassT &&P)
void doConvertDebugInfoToOld(IRUnitT &IR)
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
void doConvertDbgInfoToNew(IRUnitT &IR)
bool shouldConvertDbgInfo(IRUnitT &IR)
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...
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
Implement std::hash so that hash_code can be used in STL containers.
A CRTP mix-in that provides informational APIs needed for analysis passes.
static AnalysisKey * ID()
Returns an opaque, unique ID for this analysis type.
A special type used by analysis passes to provide an address that identifies that particular analysis...
A special type used to provide an address that identifies a set of related analyses.
A utility pass that does nothing, but preserves no analyses.
PreservedAnalyses run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...)
Run this pass over some unit of IR.
A no-op pass template which simply forces a specific analysis result to be invalidated.
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...)
Run this pass over some unit of IR.
A CRTP mix-in to automatically provide informational APIs needed for passes.
static StringRef name()
Gets the name of the pass we are mixed into.
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
A utility pass template to force an analysis result to be available.
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&... Args)
Run this pass over some unit of IR.
Abstract concept of an analysis pass.
Wrapper to model the analysis pass concept.
Abstract concept of an analysis result.
Wrapper to model the analysis result concept.
A template wrapper used to implement the polymorphic API.