21 #include "llvm/ADT/Hashing.h"
22 #include "llvm/ADT/STLExtras.h"
23 #include "llvm/ADT/ScopeExit.h"
24 #include "llvm/Support/CommandLine.h"
25 #include "llvm/Support/CrashRecoveryContext.h"
26 #include "llvm/Support/Mutex.h"
27 #include "llvm/Support/Signals.h"
28 #include "llvm/Support/Threading.h"
29 #include "llvm/Support/ToolOutputFile.h"
40 os << llvm::formatv(
"`{0}` running `{1}` on Operation `{2}`", tag,
41 pass.getName(), getOp()->getName());
50 void Pass::anchor() {}
54 return passOptions.parseFromString(
options);
60 passOptions.copyOptionValuesFrom(other->passOptions);
67 if (
auto *adaptor = dyn_cast<OpToOpPassAdaptor>(
this)) {
69 adaptor->getPassManagers(),
77 StringRef argument = getArgument();
78 if (!argument.empty())
81 os <<
"unknown<" << getName() <<
">";
82 passOptions.print(os);
93 : name(opName.getStringRef().str()), opName(opName),
94 initializationGeneration(0), nesting(nesting) {}
96 : name(name ==
OpPassManager::getAnyOpAnchorName() ?
"" : name.str()),
97 initializationGeneration(0), nesting(nesting) {}
99 : initializationGeneration(0), nesting(nesting) {}
101 : name(rhs.name), opName(rhs.opName),
102 initializationGeneration(rhs.initializationGeneration),
103 nesting(rhs.nesting) {
104 for (
const std::unique_ptr<Pass> &pass : rhs.
passes) {
105 std::unique_ptr<Pass> newPass = pass->clone();
106 newPass->threadingSibling = pass.get();
107 passes.push_back(std::move(newPass));
129 void addPass(std::unique_ptr<Pass> pass);
142 if (!name.empty() && !opName)
147 return name.empty() ? std::optional<StringRef>()
148 : std::optional<StringRef>(name);
170 std::vector<std::unique_ptr<Pass>>
passes;
184 assert(
name == rhs.
name &&
"merging unrelated pass managers");
186 rhs.
passes.push_back(std::move(pass));
192 addPass(std::unique_ptr<Pass>(adaptor));
193 return adaptor->getPassManagers().front();
199 std::optional<StringRef> pmOpName =
getOpName();
200 std::optional<StringRef> passOpName = pass->getOpName();
201 if (pmOpName && passOpName && *pmOpName != *passOpName) {
204 llvm::report_fatal_error(llvm::Twine(
"Can't add pass '") + pass->getName() +
205 "' restricted to '" + *passOpName +
206 "' on a PassManager intended to run on '" +
210 passes.emplace_back(std::move(pass));
217 for (
auto &pm : adaptor->getPassManagers())
218 if (
failed(pm.getImpl().finalizePassList(ctx)))
225 for (
auto &pass :
passes) {
227 if (
auto *currentAdaptor = dyn_cast<OpToOpPassAdaptor>(pass.get())) {
231 lastAdaptor = currentAdaptor;
237 if (
succeeded(currentAdaptor->tryMergeInto(ctx, *lastAdaptor)))
240 lastAdaptor = currentAdaptor;
241 }
else if (lastAdaptor) {
243 if (
failed(finalizeAdaptor(lastAdaptor)))
245 lastAdaptor =
nullptr;
250 if (lastAdaptor &&
failed(finalizeAdaptor(lastAdaptor)))
255 llvm::erase_if(
passes, std::logical_not<std::unique_ptr<Pass>>());
258 std::optional<OperationName> rawOpName =
getOpName(*ctx);
264 std::optional<RegisteredOperationName>
opName =
265 rawOpName->getRegisteredInfo();
266 for (std::unique_ptr<Pass> &pass :
passes) {
269 <<
"unable to schedule pass '" << pass->getName()
281 std::optional<OperationName> pmOpName =
getOpName(context);
283 return pmOpName ==
opName;
287 std::optional<RegisteredOperationName> registeredInfo =
288 opName.getRegisteredInfo();
289 if (!registeredInfo ||
292 return llvm::all_of(
passes, [&](
const std::unique_ptr<Pass> &pass) {
293 return pass->canScheduleOn(*registeredInfo);
310 impl = std::make_unique<OpPassManagerImpl>(*rhs.impl);
314 impl = std::move(rhs.impl);
337 return impl->nest(nestedName);
340 return impl->nest(nestedName);
347 impl->addPass(std::move(pass));
360 return impl->getOpName();
364 std::optional<OperationName>
366 return impl->getOpName(context);
370 return impl->getOpAnchorName();
379 [&](
const std::unique_ptr<Pass> &pass) {
380 pass->printAsTextualPipeline(os);
382 [&]() { os <<
","; });
387 llvm::errs() <<
"Pass Manager with " <<
impl->passes.size() <<
" passes:\n";
389 llvm::errs() <<
"\n";
395 pass.getDependentDialects(dialects);
407 unsigned newInitGeneration) {
408 if (
impl->initializationGeneration == newInitGeneration)
410 impl->initializationGeneration = newInitGeneration;
413 auto *adaptor = dyn_cast<OpToOpPassAdaptor>(&pass);
415 if (
failed(pass.initialize(context)))
422 if (
failed(adaptorPM.initialize(context, newInitGeneration)))
428 llvm::hash_code OpPassManager::hash() {
429 llvm::hash_code hashCode{};
432 auto *adaptor = dyn_cast<OpToOpPassAdaptor>(&pass);
434 hashCode = llvm::hash_combine(hashCode, &pass);
439 llvm::hash_combine(hashCode, adaptorPM.hash());
451 unsigned parentInitGeneration) {
455 <<
"trying to schedule a pass on an unregistered operation";
457 return op->
emitOpError() <<
"trying to schedule a pass on an operation not "
458 "marked as 'IsolatedFromAbove'";
461 <<
"trying to schedule a pass on an unsupported operation";
471 return root->emitOpError()
472 <<
"Trying to schedule a dynamic pipeline on an "
473 "operation that isn't "
474 "nested under the current operation the pass is processing";
483 if (
failed(pipeline.initialize(root->getContext(), parentInitGeneration)))
486 return OpToOpPassAdaptor::runPipeline(pipeline, root, nestedAm,
487 verifyPasses, parentInitGeneration,
490 pass->passState.emplace(op, am, dynamicPipelineCallback);
496 bool passFailed =
false;
500 if (
auto *adaptor = dyn_cast<OpToOpPassAdaptor>(pass))
501 adaptor->runOnOperation(verifyPasses);
504 passFailed = pass->passState->irAndPassFailed.getInt();
509 am.
invalidate(pass->passState->preservedAnalyses);
513 if (!passFailed && verifyPasses) {
514 bool runVerifierNow =
true;
519 bool runVerifierRecursively = !isa<OpToOpPassAdaptor>(pass);
528 #ifndef EXPENSIVE_CHECKS
529 runVerifierNow = !pass->passState->preservedAnalyses.isAll();
532 passFailed =
failed(
verify(op, runVerifierRecursively));
552 assert((!instrumentor || parentInfo) &&
553 "expected parent info if instrumentor is provided");
554 auto scopeExit = llvm::make_scope_exit([&] {
569 if (
failed(run(&pass, op, am, verifyPasses, parentInitGeneration)))
583 auto *it = llvm::find_if(
585 return it == mgrs.end() ? nullptr : &*it;
594 return mgr.
getImpl().canScheduleOn(context, name);
596 return it == mgrs.end() ? nullptr : &*it;
600 mgrs.emplace_back(std::move(mgr));
604 for (
auto &pm : mgrs)
621 if (std::optional<OperationName> pmOpName = pm.
getOpName(*ctx))
634 auto *lhsGenericPMIt = llvm::find_if(mgrs, isGenericPM);
635 if (lhsGenericPMIt != mgrs.end() &&
636 hasScheduleConflictWith(*lhsGenericPMIt, rhs.mgrs))
639 auto *rhsGenericPMIt = llvm::find_if(rhs.mgrs, isGenericPM);
640 if (rhsGenericPMIt != rhs.mgrs.end() &&
641 hasScheduleConflictWith(*rhsGenericPMIt, mgrs))
644 for (
auto &pm : mgrs) {
647 if (
auto *existingPM =
652 rhs.mgrs.emplace_back(std::move(pm));
660 if (std::optional<StringRef> lhsName = lhs->
getOpName()) {
661 if (std::optional<StringRef> rhsName = rhs->
getOpName())
662 return lhsName->compare(*rhsName);
667 llvm::array_pod_sort(rhs.mgrs.begin(), rhs.mgrs.end(), compareFn);
672 std::string OpToOpPassAdaptor::getAdaptorName() {
673 std::string name =
"Pipeline Collection : [";
674 llvm::raw_string_ostream os(name);
675 llvm::interleaveComma(getPassManagers(), os, [&](
OpPassManager &pm) {
682 void OpToOpPassAdaptor::runOnOperation() {
684 "Unexpected call to Pass::runOnOperation() on OpToOpPassAdaptor");
688 void OpToOpPassAdaptor::runOnOperation(
bool verifyPasses) {
690 runOnOperationAsyncImpl(verifyPasses);
692 runOnOperationImpl(verifyPasses);
696 void OpToOpPassAdaptor::runOnOperationImpl(
bool verifyPasses) {
697 auto am = getAnalysisManager();
701 for (
auto ®ion : getOperation()->getRegions()) {
702 for (
auto &block : region) {
703 for (
auto &op : block) {
709 unsigned initGeneration = mgr->impl->initializationGeneration;
710 if (
failed(runPipeline(*mgr, &op, am.
nest(&op), verifyPasses,
711 initGeneration, instrumentor, &parentInfo)))
712 return signalPassFailure();
722 return lhs.size() != rhs.size() ||
723 llvm::any_of(llvm::seq<size_t>(0, lhs.size()),
724 [&](
size_t i) { return lhs[i].size() != rhs[i].size(); });
728 void OpToOpPassAdaptor::runOnOperationAsyncImpl(
bool verifyPasses) {
734 if (asyncExecutors.empty() ||
hasSizeMismatch(asyncExecutors.front(), mgrs))
735 asyncExecutors.assign(context->
getThreadPool().getThreadCount(), mgrs);
741 : passManagerIdx(passManagerIdx), op(op), am(am) {}
744 unsigned passManagerIdx;
754 std::vector<OpPMInfo> opInfos;
756 for (
auto ®ion : getOperation()->getRegions()) {
759 auto pmIdxIt = knownOpPMIdx.try_emplace(op.
getName(), std::nullopt);
760 if (pmIdxIt.second) {
762 pmIdxIt.first->second = std::distance(mgrs.begin(), mgr);
766 if (pmIdxIt.first->second)
767 opInfos.emplace_back(*pmIdxIt.first->second, &op, am.
nest(&op));
777 std::vector<std::atomic<bool>> activePMs(asyncExecutors.size());
778 std::fill(activePMs.begin(), activePMs.end(),
false);
779 auto processFn = [&](OpPMInfo &opInfo) {
781 auto it = llvm::find_if(activePMs, [](std::atomic<bool> &isActive) {
782 bool expectedInactive =
false;
783 return isActive.compare_exchange_strong(expectedInactive,
true);
785 unsigned pmIndex = it - activePMs.begin();
788 OpPassManager &pm = asyncExecutors[pmIndex][opInfo.passManagerIdx];
790 pm, opInfo.op, opInfo.am, verifyPasses,
791 pm.impl->initializationGeneration, instrumentor, &parentInfo);
794 activePMs[pmIndex].store(
false);
795 return pipelineResult;
809 :
OpPassManager(operationName, nesting), context(ctx), passTiming(false),
810 verifyPasses(true) {}
814 context(operationName.
getContext()), passTiming(false),
815 verifyPasses(true) {}
824 std::optional<OperationName> anchorOp =
getOpName(*context);
825 if (anchorOp && anchorOp != op->
getName())
846 llvm::hash_code pipelineKey = hash();
847 if (newInitKey != initializationKey || pipelineKey != pipelineInitializationKey) {
848 if (
failed(initialize(context,
impl->initializationGeneration + 1)))
850 initializationKey = newInitKey;
851 pipelineKey = pipelineInitializationKey;
860 crashReproGenerator ? runWithCrashRecovery(op, am) : runPasses(op, am);
866 if (passStatisticsMode)
874 instrumentor = std::make_unique<PassInstrumentor>();
880 return OpToOpPassAdaptor::runPipeline(*
this, op, am, verifyPasses,
881 impl->initializationGeneration);
893 "expected valid descendant operation");
897 return nestImmediate(op);
902 opAncestors.push_back(op);
904 }
while (op != currentOp);
907 for (
Operation *op : llvm::reverse(opAncestors))
908 result = result.nestImmediate(op);
915 "expected immediate child operation");
917 auto it =
impl->childAnalyses.find(op);
918 if (it ==
impl->childAnalyses.end())
919 it =
impl->childAnalyses
920 .try_emplace(op, std::make_unique<NestedAnalysisMap>(op,
impl))
922 return {it->second.get()};
944 while (!mapsToInvalidate.empty()) {
945 auto *map = mapsToInvalidate.pop_back_val();
946 for (
auto &analysisPair : map->childAnalyses) {
947 analysisPair.second->invalidate(pa);
948 if (!analysisPair.second->childAnalyses.empty())
949 mapsToInvalidate.push_back(analysisPair.second.get());
987 std::optional<OperationName> name,
989 llvm::sys::SmartScopedLock<true> instrumentationLock(
impl->mutex);
990 for (
auto &instr :
impl->instrumentations)
991 instr->runBeforePipeline(name, parentInfo);
996 std::optional<OperationName> name,
998 llvm::sys::SmartScopedLock<true> instrumentationLock(
impl->mutex);
999 for (
auto &instr : llvm::reverse(
impl->instrumentations))
1000 instr->runAfterPipeline(name, parentInfo);
1005 llvm::sys::SmartScopedLock<true> instrumentationLock(
impl->mutex);
1006 for (
auto &instr :
impl->instrumentations)
1007 instr->runBeforePass(pass, op);
1012 llvm::sys::SmartScopedLock<true> instrumentationLock(
impl->mutex);
1013 for (
auto &instr : llvm::reverse(
impl->instrumentations))
1014 instr->runAfterPass(pass, op);
1019 llvm::sys::SmartScopedLock<true> instrumentationLock(
impl->mutex);
1020 for (
auto &instr : llvm::reverse(
impl->instrumentations))
1021 instr->runAfterPassFailed(pass, op);
1027 llvm::sys::SmartScopedLock<true> instrumentationLock(
impl->mutex);
1028 for (
auto &instr :
impl->instrumentations)
1029 instr->runBeforeAnalysis(name,
id, op);
1035 llvm::sys::SmartScopedLock<true> instrumentationLock(
impl->mutex);
1036 for (
auto &instr : llvm::reverse(
impl->instrumentations))
1037 instr->runAfterAnalysis(name,
id, op);
1042 std::unique_ptr<PassInstrumentation> pi) {
1043 llvm::sys::SmartScopedLock<true> instrumentationLock(
impl->mutex);
1044 impl->instrumentations.emplace_back(std::move(pi));
static MLIRContext * getContext(OpFoldResult val)
static llvm::ManagedStatic< PassManagerOptions > options
static void registerDialectsForPipeline(const OpPassManager &pm, DialectRegistry &dialects)
static bool hasSizeMismatch(ArrayRef< OpPassManager > lhs, ArrayRef< OpPassManager > rhs)
Utility functor that checks if the two ranges of pass managers have a size mismatch.
static OpPassManager * findPassManagerFor(MutableArrayRef< OpPassManager > mgrs, OperationName name, MLIRContext &context)
Find an operation pass manager that can operate on an operation of the given type,...
static OpPassManager * findPassManagerWithAnchor(MutableArrayRef< OpPassManager > mgrs, StringRef name)
Find an operation pass manager with the given anchor name, or nullptr if one does not exist.
This class represents an analysis manager for a particular operation instance.
void clear()
Clear any held analyses.
void invalidate(const PreservedAnalyses &pa)
Invalidate any non preserved analyses,.
AnalysisManager nest(Operation *op)
Get an analysis manager for the given operation, which must be a proper descendant of the current ope...
PassInstrumentor * getPassInstrumentor() const
Returns a pass instrumentation object for the current operation.
The DialectRegistry maps a dialect namespace to a constructor for the matching dialect.
auto getDialectNames() const
Return the names of dialects known to this registry.
MLIRContext is the top-level object for a collection of MLIR operations.
void appendDialectRegistry(const DialectRegistry ®istry)
Append the contents of the given dialect registry to the registry associated with this context.
void executeAction(function_ref< void()> actionFn, const tracing::Action &action)
Dispatch the provided action to the handler if any, or just execute it.
llvm::hash_code getRegistryHash()
Returns a hash of the registry of the context that may be used to give a rough indicator of if the st...
void enterMultiThreadedExecution()
These APIs are tracking whether the context will be used in a multithreading environment: this has no...
llvm::ThreadPool & getThreadPool()
Return the thread pool used by this context.
T * getOrLoadDialect()
Get (or create) a dialect for the given derived dialect type.
void exitMultiThreadedExecution()
An analysis manager class specifically for the top-level operation.
This class represents a pass manager that runs passes on either a specific operation type,...
OpPassManager & operator=(const OpPassManager &rhs)
friend class PassManager
Allow access to the constructor.
OpPassManager(Nesting nesting=Nesting::Explicit)
Construct a new op-agnostic ("any") pass manager with the given operation type and nesting behavior.
void printAsTextualPipeline(raw_ostream &os) const
Prints out the passes of the pass manager as the textual representation of pipelines.
std::optional< OperationName > getOpName(MLIRContext &context) const
Return the operation name that this pass manager operates on, or std::nullopt if this is an op-agnost...
void setNesting(Nesting nesting)
Enable or disable the implicit nesting on this particular PassManager.
size_t size() const
Returns the number of passes held by this manager.
detail::OpPassManagerImpl & getImpl()
Returns the internal implementation instance.
void addPass(std::unique_ptr< Pass > pass)
Add the given pass to this pass manager.
Nesting getNesting()
Return the current nesting mode.
Nesting
This enum represents the nesting behavior of the pass manager.
@ Implicit
Implicit nesting behavior.
void dump()
Raw dump of the pass manager to llvm::errs().
llvm::pointee_iterator< MutableArrayRef< std::unique_ptr< Pass > >::iterator > pass_iterator
Iterator over the passes in this pass manager.
llvm::pointee_iterator< ArrayRef< std::unique_ptr< Pass > >::const_iterator > const_pass_iterator
void getDependentDialects(DialectRegistry &dialects) const
Register dependent dialects for the current pass manager.
StringRef getOpAnchorName() const
Return the name used to anchor this pass manager.
std::optional< StringRef > getOpName() const
Return the operation name that this pass manager operates on, or std::nullopt if this is an op-agnost...
OpPassManager & nestAny()
Nest a new op-agnostic ("any") pass manager under this pass manager.
iterator_range< pass_iterator > getPasses()
static StringRef getAnyOpAnchorName()
Return the string name used to anchor op-agnostic pass managers that operate generically on any viabl...
void clear()
Clear the pipeline, but not the other options set on this OpPassManager.
This class provides the API for ops that are known to be isolated from above.
std::optional< RegisteredOperationName > getRegisteredInfo() const
If this operation is registered, returns the registered information, std::nullopt otherwise.
Operation is the basic unit of execution within MLIR.
MLIRContext * getContext()
Return the context this operation is associated with.
std::optional< RegisteredOperationName > getRegisteredInfo()
If this operation has a registered operation description, return it.
Location getLoc()
The source location the operation was defined or derived from.
Operation * getParentOp()
Returns the closest surrounding operation that contains this operation or nullptr if this is a top-le...
OperationName getName()
The name of an operation is the key identifier for it.
bool isAncestor(Operation *other)
Return true if this operation is an ancestor of the other operation.
bool isProperAncestor(Operation *other)
Return true if this operation is a proper ancestor of the other operation.
InFlightDiagnostic emitOpError(const Twine &message={})
Emit an error with the op name prefixed, like "'dim' op " which is convenient for verifiers.
virtual void runAfterPipeline(std::optional< OperationName > name, const PipelineParentInfo &parentInfo)
A callback to run after a pass pipeline has executed.
virtual ~PassInstrumentation()=0
virtual void runBeforePipeline(std::optional< OperationName > name, const PipelineParentInfo &parentInfo)
A callback to run before a pass pipeline is executed.
This class holds a collection of PassInstrumentation objects, and invokes their respective call backs...
void runAfterPassFailed(Pass *pass, Operation *op)
See PassInstrumentation::runAfterPassFailed for details.
void addInstrumentation(std::unique_ptr< PassInstrumentation > pi)
Add the given instrumentation to the collection.
void runBeforeAnalysis(StringRef name, TypeID id, Operation *op)
See PassInstrumentation::runBeforeAnalysis for details.
void runAfterPass(Pass *pass, Operation *op)
See PassInstrumentation::runAfterPass for details.
void runAfterAnalysis(StringRef name, TypeID id, Operation *op)
See PassInstrumentation::runAfterAnalysis for details.
void runBeforePass(Pass *pass, Operation *op)
See PassInstrumentation::runBeforePass for details.
void runBeforePipeline(std::optional< OperationName > name, const PassInstrumentation::PipelineParentInfo &parentInfo)
See PassInstrumentation::runBeforePipeline for details.
void runAfterPipeline(std::optional< OperationName > name, const PassInstrumentation::PipelineParentInfo &parentInfo)
See PassInstrumentation::runAfterPipeline for details.
MLIRContext * getContext() const
Return an instance of the context.
LogicalResult run(Operation *op)
Run the passes within this manager on the provided operation.
void addInstrumentation(std::unique_ptr< PassInstrumentation > pi)
Add the provided instrumentation to the pass manager.
void enableVerifier(bool enabled=true)
Runs the verifier after each individual pass.
The abstract base pass class.
void copyOptionValuesFrom(const Pass *other)
Copy the option values from 'other', which is another instance of this pass.
void printAsTextualPipeline(raw_ostream &os)
Prints out the pass in the textual representation of pipelines.
virtual bool canScheduleOn(RegisteredOperationName opName) const =0
Indicate if the current pass can be scheduled on the given operation type.
virtual LogicalResult initializeOptions(StringRef options)
Attempt to initialize the options of this pass from the given string.
std::optional< StringRef > getOpName() const
Returns the name of the operation that this pass operates on, or std::nullopt if this is a generic Op...
virtual void runOnOperation()=0
The polymorphic API that runs the pass over the currently held operation.
This class provides an efficient unique identifier for a specific C++ type.
void invalidate(const PreservedAnalyses &pa)
Invalidate any cached analyses based upon the given set of preserved analyses.
An adaptor pass used to run operation passes over nested operations.
A utility class to represent the analyses that are known to be preserved.
bool isAll() const
Returns true if all analyses were marked preserved.
bool isNone() const
Returns true if no analyses were marked preserved.
Detect if any of the given parameter types has a sub-element handler.
Include the generated interface declarations.
LogicalResult failure(bool isFailure=true)
Utility function to generate a LogicalResult.
LogicalResult failableParallelForEach(MLIRContext *context, IteratorT begin, IteratorT end, FuncT &&func)
Invoke the given function on the elements between [begin, end) asynchronously.
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
bool succeeded(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a success value.
LogicalResult success(bool isSuccess=true)
Utility function to generate a LogicalResult.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
LogicalResult verify(Operation *op, bool verifyRecursively=true)
Perform (potentially expensive) checks of invariants, used to detect compiler bugs,...
bool failed(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a failure value.
This class represents an efficient way to signal success or failure.
Encapsulate the "action" of executing a single pass, used for the MLIR tracing infrastructure.
void print(raw_ostream &os) const override
This struct represents information related to the parent pass of pipeline.
detail::AnalysisMap analyses
The analyses for the owning operation.
DenseMap< Operation *, std::unique_ptr< NestedAnalysisMap > > childAnalyses
The cached analyses for nested operations.
void invalidate(const PreservedAnalyses &pa)
Invalidate any non preserved analyses.
void clear()
Clear the list of passes in this pass manager, other options are preserved.
OpPassManagerImpl(const OpPassManagerImpl &rhs)
std::string name
The name of the operation that passes of this pass manager operate on.
OpPassManager::Nesting nesting
Control the implicit nesting of passes that mismatch the name set for this OpPassManager.
std::optional< OperationName > getOpName(MLIRContext &context)
Return the operation name of this pass manager.
void addPass(std::unique_ptr< Pass > pass)
Add the given pass to this pass manager.
OpPassManager & nest(StringRef nestedName)
unsigned initializationGeneration
The current initialization generation of this pass manager.
OpPassManagerImpl(OperationName opName, OpPassManager::Nesting nesting)
bool canScheduleOn(MLIRContext &context, OperationName opName)
Indicate if the current pass manager can be scheduled on the given operation type.
OpPassManagerImpl(OpPassManager::Nesting nesting)
StringRef getOpAnchorName() const
Return the name used to anchor this pass manager.
OpPassManager & nestAny()
OpPassManager & nest(OperationName nestedName)
Nest a new operation pass manager for the given operation kind under this pass manager.
std::vector< std::unique_ptr< Pass > > passes
The set of passes to run as part of this pass manager.
std::optional< StringRef > getOpName() const
void mergeInto(OpPassManagerImpl &rhs)
Merge the passes of this pass manager into the one provided.
LogicalResult finalizePassList(MLIRContext *ctx)
Finalize the pass list in preparation for execution.
std::optional< OperationName > opName
The cached OperationName (internalized in the context) for the name of the operation that passes of t...
OpPassManagerImpl(StringRef name, OpPassManager::Nesting nesting)
std::vector< std::unique_ptr< PassInstrumentation > > instrumentations
Set of registered instrumentations.
llvm::sys::SmartMutex< true > mutex
Mutex to keep instrumentation access thread-safe.