[mlir][Pass] Add a new PassNameCLParser specifically for parsing lists of pass names

[rriddle]

Summary

This parser does not include the general pass_pipeline option, the pass pipeline entries, or the options of pass entries. This is useful for cases such as print-ir-after that just want the user to select specific pass types. This revision greatly reduces the amount of text in --help for several MLIR based tools.

Fixes PR#45495

[rriddle]

Rebase

mlir/include/mlir/Pass/PassRegistry.h

public:
   LogicalResult
   addToPipeline(OpPassManager &pm,
                 function_ref<LogicalResult(const Twine &)> errorHandler) const;
 
 private:
   std::unique_ptr<detail::PassPipelineCLParserImpl> impl;
 };
 
+/// This class implements a command-line parser spefically for MLIR pass names.
+/// It registers a cl option with a given argument and description that accepts
+/// a comma delimited list of pass names.
+class PassNameCLParser {
+public:
+  /// Construct a parser with the given command line description.
+  PassNameCLParser(StringRef arg, StringRef description);
+  ~PassNameCLParser();
+
+  /// Returns true if this parser contains any valid options to add.
+  bool hasAnyOccurrences() const;
+
+  /// Returns true if the given pass registry entry was registered at the
+  /// top-level of the parser, i.e. not within an explicit textual pipeline.
+  bool contains(const PassRegistryEntry *entry) const;
+
+private:
+  std::unique_ptr<detail::PassPipelineCLParserImpl> impl;
+};
+
 } // end namespace mlir
 
 #endif // MLIR_PASS_PASSREGISTRY_H_

mlir/lib/Pass/PassManagerOptions.cpp

llvm::cl::opt<bool> localReproducer{
       "pass-pipeline-local-reproducer",
       llvm::cl::desc("When generating a crash reproducer, attempt to generated "
                      "a reproducer with the smallest pipeline."),
       llvm::cl::init(false)};
 
   //===--------------------------------------------------------------------===//
   // IR Printing
   //===--------------------------------------------------------------------===//
-  PassPipelineCLParser printBefore{"print-ir-before",
-                                   "Print IR before specified passes"};
-  PassPipelineCLParser printAfter{"print-ir-after",
-                                  "Print IR after specified passes"};
+  PassNameCLParser printBefore{"print-ir-before",
+  PassNameCLParser printAfter{"print-ir-after",
   llvm::cl::opt<bool> printBeforeAll{
       "print-ir-before-all", llvm::cl::desc("Print IR before each pass"),
       llvm::cl::init(false)};
   llvm::cl::opt<bool> printAfterAll{"print-ir-after-all",
                                     llvm::cl::desc("Print IR after each pass"),
                                     llvm::cl::init(false)};
   llvm::cl::opt<bool> printAfterChange{
       "print-ir-after-change",

mlir/lib/Pass/PassRegistry.cpp

struct PassNameParser : public llvm::cl::parser<PassArgData> {
   PassNameParser(llvm::cl::Option &opt) : llvm::cl::parser<PassArgData>(opt) {}
 
   void initialize();
   void printOptionInfo(const llvm::cl::Option &opt,
                        size_t globalWidth) const override;
   size_t getOptionWidth(const llvm::cl::Option &opt) const override;
   bool parse(llvm::cl::Option &opt, StringRef argName, StringRef arg,
              PassArgData &value);
+
+  /// If true, this parser only parses entries that correspond to a concrete
+  /// pass registry entry, and does not add a `pass-pipeline` argument, does not
+  /// include the options for pass entries, and does not include pass pipelines
+  /// entries.
+  bool passNamesOnly = false;
 };
 } // namespace
 
 void PassNameParser::initialize() {
   llvm::cl::parser<PassArgData>::initialize();
 
   /// Add an entry for the textual pass pipeline option.
+  if (!passNamesOnly) {
     addLiteralOption(passPipelineArg, PassArgData(),
                      "A textual description of a pass pipeline to run");
+  }
 
   /// Add the pass entries.
   for (const auto &kv : *passRegistry) {
     addLiteralOption(kv.second.getPassArgument(), &kv.second,
                      kv.second.getPassDescription());
   }
   /// Add the pass pipeline entries.
+  if (!passNamesOnly) {
     for (const auto &kv : *passPipelineRegistry) {
       addLiteralOption(kv.second.getPassArgument(), &kv.second,
                        kv.second.getPassDescription());
     }
   }
+}
 
 void PassNameParser::printOptionInfo(const llvm::cl::Option &opt,
                                      size_t globalWidth) const {
+  // If this parser is just parsing pass names, print a simplified option
+  // string.
+  if (passNamesOnly) {
+    llvm::outs() << "  --" << opt.ArgStr << "=<pass-arg>";
+    opt.printHelpStr(opt.HelpStr, globalWidth, opt.ArgStr.size() + 18);
+    return;
+  }
+
   // Print the information for the top-level option.
   if (opt.hasArgStr()) {
     llvm::outs() << "  --" << opt.ArgStr;
     opt.printHelpStr(opt.HelpStr, globalWidth, opt.ArgStr.size() + 7);
   } else {
     llvm::outs() << "  " << opt.HelpStr << '\n';
   }
 

 
 //===----------------------------------------------------------------------===//
 // PassPipelineCLParser
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace detail {
 struct PassPipelineCLParserImpl {
-  PassPipelineCLParserImpl(StringRef arg, StringRef description)
+  PassPipelineCLParserImpl(StringRef arg, StringRef description,
+                           bool passNamesOnly)
       : passList(arg, llvm::cl::desc(description)) {
+    passList.getParser().passNamesOnly = passNamesOnly;
     passList.setValueExpectedFlag(llvm::cl::ValueExpected::ValueOptional);
   }
 
+  /// Returns true if the given pass registry entry was registered at the
+  /// top-level of the parser, i.e. not within an explicit textual pipeline.
+  bool contains(const PassRegistryEntry *entry) const {
+    return llvm::any_of(passList, [&](const PassArgData &data) {
+      return data.registryEntry == entry;
+    });
+  }
+
   /// The set of passes and pass pipelines to run.
   llvm::cl::list<PassArgData, bool, PassNameParser> passList;
 };
 } // end namespace detail
 } // end namespace mlir
 
 /// Construct a pass pipeline parser with the given command line description.
 PassPipelineCLParser::PassPipelineCLParser(StringRef arg, StringRef description)
-    : impl(std::make_unique<detail::PassPipelineCLParserImpl>(arg,
-                                                              description)) {}
+    : impl(std::make_unique<detail::PassPipelineCLParserImpl>(
+          arg, description, /*passNamesOnly=*/false)) {}
 PassPipelineCLParser::~PassPipelineCLParser() {}
 
 /// Returns true if this parser contains any valid options to add.
 bool PassPipelineCLParser::hasAnyOccurrences() const {
   return impl->passList.getNumOccurrences() != 0;
 }
 
 /// Returns true if the given pass registry entry was registered at the
 /// top-level of the parser, i.e. not within an explicit textual pipeline.
 bool PassPipelineCLParser::contains(const PassRegistryEntry *entry) const {
-  return llvm::any_of(impl->passList, [&](const PassArgData &data) {
-    return data.registryEntry == entry;
-  });
+  return impl->contains(entry);
 }
 
 /// Adds the passes defined by this parser entry to the given pass manager.
 LogicalResult PassPipelineCLParser::addToPipeline(
     OpPassManager &pm,
     function_ref<LogicalResult(const Twine &)> errorHandler) const {
   for (auto &passIt : impl->passList) {
     if (passIt.registryEntry) {
       if (failed(passIt.registryEntry->addToPipeline(pm, passIt.options,
                                                      errorHandler)))
         return failure();
     } else {
       OpPassManager::Nesting nesting = pm.getNesting();
       pm.setNesting(OpPassManager::Nesting::Explicit);
       LogicalResult status = passIt.pipeline.addToPipeline(pm, errorHandler);
       pm.setNesting(nesting);
       if (failed(status))
         return failure();
     }
   }
   return success();
 }
+
+//===----------------------------------------------------------------------===//
+// PassNameCLParser
+
+/// Construct a pass pipeline parser with the given command line description.
+PassNameCLParser::PassNameCLParser(StringRef arg, StringRef description)
+    : impl(std::make_unique<detail::PassPipelineCLParserImpl>(
+          arg, description, /*passNamesOnly=*/true)) {
+  impl->passList.setMiscFlag(llvm::cl::CommaSeparated);
+}
+PassNameCLParser::~PassNameCLParser() {}
+
+/// Returns true if this parser contains any valid options to add.
+bool PassNameCLParser::hasAnyOccurrences() const {
+  return impl->passList.getNumOccurrences() != 0;
+}
+
+/// Returns true if the given pass registry entry was registered at the
+/// top-level of the parser, i.e. not within an explicit textual pipeline.
+bool PassNameCLParser::contains(const PassRegistryEntry *entry) const {
+  return impl->contains(entry);
+}