[mlir][Pass] Add a new `Pass::getArgument` hook

[rriddle]

Summary

This hook allows for passes to specify the command line argument without the need for registration. More concretely this will allow for generating pass crash reproducers without needing to have the passes registered. This should remove the need for production tools to register passes, leaving that solely to development tools like mlir-opt.

mlir/include/mlir/Pass/Pass.h

public:
   template <typename PassT> static const PassInfo *lookupPassInfo() {
     return lookupPassInfo(PassID::getID<PassT>());
   }
 
   /// Returns the pass info for this pass.
   const PassInfo *lookupPassInfo() const { return lookupPassInfo(getPassID()); }
 
   /// Returns the derived pass name.
-  virtual StringRef getName() = 0;
+  virtual StringRef getName() const = 0;
+
+  /// Returns the command line argument used when registering this pass. Return
+  /// an empty string if one does not exist.
+  virtual StringRef getArgument() const {
+    if (const PassInfo *passInfo = lookupPassInfo())
+      return passInfo->getPassArgument();
+    return "";
+  }
 
   /// Returns the name of the operation that this pass operates on, or None if
   /// this is a generic OperationPass.
   Optional<StringRef> getOpName() const { return opName; }
 
   //===--------------------------------------------------------------------===//
   // Options
   //===--------------------------------------------------------------------===//
public:
   static bool classof(const Pass *pass) {
     return pass->getPassID() == PassID::getID<PassT>();
   }
 
 protected:
   PassWrapper() : BaseT(PassID::getID<PassT>()) {}
 
   /// Returns the derived pass name.
-  StringRef getName() override {
-    StringRef name = llvm::getTypeName<PassT>();
-    if (!name.consume_front("mlir::"))
-      name.consume_front("(anonymous namespace)::");
-    return name;
-  }
+  StringRef getName() const override { return llvm::getTypeName<PassT>(); }
 
   /// A clone method to create a copy of this pass.
   std::unique_ptr<Pass> clonePass() const override {
     return std::make_unique<PassT>(*static_cast<const PassT *>(this));
   }
 };
 
 } // end namespace mlir
 
 #endif // MLIR_PASS_PASS_H

mlir/lib/Pass/Pass.cpp

void Pass::printAsTextualPipeline(raw_ostream &os) {
   if (auto *adaptor = getAdaptorPassBase(this)) {
     interleaveComma(adaptor->getPassManagers(), os, [&](OpPassManager &pm) {
       os << pm.getOpName() << "(";
       pm.printAsTextualPipeline(os);
       os << ")";
     });
     return;
   }
-  // Otherwise, print the pass argument followed by its options.
-  if (const PassInfo *info = lookupPassInfo())
-    os << info->getPassArgument();
+  // 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 << getName();
+    os << "unknown<" << getName() << ">";
   passOptions.print(os);
 }
 
 /// Forwarding function to execute this pass.
 LogicalResult Pass::run(Operation *op, AnalysisManager am) {
   passState.emplace(op, am);
 
   // Instrument before the pass has run.

mlir/tools/mlir-tblgen/PassGen.cpp

 
 template <typename DerivedT>
 class {0}Base : public {1} {
 public:
   {0}Base() : {1}(PassID::getID<DerivedT>()) {{}
   {0}Base(const {0}Base &) : {1}(PassID::getID<DerivedT>()) {{}
 
   /// Returns the command-line argument attached to this pass.
-  static llvm::StringRef getPassArgument() { return "{2}"; }
+  llvm::StringRef getArgument() const override { return "{2}"; }
 
   /// Returns the derived pass name.
-  llvm::StringRef getName() override { return "{0}"; }
+  llvm::StringRef getName() const override { return "{0}"; }
 
   /// Support isa/dyn_cast functionality for the derived pass class.
   static bool classof(const ::mlir::Pass *pass) {{
     return pass->getPassID() == ::mlir::PassID::getID<DerivedT>();
   }
 
   /// A clone method to create a copy of this pass.
   std::unique_ptr<Pass> clonePass() const override {{