Ensure that multi-threading is disabled when enabling IRPrinting with module scope

[mehdi_amini]

Summary

This is avoid the user to shoot themselves in the foot. and encounter issues.

[rriddle]

mlir/include/mlir/Pass/PassManager.h

142

nit: PassManager -> pass manager

mlir/include/mlir/Pass/PassManager.h

public:
 
   /// Run the passes within this manager on the provided module.
   LLVM_NODISCARD
   LogicalResult run(ModuleOp module);
 
   /// Disable support for multi-threading within the pass manager.
   void disableMultithreading(bool disable = true);
 
+  /// Return true if the pass manager is configured with multi-threading
+  /// enabled.
+  bool isMultithreadingEnabled();
+
   /// 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.
   void enableCrashReproducerGeneration(StringRef outputFile);
 
   //===--------------------------------------------------------------------===//
   // Instrumentations
   //===--------------------------------------------------------------------===//

mlir/lib/Pass/IRPrinting.cpp

struct BasicIRPrinterConfig : public PassManager::IRPrinterConfig {
   /// The stream to output to.
   raw_ostream &out;
 };
 } // end anonymous namespace
 
 /// Add an instrumentation to print the IR before and after pass execution,
 /// using the provided configuration.
 void PassManager::enableIRPrinting(std::unique_ptr<IRPrinterConfig> config) {
+  if (config->shouldPrintAtModuleScope() && isMultithreadingEnabled())
+    llvm::report_fatal_error("IR printing can't be setup on a pass-manager "
+                             "without disabling multi-threading first.");
   addInstrumentation(
       std::make_unique<IRPrinterInstrumentation>(std::move(config)));
 }
 
 /// Add an instrumentation to print the IR before and after pass execution.
 void PassManager::enableIRPrinting(
     std::function<bool(Pass *, Operation *)> shouldPrintBeforePass,
     std::function<bool(Pass *, Operation *)> shouldPrintAfterPass,
     bool printModuleScope, bool printAfterOnlyOnChange, raw_ostream &out) {
   enableIRPrinting(std::make_unique<BasicIRPrinterConfig>(
       std::move(shouldPrintBeforePass), std::move(shouldPrintAfterPass),
       printModuleScope, printAfterOnlyOnChange, out));
 }

mlir/lib/Pass/Pass.cpp

LogicalResult PassManager::run(ModuleOp module) {
   return result;
 }
 
 /// Disable support for multi-threading within the pass manager.
 void PassManager::disableMultithreading(bool disable) {
   getImpl().disableThreads = disable;
 }
 
+bool PassManager::isMultithreadingEnabled() {
+  return !getImpl().disableThreads;
+}
+
 /// 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.
 void PassManager::enableCrashReproducerGeneration(StringRef outputFile) {
   crashReproducerFileName = std::string(outputFile);
 }
 
 /// Add the provided instrumentation to the pass manager.