Handle the verifier at run() time in the PassManager instead of build time

[mehdi_amini]

Summary

This simplifies a few parts of the pass manager, but in particular we don't add as many
verifierpass as there are passes in the pipeline, and we can now enable/disable the
verifier after the fact on an already built PassManager.

[rriddle]

You should probably note somewhere that this changes the default behavior of the pass manager to not verify passes by default.

mlir/lib/Pass/Pass.cpp

356–357

unrelated nit: This should just return the error directly.

397

Should we hoist this above the instrumentation calls? I'm inclined to say yes.

398

Why? Do we intend to treat cases where a pass accidentally changes something outside of the current operation as UB? It'd still be nice to get verifier failures when my, e.g., function pass does something that it shouldn't.

483

Is there a double space after 'on'?

512–513

unrelated nit: Can you remove this auto while you are here?

745–748

?

[mehdi_amini]

mlir/lib/Pass/Pass.cpp

397

I wasn't sure, the current version preserve the existing behavior I believe, but I'm happy to move it above as well!

Wouldn't it mess up things like pass timing by including the verifier into it?

398

Not sure I understand? I added this check because I though that the last pass in the OpToOpPassAdaptor pipeline would already have verified the IR.

Is this a nesting question: an extra verifier at this level would check a level above maybe?

[rriddle]

mlir/lib/Pass/Pass.cpp

397

I wasn't sure, the current version preserve the existing behavior I believe, but I'm happy to move it above as well!

Wouldn't it mess up things like pass timing by including the verifier into it?

Yeah, I think it goes either way. I would expect several instrumentations to benefit from the fact that the pass fails when the verifier fails, i.e. it would be easier to track down which pass caused a specific failure. Pass instrumentation would hurt more, but I think that one can be explained away as similar to "do you profile in debug mode?". If pass timing is the one negative hit, which was the only one I could think of, then I'd want to move it. Unless you can think of others that might be negatively impacted?

398

Sorry, yes it is a nesting thing. I'd still want us to verify the parent module after running a nested pipeline on it.

[rriddle]

mlir/include/mlir/Pass/PassManager.h

151–152

This comment needs to be updated.

[mehdi_amini]

Address River's comments

[mehdi_amini]

mlir/lib/Pass/Pass.cpp

789

You should probably note somewhere that this changes the default behavior of the pass manager to not verify passes by default.

Did you miss the default value for verifyPasses here?

[rriddle]

mlir/lib/Pass/Pass.cpp

789

I most certainly did.

mlir/include/mlir/Pass/PassManager.h

 // OpPassManager
 //===----------------------------------------------------------------------===//
 
 /// This class represents a pass manager that runs passes on a specific
 /// operation type. This class is not constructed directly, but nested within
 /// other OpPassManagers or the top-level PassManager.
 class OpPassManager {
 public:
-  OpPassManager(Identifier name, bool verifyPasses);
-  OpPassManager(StringRef name, bool verifyPasses);
+  OpPassManager(Identifier name);
+  OpPassManager(StringRef name);
   OpPassManager(OpPassManager &&rhs);
   OpPassManager(const OpPassManager &rhs);
   ~OpPassManager();
   OpPassManager &operator=(const OpPassManager &rhs);
 
   /// Iterator over the passes in this pass manager.
   using pass_iterator =
       llvm::pointee_iterator<MutableArrayRef<std::unique_ptr<Pass>>::iterator>;
enum class PassDisplayMode {
   // In this mode the results are displayed in a nested pipeline view that
   // mirrors the internal pass pipeline that is being executed in the pass
   // manager.
   Pipeline,
 };
 
 /// The main pass manager and pipeline builder.
 class PassManager : public OpPassManager {
 public:
-  // If verifyPasses is true, the verifier is run after each pass.
-  PassManager(MLIRContext *ctx, bool verifyPasses = true);
+  PassManager(MLIRContext *ctx);
   ~PassManager();
 
   /// Run the passes within this manager on the provided module.
   LLVM_NODISCARD
   LogicalResult run(ModuleOp module);
 
   /// Return an instance of the context.
   MLIRContext *getContext() const { return context; }
 
   /// Enable support for the pass manager to generate a reproducer on the event
   /// of a crash or a pass failure. `outputFile` is a .mlir filename used to
   /// write the generated reproducer. If `genLocalReproducer` is true, the pass
   /// manager will attempt to generate a local reproducer that contains the
   /// smallest pipeline.
   void enableCrashReproducerGeneration(StringRef outputFile,
                                        bool genLocalReproducer = false);
 
+  /// Runs the verifier after each individual pass.
+  void enableVerifier(bool enabled = true);
+
   //===--------------------------------------------------------------------===//
   // Instrumentations
   //===--------------------------------------------------------------------===//
 
   /// Add the provided instrumentation to the pass manager.
   void addInstrumentation(std::unique_ptr<PassInstrumentation> pi);
 
   //===--------------------------------------------------------------------===//
private:
   /// An optional filename to use when generating a crash reproducer if valid.
   Optional<std::string> crashReproducerFileName;
 
   /// Flag that specifies if pass timing is enabled.
   bool passTiming : 1;
 
   /// Flag that specifies if the generated crash reproducer should be local.
   bool localReproducer : 1;
+
+  /// A flag that indicates if the IR should be verified in between passes.
+  bool verifyPasses : 1;
 };
 
 /// Register a set of useful command-line options that can be used to configure
 /// a pass manager. The values of these options can be applied via the
 /// 'applyPassManagerCLOptions' method below.
 void registerPassManagerCLOptions();
 
 /// Apply any values provided to the pass manager options that were registered
 /// with 'registerPassManagerOptions'.
 void applyPassManagerCLOptions(PassManager &pm);
 } // end namespace mlir
 
 #endif // MLIR_PASS_PASSMANAGER_H

mlir/lib/Pass/Pass.cpp

 
 //===----------------------------------------------------------------------===//
 // OpPassManagerImpl
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace detail {
 struct OpPassManagerImpl {
-  OpPassManagerImpl(Identifier identifier, bool verifyPasses)
-      : name(identifier), identifier(identifier), verifyPasses(verifyPasses) {}
-  OpPassManagerImpl(StringRef name, bool verifyPasses)
-      : name(name), verifyPasses(verifyPasses) {}
+  OpPassManagerImpl(Identifier identifier)
+      : name(identifier), identifier(identifier) {}
+  OpPassManagerImpl(StringRef name) : name(name) {}
 
   /// Merge the passes of this pass manager into the one provided.
   void mergeInto(OpPassManagerImpl &rhs);
 
   /// Nest a new operation pass manager for the given operation kind under this
   /// pass manager.
   OpPassManager &nest(Identifier nestedName);
   OpPassManager &nest(StringRef nestedName);
struct OpPassManagerImpl {
 
   /// The name of the operation that passes of this pass manager operate on.
   StringRef name;
 
   /// The cached identifier (internalized in the context) for the name of the
   /// operation that passes of this pass manager operate on.
   Optional<Identifier> identifier;
 
-  /// Flag that specifies if the IR should be verified after each pass has run.
-  bool verifyPasses : 1;
-
   /// The set of passes to run as part of this pass manager.
   std::vector<std::unique_ptr<Pass>> passes;
 };
 } // end namespace detail
 } // end namespace mlir
 
 void OpPassManagerImpl::mergeInto(OpPassManagerImpl &rhs) {
   assert(name == rhs.name && "merging unrelated pass managers");
   for (auto &pass : passes)
     rhs.passes.push_back(std::move(pass));
   passes.clear();
 }
 
 OpPassManager &OpPassManagerImpl::nest(Identifier nestedName) {
-  OpPassManager nested(nestedName, verifyPasses);
+  OpPassManager nested(nestedName);
   auto *adaptor = new OpToOpPassAdaptor(std::move(nested));
   addPass(std::unique_ptr<Pass>(adaptor));
   return adaptor->getPassManagers().front();
 }
 
 OpPassManager &OpPassManagerImpl::nest(StringRef nestedName) {
-  OpPassManager nested(nestedName, verifyPasses);
+  OpPassManager nested(nestedName);
   auto *adaptor = new OpToOpPassAdaptor(std::move(nested));
   addPass(std::unique_ptr<Pass>(adaptor));
   return adaptor->getPassManagers().front();
 }
 
 void OpPassManagerImpl::addPass(std::unique_ptr<Pass> pass) {
   // If this pass runs on a different operation than this pass manager, then
   // implicitly nest a pass manager for this operation.
   auto passOpName = pass->getOpName();
   if (passOpName && passOpName != name)
     return nest(*passOpName).addPass(std::move(pass));
 
   passes.emplace_back(std::move(pass));
-  if (verifyPasses)
-    passes.emplace_back(std::make_unique<VerifierPass>());
 }
 
 void OpPassManagerImpl::coalesceAdjacentAdaptorPasses() {
   // Bail out early if there are no adaptor passes.
   if (llvm::none_of(passes, [](std::unique_ptr<Pass> &pass) {
         return isa<OpToOpPassAdaptor>(pass.get());
       }))
     return;
 
   // Walk the pass list and merge adjacent adaptors.
   OpToOpPassAdaptor *lastAdaptor = nullptr;
   for (auto it = passes.begin(), e = passes.end(); it != e; ++it) {
     // Check to see if this pass is an adaptor.
     if (auto *currentAdaptor = dyn_cast<OpToOpPassAdaptor>(it->get())) {
       // If it is the first adaptor in a possible chain, remember it and
       // continue.
       if (!lastAdaptor) {
         lastAdaptor = currentAdaptor;
         continue;
       }
 
       // Otherwise, merge into the existing adaptor and delete the current one.
       currentAdaptor->mergeInto(*lastAdaptor);
       it->reset();
-
-      // If the verifier is enabled, then next pass is a verifier run so
-      // drop it. Verifier passes are inserted after every pass, so this one
-      // would be a duplicate.
-      if (verifyPasses) {
-        assert(std::next(it) != e && isa<VerifierPass>(*std::next(it)));
-        (++it)->reset();
-      }
     } else if (lastAdaptor && !isa<VerifierPass>(*it)) {
       // If this pass is not an adaptor and not a verifier pass, then coalesce
       // and forget any existing adaptor.
       for (auto &pm : lastAdaptor->getPassManagers())
         pm.getImpl().coalesceAdjacentAdaptorPasses();
       lastAdaptor = nullptr;
     }
   }
for (std::unique_ptr<Pass> &pass : oldPasses) {
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // OpPassManager
 //===----------------------------------------------------------------------===//
 
-OpPassManager::OpPassManager(Identifier name, bool verifyPasses)
-    : impl(new OpPassManagerImpl(name, verifyPasses)) {}
-OpPassManager::OpPassManager(StringRef name, bool verifyPasses)
-    : impl(new OpPassManagerImpl(name, verifyPasses)) {}
+OpPassManager::OpPassManager(Identifier name)
+    : impl(new OpPassManagerImpl(name)) {}
+OpPassManager::OpPassManager(StringRef name)
+    : impl(new OpPassManagerImpl(name)) {}
 OpPassManager::OpPassManager(OpPassManager &&rhs) : impl(std::move(rhs.impl)) {}
 OpPassManager::OpPassManager(const OpPassManager &rhs) { *this = rhs; }
 OpPassManager &OpPassManager::operator=(const OpPassManager &rhs) {
-  impl.reset(new OpPassManagerImpl(rhs.impl->name, rhs.impl->verifyPasses));
+  impl.reset(new OpPassManagerImpl(rhs.impl->name));
   for (auto &pass : rhs.impl->passes)
     impl->passes.emplace_back(pass->clone());
   return *this;
 }
 
 OpPassManager::~OpPassManager() {}
 
 OpPassManager::pass_iterator OpPassManager::begin() {
void OpPassManager::getDependentDialects(DialectRegistry &dialects) const {
   registerDialectsForPipeline(*this, dialects);
 }
 
 //===----------------------------------------------------------------------===//
 // OpToOpPassAdaptor
 //===----------------------------------------------------------------------===//
 
 LogicalResult OpToOpPassAdaptor::run(Pass *pass, Operation *op,
-                                     AnalysisManager am) {
+                                     AnalysisManager am, bool verifyPasses) {
   if (!op->getName().getAbstractOperation())
     return op->emitOpError()
            << "trying to schedule a pass on an unregistered operation";
   if (!op->getName().getAbstractOperation()->hasProperty(
           OperationProperty::IsolatedFromAbove))
     return op->emitOpError() << "trying to schedule a pass on an operation not "
                                 "marked as 'IsolatedFromAbove'";
 
   // Initialize the pass state with a callback for the pass to dynamically
   // execute a pipeline on the currently visited operation.
   auto dynamic_pipeline_callback =
-      [op, &am](OpPassManager &pipeline, Operation *root) {
-        if (!op->isAncestor(root)) {
-          root->emitOpError()
-              << "Trying to schedule a dynamic pipeline on an "
-                 "operation that isn't "
-                 "nested under the current operation the pass is processing";
-          return failure();
-        }
-        AnalysisManager nestedAm = am.nest(root);
-        return OpToOpPassAdaptor::runPipeline(pipeline.getPasses(), root,
-                                              nestedAm);
-      };
+      [op, &am, verifyPasses](OpPassManager &pipeline,
+                              Operation *root) -> LogicalResult {
+    if (!op->isAncestor(root))
+      return root->emitOpError()
+
+    return OpToOpPassAdaptor::runPipeline(pipeline.getPasses(), root, nestedAm,
+                                          verifyPasses);
   pass->passState.emplace(op, am, dynamic_pipeline_callback);
   // Instrument before the pass has run.
   PassInstrumentor *pi = am.getPassInstrumentor();
   if (pi)
     pi->runBeforePass(pass, op);
 
   // Invoke the virtual runOnOperation method.
+  if (auto *adaptor = dyn_cast<OpToOpPassAdaptor>(pass))
+    adaptor->runOnOperation(verifyPasses);
+  else
     pass->runOnOperation();
+  bool passFailed = pass->passState->irAndPassFailed.getInt();
 
   // Invalidate any non preserved analyses.
   am.invalidate(pass->passState->preservedAnalyses);
 
+  // Run the verifier if this pass didn't fail already.
+  if (!passFailed && verifyPasses)
+    passFailed = failed(verify(op));
+
   // Instrument after the pass has run.
-  bool passFailed = pass->passState->irAndPassFailed.getInt();
   if (pi) {
     if (passFailed)
       pi->runAfterPassFailed(pass, op);
     else
       pi->runAfterPass(pass, op);
   }
 
   // Return if the pass signaled a failure.
   return failure(passFailed);
 }
 
 /// Run the given operation and analysis manager on a provided op pass manager.
 LogicalResult OpToOpPassAdaptor::runPipeline(
     iterator_range<OpPassManager::pass_iterator> passes, Operation *op,
-    AnalysisManager am) {
+    AnalysisManager am, bool verifyPasses) {
   auto scope_exit = llvm::make_scope_exit([&] {
     // Clear out any computed operation analyses. These analyses won't be used
     // any more in this pipeline, and this helps reduce the current working set
     // of memory. If preserving these analyses becomes important in the future
     // we can re-evaluate this.
     am.clear();
   });
 
   // Run the pipeline over the provided operation.
   for (Pass &pass : passes)
-    if (failed(run(&pass, op, am)))
+    if (failed(run(&pass, op, am, verifyPasses)))
       return failure();
 
   return success();
 }
 
 /// Find an operation pass manager that can operate on an operation of the given
 /// type, or nullptr if one does not exist.
 static OpPassManager *findPassManagerFor(MutableArrayRef<OpPassManager> mgrs,
std::string OpToOpPassAdaptor::getAdaptorName() {
   llvm::raw_string_ostream os(name);
   llvm::interleaveComma(getPassManagers(), os, [&](OpPassManager &pm) {
     os << '\'' << pm.getOpName() << '\'';
   });
   os << ']';
   return os.str();
 }
 
-/// Run the held pipeline over all nested operations.
 void OpToOpPassAdaptor::runOnOperation() {
+  llvm_unreachable(
+      "Unexpected call to Pass::runOnOperation() on OpToOpPassAdaptor");
+}
+
+/// Run the held pipeline over all nested operations.
+void OpToOpPassAdaptor::runOnOperation(bool verifyPasses) {
   if (getContext().isMultithreadingEnabled())
-    runOnOperationAsyncImpl();
+    runOnOperationAsyncImpl(verifyPasses);
   else
-    runOnOperationImpl();
+    runOnOperationImpl(verifyPasses);
 }
 
 /// Run this pass adaptor synchronously.
-void OpToOpPassAdaptor::runOnOperationImpl() {
+void OpToOpPassAdaptor::runOnOperationImpl(bool verifyPasses) {
   auto am = getAnalysisManager();
   PassInstrumentation::PipelineParentInfo parentInfo = {llvm::get_threadid(),
                                                         this};
   auto *instrumentor = am.getPassInstrumentor();
   for (auto &region : getOperation()->getRegions()) {
     for (auto &block : region) {
       for (auto &op : block) {
         auto *mgr = findPassManagerFor(mgrs, op.getName().getIdentifier(),
                                        *op.getContext());
         if (!mgr)
           continue;
         Identifier opName = mgr->getOpName(*getOperation()->getContext());
 
         // Run the held pipeline over the current operation.
         if (instrumentor)
           instrumentor->runBeforePipeline(opName, parentInfo);
-        auto result = runPipeline(mgr->getPasses(), &op, am.nest(&op));
+        LogicalResult result =
+            runPipeline(mgr->getPasses(), &op, am.nest(&op), verifyPasses);
         if (instrumentor)
           instrumentor->runAfterPipeline(opName, parentInfo);
 
         if (failed(result))
           return signalPassFailure();
       }
     }
   }
 }
 
 /// Utility functor that checks if the two ranges of pass managers have a size
 /// mismatch.
 static bool hasSizeMismatch(ArrayRef<OpPassManager> lhs,
                             ArrayRef<OpPassManager> rhs) {
   return lhs.size() != rhs.size() ||
          llvm::any_of(llvm::seq<size_t>(0, lhs.size()),
                       [&](size_t i) { return lhs[i].size() != rhs[i].size(); });
 }
 
 /// Run this pass adaptor synchronously.
-void OpToOpPassAdaptor::runOnOperationAsyncImpl() {
+void OpToOpPassAdaptor::runOnOperationAsyncImpl(bool verifyPasses) {
   AnalysisManager am = getAnalysisManager();
 
   // Create the async executors if they haven't been created, or if the main
   // pipeline has changed.
   if (asyncExecutors.empty() || hasSizeMismatch(asyncExecutors.front(), mgrs))
     asyncExecutors.assign(llvm::hardware_concurrency().compute_thread_count(),
                           mgrs);
 
llvm::parallelForEach(
           auto *pm = findPassManagerFor(
               pms, it.first->getName().getIdentifier(), getContext());
           assert(pm && "expected valid pass manager for operation");
 
           Identifier opName = pm->getOpName(*getOperation()->getContext());
           if (instrumentor)
             instrumentor->runBeforePipeline(opName, parentInfo);
           auto pipelineResult =
-              runPipeline(pm->getPasses(), it.first, it.second);
+              runPipeline(pm->getPasses(), it.first, it.second, verifyPasses);
           if (instrumentor)
             instrumentor->runAfterPipeline(opName, parentInfo);
 
           // Drop this thread from being tracked by the diagnostic handler.
           // After this task has finished, the thread may be used outside of
           // this pass manager context meaning that we don't want to track
           // diagnostics from it anymore.
           diagHandler.eraseOrderIDForThread();
LogicalResult PassManager::runWithCrashRecovery(ModuleOp module,
   // If this isn't a local producer, run all of the passes in recovery mode.
   if (!localReproducer)
     return runWithCrashRecovery(impl->passes, module, am);
 
   // Split the passes within adaptors to ensure that each pass can be run in
   // isolation.
   impl->splitAdaptorPasses();
 
-  // If this is a local producer, run each of the passes individually. If the
-  // verifier is enabled, each pass will have a verifier after. This is included
-  // in the recovery run.
-  unsigned stride = impl->verifyPasses ? 2 : 1;
+  // If this is a local producer, run each of the passes individually.
   MutableArrayRef<std::unique_ptr<Pass>> passes = impl->passes;
-  for (unsigned i = 0, e = passes.size(); i != e; i += stride) {
-    if (failed(runWithCrashRecovery(passes.slice(i, stride), module, am)))
+  for (std::unique_ptr<Pass> &pass : passes)
+    if (failed(runWithCrashRecovery(pass, module, am)))
       return failure();
-  }
   return success();
 }
 
 /// Run the given passes with crash recover enabled.
 LogicalResult
 PassManager::runWithCrashRecovery(MutableArrayRef<std::unique_ptr<Pass>> passes,
                                   ModuleOp module, AnalysisManager am) {
   RecoveryReproducerContext context(passes, module, *crashReproducerFileName,
                                     !getContext()->isMultithreadingEnabled(),
-                                    impl->verifyPasses);
+                                    verifyPasses);
 
   // Safely invoke the passes within a recovery context.
   llvm::CrashRecoveryContext::Enable();
   LogicalResult passManagerResult = failure();
   llvm::CrashRecoveryContext recoveryContext;
   recoveryContext.RunSafelyOnThread([&] {
     for (std::unique_ptr<Pass> &pass : passes)
-      if (failed(OpToOpPassAdaptor::run(pass.get(), module, am)))
+      if (failed(OpToOpPassAdaptor::run(pass.get(), module, am, verifyPasses)))
         return;
     passManagerResult = success();
   });
   llvm::CrashRecoveryContext::Disable();
   if (succeeded(passManagerResult))
     return success();
 
   std::string error;
   if (failed(context.generate(error)))
     return module.emitError("<MLIR-PassManager-Crash-Reproducer>: ") << error;
   return module.emitError()
          << "A failure has been detected while processing the MLIR module, a "
             "reproducer has been generated in '"
          << *crashReproducerFileName << "'";
 }
 
 //===----------------------------------------------------------------------===//
 // PassManager
 //===----------------------------------------------------------------------===//
 
-PassManager::PassManager(MLIRContext *ctx, bool verifyPasses)
-    : OpPassManager(Identifier::get(ModuleOp::getOperationName(), ctx),
-                    verifyPasses),
-      context(ctx), passTiming(false), localReproducer(false) {}
+PassManager::PassManager(MLIRContext *ctx)
+    : OpPassManager(Identifier::get(ModuleOp::getOperationName(), ctx)),
+      context(ctx), passTiming(false), localReproducer(false),
+      verifyPasses(true) {}
 
 PassManager::~PassManager() {}
 
+void PassManager::enableVerifier(bool enabled) { verifyPasses = enabled; }
+
 /// Run the passes within this manager on the provided module.
 LogicalResult PassManager::run(ModuleOp module) {
   // Before running, make sure to coalesce any adjacent pass adaptors in the
   // pipeline.
   getImpl().coalesceAdjacentAdaptorPasses();
 
   // Register all dialects for the current pipeline.
   DialectRegistry dependentDialects;
   getDependentDialects(dependentDialects);
   dependentDialects.loadAll(module.getContext());
 
   // Construct an analysis manager for the pipeline.
   ModuleAnalysisManager am(module, instrumentor.get());
 
   // Notify the context that we start running a pipeline for book keeping.
   module.getContext()->enterMultiThreadedExecution();
 
   // If reproducer generation is enabled, run the pass manager with crash
   // handling enabled.
-  LogicalResult result =
-      crashReproducerFileName
+  LogicalResult result = crashReproducerFileName
                              ? runWithCrashRecovery(module, am)
-          : OpToOpPassAdaptor::runPipeline(getPasses(), module, am);
+                             : OpToOpPassAdaptor::runPipeline(
+                                   getPasses(), module, am, verifyPasses);
 
   // Notify the context that the run is done.
   module.getContext()->exitMultiThreadedExecution();
 
   // Dump all of the pass statistics if necessary.
   if (passStatisticsMode)
     dumpStatistics();
   return result;

mlir/lib/Pass/PassDetail.h

 /// An adaptor pass used to run operation passes over nested operations.
 class OpToOpPassAdaptor
     : public PassWrapper<OpToOpPassAdaptor, OperationPass<>> {
 public:
   OpToOpPassAdaptor(OpPassManager &&mgr);
   OpToOpPassAdaptor(const OpToOpPassAdaptor &rhs) = default;
 
   /// Run the held pipeline over all operations.
+  void runOnOperation(bool verifyPasses);
   void runOnOperation() override;
 
   /// Merge the current pass adaptor into given 'rhs'.
   void mergeInto(OpToOpPassAdaptor &rhs);
 
   /// Returns the pass managers held by this adaptor.
   MutableArrayRef<OpPassManager> getPassManagers() { return mgrs; }
 
   /// Populate the set of dependent dialects for the passes in the current
   /// adaptor.
   void getDependentDialects(DialectRegistry &dialects) const override;
 
   /// Return the async pass managers held by this parallel adaptor.
   MutableArrayRef<SmallVector<OpPassManager, 1>> getParallelPassManagers() {
     return asyncExecutors;
   }
 
   /// Returns the adaptor pass name.
   std::string getAdaptorName();
 
 private:
   /// Run this pass adaptor synchronously.
-  void runOnOperationImpl();
+  void runOnOperationImpl(bool verifyPasses);
 
   /// Run this pass adaptor asynchronously.
-  void runOnOperationAsyncImpl();
+  void runOnOperationAsyncImpl(bool verifyPasses);
 
   /// Run the given operation and analysis manager on a single pass.
-  static LogicalResult run(Pass *pass, Operation *op, AnalysisManager am);
+  static LogicalResult run(Pass *pass, Operation *op, AnalysisManager am,
+                           bool verifyPasses);
 
   /// Run the given operation and analysis manager on a provided op pass
   /// manager.
   static LogicalResult
   runPipeline(iterator_range<OpPassManager::pass_iterator> passes,
-              Operation *op, AnalysisManager am);
+              Operation *op, AnalysisManager am, bool verifyPasses);
 
   /// A set of adaptors to run.
   SmallVector<OpPassManager, 1> mgrs;
 
   /// A set of executors, cloned from the main executor, that run asynchronously
   /// on different threads. This is used when threading is enabled.
   SmallVector<SmallVector<OpPassManager, 1>, 8> asyncExecutors;
 
   // For accessing "runPipeline".
   friend class mlir::PassManager;
 };
 
 } // end namespace detail
 } // end namespace mlir
 #endif // MLIR_PASS_PASSDETAIL_H_

mlir/lib/Support/MlirOptMain.cpp

static LogicalResult performActions(raw_ostream &os, bool verifyDiagnostics,
 
   // Parse the input file and reset the context threading state.
   OwningModuleRef module(parseSourceFile(sourceMgr, context));
   context->enableMultithreading(wasThreadingEnabled);
   if (!module)
     return failure();
 
   // Apply any pass manager command line options.
-  PassManager pm(context, verifyPasses);
+  PassManager pm(context);
+  pm.enableVerifier(verifyPasses);
   applyPassManagerCLOptions(pm);
 
   // Build the provided pipeline.
   if (failed(passPipeline.addToPipeline(pm)))
     return failure();
 
   // Run the pipeline.
   if (failed(pm.run(*module)))

mlir/test/Pass/pass-timing.mlir

 // RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=list 2>&1 | FileCheck -check-prefix=LIST %s
 // RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s
 // RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=list 2>&1 | FileCheck -check-prefix=MT_LIST %s
 // RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -pass-timing -pass-timing-display=pipeline 2>&1 | FileCheck -check-prefix=MT_PIPELINE %s
 // RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=false -test-pm-nested-pipeline -pass-timing -pass-timing-display=pipeline 2>&1 | FileCheck -check-prefix=NESTED_MT_PIPELINE %s
 
 // LIST: Pass execution timing report
 // LIST: Total Execution Time:
 // LIST: Name
 // LIST-DAG: Canonicalizer
-// LIST-DAG: Verifier
 // LIST-DAG: CSE
 // LIST-DAG: DominanceInfo
 // LIST: Total
 
 // PIPELINE: Pass execution timing report
 // PIPELINE: Total Execution Time:
 // PIPELINE: Name
 // PIPELINE-NEXT: 'func' Pipeline
 // PIPELINE-NEXT:   CSE
 // PIPELINE-NEXT:     (A) DominanceInfo
-// PIPELINE-NEXT:   Verifier
 // PIPELINE-NEXT:   Canonicalizer
-// PIPELINE-NEXT:   Verifier
 // PIPELINE-NEXT:   CSE
 // PIPELINE-NEXT:     (A) DominanceInfo
-// PIPELINE-NEXT:   Verifier
-// PIPELINE-NEXT: Verifier
 // PIPELINE-NEXT: Total
 
 // MT_LIST: Pass execution timing report
 // MT_LIST: Total Execution Time:
 // MT_LIST: Name
 // MT_LIST-DAG: Canonicalizer
-// MT_LIST-DAG: Verifier
 // MT_LIST-DAG: CSE
 // MT_LIST-DAG: DominanceInfo
 // MT_LIST: Total
 
 // MT_PIPELINE: Pass execution timing report
 // MT_PIPELINE: Total Execution Time:
 // MT_PIPELINE: Name
 // MT_PIPELINE-NEXT: 'func' Pipeline
 // MT_PIPELINE-NEXT:   CSE
 // MT_PIPELINE-NEXT:     (A) DominanceInfo
-// MT_PIPELINE-NEXT:   Verifier
 // MT_PIPELINE-NEXT:   Canonicalizer
-// MT_PIPELINE-NEXT:   Verifier
 // MT_PIPELINE-NEXT:   CSE
 // MT_PIPELINE-NEXT:     (A) DominanceInfo
-// MT_PIPELINE-NEXT:   Verifier
-// MT_PIPELINE-NEXT: Verifier
 // MT_PIPELINE-NEXT: Total
 
 // NESTED_MT_PIPELINE: Pass execution timing report
 // NESTED_MT_PIPELINE: Total Execution Time:
 // NESTED_MT_PIPELINE: Name
 // NESTED_MT_PIPELINE-NEXT: Pipeline Collection : ['func', 'module']
 // NESTED_MT_PIPELINE-NEXT:   'func' Pipeline
 // NESTED_MT_PIPELINE-NEXT:     TestFunctionPass

mlir/test/Pass/pipeline-stats.mlir

 // RUN: mlir-opt %s -verify-each=true -pass-pipeline='func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=list 2>&1 | FileCheck -check-prefix=LIST %s
 // RUN: mlir-opt %s -verify-each=true -pass-pipeline='func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s
 
 // LIST: Pass statistics report
 // LIST: TestStatisticPass
 // LIST-NEXT:  (S) {{0|8}} num-ops - Number of operations counted
 // LIST-NOT: Verifier
 
 // PIPELINE: Pass statistics report
 // PIPELINE: 'func' Pipeline
 // PIPELINE-NEXT:   TestStatisticPass
 // PIPELINE-NEXT:     (S) {{0|4}} num-ops - Number of operations counted
-// PIPELINE-NEXT:   Verifier
 // PIPELINE-NEXT:   TestStatisticPass
 // PIPELINE-NEXT:     (S) {{0|4}} num-ops - Number of operations counted
-// PIPELINE-NEXT:   Verifier
-// PIPELINE-NEXT: Verifier
 
 func @foo() {
   return
 }
 
 func @bar() {
   return
 }

mlir/test/lib/Transforms/TestDynamicPipeline.cpp

 using namespace mlir;
 
 namespace {
 
 class TestDynamicPipelinePass
     : public PassWrapper<TestDynamicPipelinePass, OperationPass<>> {
 public:
   void getDependentDialects(DialectRegistry &registry) const override {
-    OpPassManager pm(ModuleOp::getOperationName(), false);
+    OpPassManager pm(ModuleOp::getOperationName());
     parsePassPipeline(pipeline, pm, llvm::errs());
     pm.getDependentDialects(registry);
   }
 
   TestDynamicPipelinePass(){};
   TestDynamicPipelinePass(const TestDynamicPipelinePass &) {}
 
   void runOnOperation() override {
void runOnOperation() override {
 
     auto opName = symbolOp.getName();
     if (!opNames.empty() && !llvm::is_contained(opNames, opName)) {
       llvm::errs() << "dynamic-pipeline skip op name: " << opName << "\n";
       return;
     }
     if (!pm) {
       pm = std::make_unique<OpPassManager>(
-          getOperation()->getName().getIdentifier(), false);
+          getOperation()->getName().getIdentifier());
       parsePassPipeline(pipeline, *pm, llvm::errs());
     }
 
     // Check that running on the parent operation always immediately fails.
     if (runOnParent) {
       if (getOperation()->getParentOp())
         if (!failed(runPipeline(*pm, getOperation()->getParentOp())))
           signalPassFailure();