Add a dump() method on the pass manager for debugging purpose (NFC)

mlir/include/mlir/Pass/Pass.h

struct ListOption
     using detail::PassOptions::ListOption<DataType, OptionParser>::operator=;
   };
 
   /// Attempt to initialize the options of this pass from the given string.
   LogicalResult initializeOptions(StringRef options);
 
   /// Prints out the pass in the textual representation of pipelines. If this is
   /// an adaptor pass, print with the op_name(sub_pass,...) format.
-  void printAsTextualPipeline(raw_ostream &os);
+  void printAsTextualPipeline(raw_ostream &os, bool filterVerifier = true);
 
   //===--------------------------------------------------------------------===//
   // Statistics
   //===--------------------------------------------------------------------===//
 
   /// This class represents a single pass statistic. This statistic functions
   /// similarly to an unsigned integer value, and may be updated and incremented
   /// accordingly. This class can be used to provide additional information

mlir/include/mlir/Pass/PassManager.h

public:
 
   /// Returns the internal implementation instance.
   detail::OpPassManagerImpl &getImpl();
 
   /// Prints out the passes of the pass manager as the textual representation
   /// of pipelines.
   /// Note: The quality of the string representation depends entirely on the
   /// the correctness of per-pass overrides of Pass::printAsTextualPipeline.
-  void printAsTextualPipeline(raw_ostream &os);
+  void printAsTextualPipeline(raw_ostream &os, bool filterVerifier = true);
+
+  /// Raw dump of the pass manager to llvm::errs().
+  void dump();
 
   /// Merge the pass statistics of this class into 'other'.
   void mergeStatisticsInto(OpPassManager &other);
 
   /// Register dependent dialects for the current pass manager.
   /// This is forwarding to every pass in this PassManager, see the
   /// documentation for the same method on the Pass class.
   void getDependentDialects(DialectRegistry &dialects) const;

mlir/lib/Pass/Pass.cpp

 /// Copy the option values from 'other', which is another instance of this
 /// pass.
 void Pass::copyOptionValuesFrom(const Pass *other) {
   passOptions.copyOptionValuesFrom(other->passOptions);
 }
 
 /// Prints out the pass in the textual representation of pipelines. If this is
 /// an adaptor pass, print with the op_name(sub_pass,...) format.
-void Pass::printAsTextualPipeline(raw_ostream &os) {
+void Pass::printAsTextualPipeline(raw_ostream &os, bool filterVerifier) {
   // Special case for adaptors to use the 'op_name(sub_passes)' format.
   if (auto *adaptor = dyn_cast<OpToOpPassAdaptor>(this)) {
     llvm::interleaveComma(adaptor->getPassManagers(), os,
                           [&](OpPassManager &pm) {
                             os << pm.getOpName() << "(";
-                            pm.printAsTextualPipeline(os);
+                            pm.printAsTextualPipeline(os, filterVerifier);
                             os << ")";
                           });
     return;
   }
   // Otherwise, print the pass argument followed by its options. If the pass
   // doesn't have an argument, print the name of the pass to give some indicator
   // of what pass was run.
   StringRef argument = getArgument();
   if (!argument.empty())
     os << argument;
   else
     os << "unknown<" << getName() << ">";
   passOptions.print(os);
 }
 
-
 //===----------------------------------------------------------------------===//
 // Verifier Passes
 //===----------------------------------------------------------------------===//
 
 void VerifierPass::runOnOperation() {
   if (failed(verify(getOperation())))
     signalPassFailure();
   markAllAnalysesPreserved();

 
 /// Return the operation name that this pass manager operates on.
 Identifier OpPassManager::getOpName(MLIRContext &context) const {
   return impl->getOpName(context);
 }
 
 /// Prints out the given passes as the textual representation of a pipeline.
 static void printAsTextualPipeline(ArrayRef<std::unique_ptr<Pass>> passes,
-                                   raw_ostream &os) {
+                                   raw_ostream &os,
+                                   bool filterVerifier = true) {
   // Filter out passes that are not part of the public pipeline.
   auto filteredPasses =
-      llvm::make_filter_range(passes, [](const std::unique_ptr<Pass> &pass) {
-        return !isa<VerifierPass>(pass);
+      llvm::make_filter_range(passes, [&](const std::unique_ptr<Pass> &pass) {
+        return !filterVerifier || !isa<VerifierPass>(pass);
       });
   llvm::interleaveComma(filteredPasses, os,
                         [&](const std::unique_ptr<Pass> &pass) {
-                          pass->printAsTextualPipeline(os);
+                          pass->printAsTextualPipeline(os, filterVerifier);
                         });
 }
 
 /// Prints out the passes of the pass manager as the textual representation
 /// of pipelines.
-void OpPassManager::printAsTextualPipeline(raw_ostream &os) {
-  ::printAsTextualPipeline(impl->passes, os);
+void OpPassManager::printAsTextualPipeline(raw_ostream &os,
+                                           bool filterVerifier) {
+  ::printAsTextualPipeline(impl->passes, os, filterVerifier);
+}
+
+void OpPassManager::dump() {
+  llvm::errs() << "Pass Manager with " << impl->passes.size() << " passes: ";
+  ::printAsTextualPipeline(impl->passes, llvm::errs(),
+                           /*filterVerifier=*/false);
+  llvm::errs() << "\n";
 }
 
 static void registerDialectsForPipeline(const OpPassManager &pm,
                                         DialectRegistry &dialects) {
   for (const Pass &pass : pm.getPasses())
     pass.getDependentDialects(dialects);
 }