[mlir] Include anchor op in reproducer pipeline string

[rkayaith]

Summary

Including the anchor op ensures that all pass manager settings are fully
specified, and makes the string consistent with the printed form.

Depends on D134622

[rkayaith]

simplify change

[rkayaith]

clang-format

[rkayaith]

fix RUN command for windows

[rkayaith]

update

[rkayaith]

mlir/test/Pass/run-reproducer.mlir

17

not sure why whitespace gets printed after the {

[rkayaith]

update docs, rename variable

[rriddle]

mlir/test/Pass/run-reproducer.mlir

17

I think we should fix that, otherwise seems like it will create problems elsewhere.

mlir/lib/Pass/PassCrashRecovery.cpp

if (!impl->localReproducer)
     return;
 
   // Disable the current pass recovery context, if there is one. This may happen
   // in the case of dynamic pass pipelines.
   if (!impl->activeContexts.empty())
     impl->activeContexts.back()->disable();
 
   // Collect all of the parent scopes of this operation.
-  SmallVector<OperationName> scopes;
+  SmallVector<OperationName> scopes{op->getName()};
   while (Operation *parentOp = op->getParentOp()) {
-    scopes.push_back(op->getName());
+    scopes.push_back(parentOp->getName());
     op = parentOp;
   }
 
   // Emit a pass pipeline string for the current pass running on the current
   // operation type.
   std::string passStr;
   llvm::raw_string_ostream passOS(passStr);
   for (OperationName scope : llvm::reverse(scopes))
     passOS << scope << "(";
   pass->printAsTextualPipeline(passOS);
   for (unsigned i = 0, e = scopes.size(); i < e; ++i)
     passOS << ")";
 
   impl->activeContexts.push_back(std::make_unique<RecoveryReproducerContext>(
       passOS.str(), op, impl->streamFactory, impl->pmFlagVerifyPasses));
 }
 void PassCrashReproducerGenerator::prepareReproducerFor(
     iterator_range<PassManager::pass_iterator> passes, Operation *op) {
   std::string passStr;
   llvm::raw_string_ostream passOS(passStr);
+  passOS << op->getName() << "(";
   llvm::interleaveComma(
       passes, passOS, [&](Pass &pass) { pass.printAsTextualPipeline(passOS); });
+  passOS << ")";
 
   impl->activeContexts.push_back(std::make_unique<RecoveryReproducerContext>(
       passOS.str(), op, impl->streamFactory, impl->pmFlagVerifyPasses));
 }
 
 void PassCrashReproducerGenerator::removeLastReproducerFor(Pass *pass,
                                                            Operation *op) {
   // We only pop the active context if we are tracking local reproducers.
auto parseFn = [this](AsmParsedResourceEntry &entry) -> LogicalResult {
     }
     return entry.emitError() << "unknown 'mlir_reproducer' resource key '"
                              << entry.getKey() << "'";
   };
   config.attachResourceParser("mlir_reproducer", parseFn);
 }
 
 LogicalResult PassReproducerOptions::apply(PassManager &pm) const {
-  if (pipeline.has_value())
-    if (failed(parsePassPipeline(*pipeline, pm)))
+  if (pipeline.has_value()) {
+    FailureOr<OpPassManager> reproPm = parsePassPipeline(*pipeline);
+    if (failed(reproPm))
       return failure();
+    static_cast<OpPassManager &>(pm) = std::move(*reproPm);
+  }
 
   if (disableThreading.has_value())
     pm.getContext()->disableMultithreading(*disableThreading);
 
   if (verifyEach.has_value())
     pm.enableVerifier(*verifyEach);
 
   return success();
 }

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

module @inner_mod1 {
   // expected-note@below {{Pipeline failed while executing}}
   module @foo {}
 }
 
 
 // REPRO_LOCAL_DYNAMIC_FAILURE: module @inner_mod1
 // REPRO_LOCAL_DYNAMIC_FAILURE: module @foo {
 
-// REPRO_LOCAL_DYNAMIC_FAILURE: pipeline: "builtin.module(test-pass-failure)"
+// REPRO_LOCAL_DYNAMIC_FAILURE: pipeline: "builtin.module(builtin.module(test-pass-failure))"

mlir/test/Pass/crash-recovery.mlir

 // expected-error@below {{Failures have been detected while processing an MLIR pass pipeline}}
 // expected-note@below {{Pipeline failed while executing}}
 module @inner_mod1 {
   module @foo {}
 }
 
 // REPRO: module @inner_mod1
 // REPRO: module @foo {
-// REPRO: pipeline: "builtin.module(test-module-pass,test-pass-crash)"
+// REPRO: pipeline: "builtin.module(builtin.module(test-module-pass,test-pass-crash))"
 
 // REPRO_LOCAL: module @inner_mod1
 // REPRO_LOCAL: module @foo {
-// REPRO_LOCAL: pipeline: "builtin.module(test-pass-crash)"
+// REPRO_LOCAL: pipeline: "builtin.module(builtin.module(test-pass-crash))"
 
 // REPRO_LOCAL_DYNAMIC: module @inner_mod1
 // REPRO_LOCAL_DYNAMIC: module @foo {
-// REPRO_LOCAL_DYNAMIC: pipeline: "builtin.module(test-pass-crash)"
+// REPRO_LOCAL_DYNAMIC: pipeline: "builtin.module(builtin.module(test-pass-crash))"

mlir/test/Pass/run-reproducer.mlir

+// RUN: mlir-opt %s -test-dump-pipeline |& FileCheck %s
 // RUN: mlir-opt %s -mlir-print-ir-before=cse 2>&1 | FileCheck -check-prefix=BEFORE %s
 
 func.func @foo() {
   %0 = arith.constant 0 : i32
   return
 }
 
 func.func @bar() {
   return
 }
 
 {-#
   external_resources: {
     mlir_reproducer: {
-      pipeline: "func.func(cse,canonicalize)",
+      verify_each: true,
+      // CHECK:  builtin.module(func.func(cse,canonicalize{ max-iterations=1 region-simplify=false top-down=false}))
+      pipeline: "builtin.module(func.func(cse,canonicalize{max-iterations=1 region-simplify=false top-down=false}))",
       disable_threading: true
     }
   }
 #-}
 
 // BEFORE: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
 // BEFORE-NEXT: func @foo()
 // BEFORE: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
 // BEFORE-NEXT: func @bar()
 // BEFORE-NOT: // -----// IR Dump Before{{.*}}Canonicalizer (canonicalize) //----- //
 // BEFORE-NOT: // -----// IR Dump After