[mlir:Pass] Generate a reproducer as early as possible

[rriddle]

Summary

This avoids keeping references to passes that may be freed by
the time that the pass manager has finished executing (in the
non-crash case).

Fixes PR#52069

mlir/lib/Pass/PassCrashRecovery.cpp

formatPassOpReproducerMessage(Diagnostic &os,
   os << "`" << passOpPair.first->getName() << "` on "
      << "'" << passOpPair.second->getName() << "' operation";
   if (SymbolOpInterface symbol = dyn_cast<SymbolOpInterface>(passOpPair.second))
     os << ": @" << symbol.getName();
 }
 
 void PassCrashReproducerGenerator::finalize(Operation *rootOp,
                                             LogicalResult executionResult) {
+  // Don't generate a reproducer if we have no active contexts.
+  if (impl->activeContexts.empty())
+    return;
+
   // If the pass manager execution succeeded, we don't generate any reproducers.
   if (succeeded(executionResult))
     return impl->activeContexts.clear();
 
   MLIRContext *context = rootOp->getContext();
   bool shouldPrintOnOp = context->shouldPrintOpOnDiagnostic();
   context->printOpOnDiagnostic(false);
   InFlightDiagnostic diag = rootOp->emitError()

 //===----------------------------------------------------------------------===//
 
 namespace {
 struct CrashReproducerInstrumentation : public PassInstrumentation {
   CrashReproducerInstrumentation(PassCrashReproducerGenerator &generator)
       : generator(generator) {}
   ~CrashReproducerInstrumentation() override = default;
 
-  /// A callback to run before a pass is executed.
   void runBeforePass(Pass *pass, Operation *op) override {
     if (!isa<OpToOpPassAdaptor>(pass))
       generator.prepareReproducerFor(pass, op);
   }
 
-  /// A callback to run after a pass is successfully executed. This function
-  /// takes a pointer to the pass to be executed, as well as the current
-  /// operation being operated on.
   void runAfterPass(Pass *pass, Operation *op) override {
     if (!isa<OpToOpPassAdaptor>(pass))
       generator.removeLastReproducerFor(pass, op);
   }
 
+  void runAfterPassFailed(Pass *pass, Operation *op) override {
+    generator.finalize(op, /*executionResult=*/failure());
+  }
+
 private:
   /// The generator used to create crash reproducers.
   PassCrashReproducerGenerator &generator;
 };
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // FileReproducerStream

mlir/test/Pass/crash-recovery-dynamic-failure.mlir

+// Check that local reproducers will also traverse dynamic pass pipelines.
+// RUN: mlir-opt %s -pass-pipeline='test-module-pass,test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=test-pass-failure}' -pass-pipeline-crash-reproducer=%t -verify-diagnostics -pass-pipeline-local-reproducer --mlir-disable-threading
+// RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL_DYNAMIC_FAILURE %s
+
+// The crash recovery mechanism will leak memory allocated in the crashing thread.
+// UNSUPPORTED: asan
+
+module @inner_mod1 {
+  // expected-error@below {{Failures have been detected while processing an MLIR pass pipeline}}
+  // expected-note@below {{Pipeline failed while executing}}
+  module @foo {}
+}
+
+// REPRO_LOCAL_DYNAMIC_FAILURE: configuration: -pass-pipeline='builtin.module(test-pass-failure)'
+
+// REPRO_LOCAL_DYNAMIC_FAILURE: module @inner_mod1
+// REPRO_LOCAL_DYNAMIC_FAILURE: module @foo {

mlir/test/lib/Pass/TestDynamicPipeline.cpp

if (!symbolOp) {
       return;
     }
 
     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>(currentOp->getName().getIdentifier(),
-                                           OpPassManager::Nesting::Implicit);
-      (void)parsePassPipeline(pipeline, *pm, llvm::errs());
-    }
+    OpPassManager pm(currentOp->getName().getIdentifier(),
+    (void)parsePassPipeline(pipeline, pm, llvm::errs());
 
     // Check that running on the parent operation always immediately fails.
     if (runOnParent) {
       if (currentOp->getParentOp())
-        if (!failed(runPipeline(*pm, currentOp->getParentOp())))
+        if (!failed(runPipeline(pm, currentOp->getParentOp())))
           signalPassFailure();
       return;
     }
 
     if (runOnNestedOp) {
       llvm::errs() << "Run on nested op\n";
       currentOp->walk([&](Operation *op) {
         if (op == currentOp || !op->hasTrait<OpTrait::IsIsolatedFromAbove>() ||
             op->getName() != currentOp->getName())
           return;
         llvm::errs() << "Run on " << *op << "\n";
         // Run on the current operation
-        if (failed(runPipeline(*pm, op)))
+        if (failed(runPipeline(pm, op)))
           signalPassFailure();
       });
     } else {
       // Run on the current operation
-      if (failed(runPipeline(*pm, currentOp)))
+      if (failed(runPipeline(pm, currentOp)))
         signalPassFailure();
     }
   }
 
-  std::unique_ptr<OpPassManager> pm;
-
   Option<bool> runOnNestedOp{
       *this, "run-on-nested-operations",
       llvm::cl::desc("This will apply the pipeline on nested operations under "
                      "the visited operation.")};
   Option<bool> runOnParent{
       *this, "run-on-parent",
       llvm::cl::desc("This will apply the pipeline on the parent operation if "
                      "it exist, this is expected to fail.")};