36#ifndef LLVM_TRANSFORMS_SCALAR_LOOPPASSMANAGER_H
37#define LLVM_TRANSFORMS_SCALAR_LOOPPASSMANAGER_H
53class PassInstrumentation;
57template <
typename PassT>
58using HasRunOnLoopT =
decltype(std::declval<PassT>().run(
59 std::declval<Loop &>(), std::declval<LoopAnalysisManager &>(),
60 std::declval<LoopStandardAnalysisResults &>(),
61 std::declval<LPMUpdater &>()));
82 : IsLoopNestPass(
std::
move(Arg.IsLoopNestPass)),
83 LoopPasses(
std::
move(Arg.LoopPasses)),
84 LoopNestPasses(
std::
move(Arg.LoopNestPasses)) {}
87 IsLoopNestPass = std::move(
RHS.IsLoopNestPass);
88 LoopPasses = std::move(
RHS.LoopPasses);
89 LoopNestPasses = std::move(
RHS.LoopNestPasses);
104 template <
typename PassT>
106 std::enable_if_t<is_detected<HasRunOnLoopT, PassT>::value>
108 using LoopPassModelT =
111 IsLoopNestPass.push_back(
false);
114 LoopPasses.push_back(std::unique_ptr<LoopPassConceptT>(
115 new LoopPassModelT(std::forward<PassT>(
Pass))));
118 template <
typename PassT>
120 std::enable_if_t<!is_detected<HasRunOnLoopT, PassT>::value>
122 using LoopNestPassModelT =
125 IsLoopNestPass.push_back(
true);
128 LoopNestPasses.push_back(std::unique_ptr<LoopNestPassConceptT>(
129 new LoopNestPassModelT(std::forward<PassT>(
Pass))));
135 template <
typename PassT>
137 std::enable_if_t<is_detected<HasRunOnLoopT, PassT>::value>
139 using RepeatedLoopPassModelT =
142 IsLoopNestPass.push_back(
false);
145 LoopPasses.push_back(std::unique_ptr<LoopPassConceptT>(
146 new RepeatedLoopPassModelT(std::move(
Pass))));
149 template <
typename PassT>
151 std::enable_if_t<!is_detected<HasRunOnLoopT, PassT>::value>
153 using RepeatedLoopNestPassModelT =
156 IsLoopNestPass.push_back(
true);
159 LoopNestPasses.push_back(std::unique_ptr<LoopNestPassConceptT>(
160 new RepeatedLoopNestPassModelT(std::move(
Pass))));
163 bool isEmpty()
const {
return LoopPasses.empty() && LoopNestPasses.empty(); }
187 template <
typename IRUnitT,
typename PassT>
188 std::optional<PreservedAnalyses>
201 static const Loop &getLoopFromIR(
Loop &L) {
return L; }
219template <
typename AnalysisT>
227 (void)AM.template getResult<AnalysisT>(L, AR);
232 auto ClassName = AnalysisT::name();
233 auto PassName = MapClassName2PassName(ClassName);
239template <
typename AnalysisT>
282 "Cannot delete a loop outside of the "
283 "subloop tree currently being processed.");
285 SkipCurrentLoop =
true;
289#ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
302 "Child loops should not be pushed in loop-nest mode.");
305 Worklist.insert(CurrentL);
308 for (
Loop *NewL : NewChildLoops)
309 assert(NewL->getParentLoop() == CurrentL &&
"All of the new loops must "
310 "be immediate children of "
311 "the current loop!");
318 SkipCurrentLoop =
true;
328#if defined(LLVM_ENABLE_ABI_BREAKING_CHECKS) && !defined(NDEBUG)
329 for (
Loop *NewL : NewSibLoops)
330 assert(NewL->getParentLoop() == ParentL &&
331 "All of the new loops must be siblings of the current loop!");
335 Worklist.insert(NewSibLoops);
350 SkipCurrentLoop =
true;
353 Worklist.insert(CurrentL);
357 return LoopNestChanged;
363 LoopNestChanged = Changed;
376 bool SkipCurrentLoop;
377 const bool LoopNestMode;
378 bool LoopNestChanged;
380#ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
388 bool LoopNestChanged =
false)
389 : Worklist(Worklist),
LAM(
LAM), LoopNestMode(LoopNestMode),
390 LoopNestChanged(LoopNestChanged) {}
393template <
typename IRUnitT,
typename PassT>
399 const Loop &L = getLoopFromIR(
IR);
402 if (!PI.runBeforePass<
Loop>(*
Pass, L))
408 if (U.skipCurrentLoop())
409 PI.runAfterPassInvalidated<IRUnitT>(*
Pass, PA);
411 PI.runAfterPass<
Loop>(*
Pass, L, PA);
439 bool UseMemorySSA =
false,
440 bool UseBlockFrequencyInfo =
false,
441 bool UseBranchProbabilityInfo =
false,
442 bool LoopNestMode =
false)
444 UseBlockFrequencyInfo(UseBlockFrequencyInfo),
445 UseBranchProbabilityInfo(UseBranchProbabilityInfo),
446 LoopNestMode(LoopNestMode) {
461 std::unique_ptr<PassConceptT>
Pass;
465 bool UseMemorySSA =
false;
466 bool UseBlockFrequencyInfo =
false;
467 bool UseBranchProbabilityInfo =
false;
468 const bool LoopNestMode;
475template <
typename LoopPassT>
476inline std::enable_if_t<is_detected<HasRunOnLoopT, LoopPassT>::value,
477 FunctionToLoopPassAdaptor>
479 bool UseBlockFrequencyInfo =
false,
480 bool UseBranchProbabilityInfo =
false) {
487 std::unique_ptr<FunctionToLoopPassAdaptor::PassConceptT>(
488 new PassModelT(std::forward<LoopPassT>(
Pass))),
489 UseMemorySSA, UseBlockFrequencyInfo, UseBranchProbabilityInfo,
false);
494template <
typename LoopNestPassT>
495inline std::enable_if_t<!is_detected<HasRunOnLoopT, LoopNestPassT>::value,
496 FunctionToLoopPassAdaptor>
498 bool UseBlockFrequencyInfo =
false,
499 bool UseBranchProbabilityInfo =
false) {
508 std::unique_ptr<FunctionToLoopPassAdaptor::PassConceptT>(
509 new PassModelT(std::move(LPM))),
510 UseMemorySSA, UseBlockFrequencyInfo, UseBranchProbabilityInfo,
true);
519 bool UseBranchProbabilityInfo) {
525 bool LoopNestMode = (LPM.getNumLoopPasses() == 0);
529 std::unique_ptr<FunctionToLoopPassAdaptor::PassConceptT>(
530 new PassModelT(std::move(LPM))),
531 UseMemorySSA, UseBlockFrequencyInfo, UseBranchProbabilityInfo,
aarch64 AArch64 CCMP Pass
#define LLVM_ATTRIBUTE_MINSIZE
Legalize the Machine IR a function s Machine IR
This header provides classes for managing per-loop analyses.
This file defines the interface for the loop nest analysis.
This header defines various interfaces for pass management in LLVM.
This file provides a priority worklist.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static const char PassName[]
A container for analyses that lazily runs them and caches their results.
void clear(IRUnitT &IR, llvm::StringRef Name)
Clear any cached analysis results for a single unit of IR.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
bool isLoopNestMode() const
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Runs the loop passes across every loop in the function.
FunctionToLoopPassAdaptor(std::unique_ptr< PassConceptT > Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool UseBranchProbabilityInfo=false, bool LoopNestMode=false)
Converts loops into loop-closed SSA form.
This class provides an interface for updating the loop pass manager based on mutations to the loop ne...
void markLoopNestChanged(bool Changed)
Loopnest passes should use this method to indicate if the loopnest has been modified.
void setParentLoop(Loop *L)
bool isLoopNestChanged() const
void revisitCurrentLoop()
Restart the current loop.
bool skipCurrentLoop() const
This can be queried by loop passes which run other loop passes (like pass managers) to know whether t...
void addChildLoops(ArrayRef< Loop * > NewChildLoops)
Loop passes should use this method to indicate they have added new child loops of the current loop.
void markLoopAsDeleted(Loop &L, llvm::StringRef Name)
Loop passes should use this method to indicate they have deleted a loop from the nest.
void addSiblingLoops(ArrayRef< Loop * > NewSibLoops)
Loop passes should use this method to indicate they have added new sibling loops to the current loop.
bool contains(const LoopT *L) const
Return true if the specified loop is contained within in this loop.
This class represents a loop nest and can be used to query its properties.
Loop & getOutermostLoop() const
Return the outermost loop in the loop nest.
This pass is responsible for loop canonicalization.
Represents a single loop in the control flow graph.
This class provides instrumentation entry points for the Pass Manager, doing calls to callbacks regis...
size_t getNumLoopPasses() const
PassManager(PassManager &&Arg)
size_t getNumLoopNestPasses() const
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t< is_detected< HasRunOnLoopT, PassT >::value > addPass(PassT &&Pass)
std::vector< std::unique_ptr< LoopNestPassConceptT > > LoopNestPasses
std::optional< PreservedAnalyses > runSinglePass(IRUnitT &IR, PassT &Pass, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &U, PassInstrumentation &PI)
Run either a loop pass or a loop-nest pass.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t< is_detected< HasRunOnLoopT, PassT >::value > addPass(RepeatedPass< PassT > &&Pass)
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!is_detected< HasRunOnLoopT, PassT >::value > addPass(PassT &&Pass)
std::vector< std::unique_ptr< LoopPassConceptT > > LoopPasses
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!is_detected< HasRunOnLoopT, PassT >::value > addPass(RepeatedPass< PassT > &&Pass)
PassManager & operator=(PassManager &&RHS)
Manages a sequence of passes over a particular unit of IR.
LLVM_ATTRIBUTE_MINSIZE void addPass(PassT &&Pass)
Pass interface - Implemented by all 'passes'.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Pass for printing a loop's contents as textual IR.
PreservedAnalyses run(Loop &L, LoopAnalysisManager &, LoopStandardAnalysisResults &, LPMUpdater &)
A utility pass template that simply runs another pass multiple times.
A version of PriorityWorklist that selects small size optimized data structures for the vector and ma...
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.
This is an optimization pass for GlobalISel generic memory operations.
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
PassManager< Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & > LoopPassManager
The Loop pass manager.
FunctionToLoopPassAdaptor createFunctionToLoopPassAdaptor< LoopPassManager >(LoopPassManager &&LPM, bool UseMemorySSA, bool UseBlockFrequencyInfo, bool UseBranchProbabilityInfo)
If Pass is an instance of LoopPassManager, the returned adaptor will be in loop-nest mode if the pass...
void appendLoopsToWorklist(RangeT &&, SmallPriorityWorklist< Loop *, 4 > &)
Utility that implements appending of loops onto a worklist given a range.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
std::enable_if_t< is_detected< HasRunOnLoopT, LoopPassT >::value, FunctionToLoopPassAdaptor > createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool UseBranchProbabilityInfo=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
Implement std::hash so that hash_code can be used in STL containers.
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
A CRTP mix-in to automatically provide informational APIs needed for passes.
A partial specialization of the require analysis template pass to forward the extra parameters from a...
PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &)
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
A utility pass template to force an analysis result to be available.
Template for the abstract base class used to dispatch polymorphically over pass objects.
A template wrapper used to implement the polymorphic API.