Migrate MLIR test passes to the new registration API

[mehdi_amini]

Summary

Make sure they all define getArgument()/getDescription().

Depends On D104421

mlir/lib/Dialect/GPU/Transforms/SerializeToCubin.cpp

#define RETURN_ON_CUDA_ERROR(expr)                                             \
   } while (false)
 
 namespace {
 class SerializeToCubinPass
     : public PassWrapper<SerializeToCubinPass, gpu::SerializeToBlobPass> {
 public:
   SerializeToCubinPass();
 
+  StringRef getArgument() const override { return "gpu-to-cubin"; }
+  StringRef getDescription() const override {
+    return "Lower GPU kernel function to CUBIN binary annotations";
+  }
+
 private:
   void getDependentDialects(DialectRegistry &registry) const override;
 
   // Serializes PTX to CUBIN.
   std::unique_ptr<std::vector<char>>
   serializeISA(const std::string &isa) override;
 };
 } // namespace
SerializeToCubinPass::serializeISA(const std::string &isa) {
   RETURN_ON_CUDA_ERROR(cuCtxDestroy(context));
 
   return result;
 }
 
 // Register pass to serialize GPU kernel functions to a CUBIN binary annotation.
 void mlir::registerGpuSerializeToCubinPass() {
   PassRegistration<SerializeToCubinPass> registerSerializeToCubin(
-      "gpu-to-cubin", "Lower GPU kernel function to CUBIN binary annotations",
       [] {
         // Initialize LLVM NVPTX backend.
         LLVMInitializeNVPTXTarget();
         LLVMInitializeNVPTXTargetInfo();
         LLVMInitializeNVPTXTargetMC();
         LLVMInitializeNVPTXAsmPrinter();
 
         return std::make_unique<SerializeToCubinPass>();
       });
 }
 #else  // MLIR_GPU_TO_CUBIN_PASS_ENABLE
 void mlir::registerGpuSerializeToCubinPass() {}
 #endif // MLIR_GPU_TO_CUBIN_PASS_ENABLE

mlir/lib/Dialect/GPU/Transforms/SerializeToHsaco.cpp

 using namespace mlir;
 
 namespace {
 class SerializeToHsacoPass
     : public PassWrapper<SerializeToHsacoPass, gpu::SerializeToBlobPass> {
 public:
   SerializeToHsacoPass();
 
+  StringRef getArgument() const override { return "gpu-to-hsaco"; }
+  StringRef getDescription() const override {
+    return "Lower GPU kernel function to HSACO binary annotations";
+  }
+
 private:
   void getDependentDialects(DialectRegistry &registry) const override;
 
   // Serializes ROCDL to HSACO.
   std::unique_ptr<std::vector<char>>
   serializeISA(const std::string &isa) override;
 
   std::unique_ptr<SmallVectorImpl<char>> assembleIsa(const std::string &isa);
SerializeToHsacoPass::serializeISA(const std::string &isa) {
   if (!isaBinary)
     return {};
   return createHsaco(*isaBinary);
 }
 
 // Register pass to serialize GPU kernel functions to a HSACO binary annotation.
 void mlir::registerGpuSerializeToHsacoPass() {
   PassRegistration<SerializeToHsacoPass> registerSerializeToHSACO(
-      "gpu-to-hsaco", "Lower GPU kernel function to HSACO binary annotations",
       [] {
         // Initialize LLVM AMDGPU backend.
         LLVMInitializeAMDGPUAsmParser();
         LLVMInitializeAMDGPUAsmPrinter();
         LLVMInitializeAMDGPUTarget();
         LLVMInitializeAMDGPUTargetInfo();
         LLVMInitializeAMDGPUTargetMC();
 
         return std::make_unique<SerializeToHsacoPass>();
       });
 }
 #else  // MLIR_GPU_TO_HSACO_PASS_ENABLE
 void mlir::registerGpuSerializeToHsacoPass() {}
 #endif // MLIR_GPU_TO_HSACO_PASS_ENABLE

mlir/test/lib/Analysis/TestAliasAnalysis.cpp

 
 //===----------------------------------------------------------------------===//
 // Testing AliasResult
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TestAliasAnalysisPass
     : public PassWrapper<TestAliasAnalysisPass, OperationPass<>> {
+  StringRef getArgument() const final { return "test-alias-analysis"; }
+  StringRef getDescription() const final {
+    return "Test alias analysis results.";
+  }
   void runOnOperation() override {
     llvm::errs() << "Testing : " << getOperation()->getAttr("sym_name") << "\n";
 
     // Collect all of the values to check for aliasing behavior.
     AliasAnalysis &aliasAnalysis = getAnalysis<AliasAnalysis>();
     SmallVector<Value, 32> valsToCheck;
     getOperation()->walk([&](Operation *op) {
       if (!op->getAttr("test.ptr"))

 
 //===----------------------------------------------------------------------===//
 // Testing ModRefResult
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TestAliasAnalysisModRefPass
     : public PassWrapper<TestAliasAnalysisModRefPass, OperationPass<>> {
+  StringRef getArgument() const final { return "test-alias-analysis-modref"; }
+  StringRef getDescription() const final {
+    return "Test alias analysis ModRef results.";
+  }
   void runOnOperation() override {
     llvm::errs() << "Testing : " << getOperation()->getAttr("sym_name") << "\n";
 
     // Collect all of the values to check for aliasing behavior.
     AliasAnalysis &aliasAnalysis = getAnalysis<AliasAnalysis>();
     SmallVector<Value, 32> valsToCheck;
     getOperation()->walk([&](Operation *op) {
       if (!op->getAttr("test.ptr"))

 
 //===----------------------------------------------------------------------===//
 // Pass Registration
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace test {
 void registerTestAliasAnalysisPass() {
-  PassRegistration<TestAliasAnalysisPass> aliasPass(
-      "test-alias-analysis", "Test alias analysis results.");
-  PassRegistration<TestAliasAnalysisModRefPass> modRefPass(
-      "test-alias-analysis-modref", "Test alias analysis ModRef results.");
+  PassRegistration<TestAliasAnalysisPass>();
+  PassRegistration<TestAliasAnalysisModRefPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestCallGraph.cpp

 #include "mlir/Analysis/CallGraph.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 struct TestCallGraphPass
     : public PassWrapper<TestCallGraphPass, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-print-callgraph"; }
+  StringRef getDescription() const final {
+    return "Print the contents of a constructed callgraph.";
+  }
   void runOnOperation() override {
     llvm::errs() << "Testing : " << getOperation()->getAttr("test.name")
                  << "\n";
     getAnalysis<CallGraph>().print(llvm::errs());
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
-void registerTestCallGraphPass() {
-  PassRegistration<TestCallGraphPass> pass(
-      "test-print-callgraph", "Print the contents of a constructed callgraph.");
-}
+void registerTestCallGraphPass() { PassRegistration<TestCallGraphPass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestLiveness.cpp

 #include "mlir/Analysis/Liveness.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 
 struct TestLivenessPass : public PassWrapper<TestLivenessPass, FunctionPass> {
+  StringRef getArgument() const final { return "test-print-liveness"; }
+  StringRef getDescription() const final {
+    return "Print the contents of a constructed liveness information.";
+  }
   void runOnFunction() override {
     llvm::errs() << "Testing : " << getFunction().getName() << "\n";
     getAnalysis<Liveness>().print(llvm::errs());
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
-void registerTestLivenessPass() {
-  PassRegistration<TestLivenessPass>(
-      "test-print-liveness",
-      "Print the contents of a constructed liveness information.");
-}
+void registerTestLivenessPass() { PassRegistration<TestLivenessPass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestMemRefBoundCheck.cpp

 
 using namespace mlir;
 
 namespace {
 
 /// Checks for out of bound memref access subscripts..
 struct TestMemRefBoundCheck
     : public PassWrapper<TestMemRefBoundCheck, FunctionPass> {
+  StringRef getArgument() const final { return "test-memref-bound-check"; }
+  StringRef getDescription() const final {
+    return "Check memref access bounds in a Function";
+  }
   void runOnFunction() override;
 };
 
 } // end anonymous namespace
 
 void TestMemRefBoundCheck::runOnFunction() {
   getFunction().walk([](Operation *opInst) {
     TypeSwitch<Operation *>(opInst)
         .Case<AffineReadOpInterface, AffineWriteOpInterface>(
             [](auto op) { (void)boundCheckLoadOrStoreOp(op); });
 
     // TODO: do this for DMA ops as well.
   });
 }
 
 namespace mlir {
 namespace test {
-void registerMemRefBoundCheck() {
-  PassRegistration<TestMemRefBoundCheck>(
-      "test-memref-bound-check", "Check memref access bounds in a Function");
-}
+void registerMemRefBoundCheck() { PassRegistration<TestMemRefBoundCheck>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestMemRefDependenceCheck.cpp

 using namespace mlir;
 
 namespace {
 
 // TODO: Add common surrounding loop depth-wise dependence checks.
 /// Checks dependences between all pairs of memref accesses in a Function.
 struct TestMemRefDependenceCheck
     : public PassWrapper<TestMemRefDependenceCheck, FunctionPass> {
+  StringRef getArgument() const final { return "test-memref-dependence-check"; }
+  StringRef getDescription() const final {
+    return "Checks dependences between all pairs of memref accesses.";
+  }
   SmallVector<Operation *, 4> loadsAndStores;
   void runOnFunction() override;
 };
 
 } // end anonymous namespace
 
 // Returns a result string which represents the direction vector (if there was
 // a dependence), returns the string "false" otherwise.
void TestMemRefDependenceCheck::runOnFunction() {
   });
 
   checkDependences(loadsAndStores);
 }
 
 namespace mlir {
 namespace test {
 void registerTestMemRefDependenceCheck() {
-  PassRegistration<TestMemRefDependenceCheck> pass(
-      "test-memref-dependence-check",
-      "Checks dependences between all pairs of memref accesses.");
+  PassRegistration<TestMemRefDependenceCheck>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestMemRefStrideCalculation.cpp

 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 struct TestMemRefStrideCalculation
     : public PassWrapper<TestMemRefStrideCalculation, FunctionPass> {
+  StringRef getArgument() const final {
+    return "test-memref-stride-calculation";
+  }
+  StringRef getDescription() const final {
+    return "Test operation constant folding";
+  }
   void runOnFunction() override;
 };
 } // end anonymous namespace
 
 /// Traverse AllocOp and compute strides of each MemRefType independently.
 void TestMemRefStrideCalculation::runOnFunction() {
   llvm::outs() << "Testing: " << getFunction().getName() << "\n";
   getFunction().walk([&](memref::AllocOp allocOp) {
getFunction().walk([&](memref::AllocOp allocOp) {
     llvm::outs() << "\n";
   });
   llvm::outs().flush();
 }
 
 namespace mlir {
 namespace test {
 void registerTestMemRefStrideCalculation() {
-  PassRegistration<TestMemRefStrideCalculation> pass(
-      "test-memref-stride-calculation", "Test operation constant folding");
+  PassRegistration<TestMemRefStrideCalculation>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestNumberOfExecutions.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 
 struct TestNumberOfBlockExecutionsPass
     : public PassWrapper<TestNumberOfBlockExecutionsPass, FunctionPass> {
+  StringRef getArgument() const final {
+    return "test-print-number-of-block-executions";
+  }
+  StringRef getDescription() const final {
+    return "Print the contents of a constructed number of executions analysis "
+           "for "
+           "all blocks.";
+  }
   void runOnFunction() override {
     llvm::errs() << "Number of executions: " << getFunction().getName() << "\n";
     getAnalysis<NumberOfExecutions>().printBlockExecutions(
         llvm::errs(), &getFunction().getBody());
   }
 };
 
 struct TestNumberOfOperationExecutionsPass
     : public PassWrapper<TestNumberOfOperationExecutionsPass, FunctionPass> {
+  StringRef getArgument() const final {
+    return "test-print-number-of-operation-executions";
+  }
+  StringRef getDescription() const final {
+    return "Print the contents of a constructed number of executions analysis "
+           "for "
+           "all operations.";
+  }
   void runOnFunction() override {
     llvm::errs() << "Number of executions: " << getFunction().getName() << "\n";
     getAnalysis<NumberOfExecutions>().printOperationExecutions(
         llvm::errs(), &getFunction().getBody());
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
 void registerTestNumberOfBlockExecutionsPass() {
-  PassRegistration<TestNumberOfBlockExecutionsPass>(
-      "test-print-number-of-block-executions",
-      "Print the contents of a constructed number of executions analysis for "
-      "all blocks.");
+  PassRegistration<TestNumberOfBlockExecutionsPass>();
 }
 
 void registerTestNumberOfOperationExecutionsPass() {
-  PassRegistration<TestNumberOfOperationExecutionsPass>(
-      "test-print-number-of-operation-executions",
-      "Print the contents of a constructed number of executions analysis for "
-      "all operations.");
+  PassRegistration<TestNumberOfOperationExecutionsPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Conversion/StandardToLLVM/TestConvertCallOp.cpp

 };
 
 class TestConvertCallOp
     : public PassWrapper<TestConvertCallOp, OperationPass<ModuleOp>> {
 public:
   void getDependentDialects(DialectRegistry &registry) const final {
     registry.insert<LLVM::LLVMDialect>();
   }
+  StringRef getArgument() const final { return "test-convert-call-op"; }
+  StringRef getDescription() const final {
+    return "Tests conversion of `std.call` to `llvm.call` in "
+           "presence of custom types";
+  }
 
   void runOnOperation() override {
     ModuleOp m = getOperation();
 
     // Populate type conversions.
     LLVMTypeConverter typeConverter(m.getContext());
     typeConverter.addConversion([&](test::TestType type) {
       return LLVM::LLVMPointerType::get(IntegerType::get(m.getContext(), 8));
if (failed(applyPartialConversion(m, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 namespace mlir {
 namespace test {
-void registerConvertCallOpPass() {
-  PassRegistration<TestConvertCallOp>(
-      "test-convert-call-op",
-      "Tests conversion of `std.call` to `llvm.call` in "
-      "presence of custom types");
-}
+void registerConvertCallOpPass() { PassRegistration<TestConvertCallOp>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Affine/TestAffineDataCopy.cpp

 using namespace mlir;
 
 static llvm::cl::OptionCategory clOptionsCategory(PASS_NAME " options");
 
 namespace {
 
 struct TestAffineDataCopy
     : public PassWrapper<TestAffineDataCopy, FunctionPass> {
+  StringRef getArgument() const final { return PASS_NAME; }
+  StringRef getDescription() const final {
+    return "Tests affine data copy utility functions.";
+  }
   TestAffineDataCopy() = default;
   TestAffineDataCopy(const TestAffineDataCopy &pass){};
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
   void runOnFunction() override;
 
if (isa<AffineLoadOp>(op)) {
       AffineStoreOp::getCanonicalizationPatterns(patterns, &getContext());
     }
     (void)applyOpPatternsAndFold(op, std::move(patterns));
   }
 }
 
 namespace mlir {
 void registerTestAffineDataCopyPass() {
-  PassRegistration<TestAffineDataCopy>(
-      PASS_NAME, "Tests affine data copy utility functions.");
+  PassRegistration<TestAffineDataCopy>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/Affine/TestAffineLoopParametricTiling.cpp

 
 using namespace mlir;
 
 #define DEBUG_TYPE "test-affine-parametric-tile"
 
 namespace {
 struct TestAffineLoopParametricTiling
     : public PassWrapper<TestAffineLoopParametricTiling, FunctionPass> {
+  StringRef getArgument() const final { return "test-affine-parametric-tile"; }
+  StringRef getDescription() const final {
+    return "Tile affine loops using SSA values as tile sizes";
+  }
   void runOnFunction() override;
 };
 } // end anonymous namespace
 
 /// Checks if the function enclosing the loop nest has any arguments passed to
 /// it, which can be used as tiling parameters. Assumes that atleast 'n'
 /// arguments are passed, where 'n' is the number of loops in the loop nest.
 static void checkIfTilingParametersExist(ArrayRef<AffineForOp> band) {
if (failed(
             tilePerfectlyNestedParametric(band, tilingParameters, &tiledNest)))
       return signalPassFailure();
   }
 }
 
 namespace mlir {
 namespace test {
 void registerTestAffineLoopParametricTilingPass() {
-  PassRegistration<TestAffineLoopParametricTiling>(
-      "test-affine-parametric-tile",
-      "Tile affine loops using SSA values as tile sizes");
+  PassRegistration<TestAffineLoopParametricTiling>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Affine/TestAffineLoopUnswitching.cpp

 
 using namespace mlir;
 
 namespace {
 
 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestAffineLoopUnswitching
     : public PassWrapper<TestAffineLoopUnswitching, FunctionPass> {
+  StringRef getArgument() const final { return PASS_NAME; }
+  StringRef getDescription() const final {
+    return "Tests affine loop unswitching / if/else hoisting";
+  }
   TestAffineLoopUnswitching() = default;
   TestAffineLoopUnswitching(const TestAffineLoopUnswitching &pass) {}
 
   void runOnFunction() override;
 
   /// The maximum number of iterations to run this for.
   constexpr static unsigned kMaxIterations = 5;
 };
do {
     };
     if (func.walk(walkFn).wasInterrupted())
       break;
   } while (++i < kMaxIterations);
 }
 
 namespace mlir {
 void registerTestAffineLoopUnswitchingPass() {
-  PassRegistration<TestAffineLoopUnswitching>(
-      PASS_NAME, "Tests affine loop unswitching / if/else hoisting");
+  PassRegistration<TestAffineLoopUnswitching>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/Affine/TestLoopPermutation.cpp

 
 static llvm::cl::OptionCategory clOptionsCategory(PASS_NAME " options");
 
 namespace {
 
 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestLoopPermutation
     : public PassWrapper<TestLoopPermutation, FunctionPass> {
+  StringRef getArgument() const final { return PASS_NAME; }
+  StringRef getDescription() const final {
+    return "Tests affine loop permutation utility";
+  }
   TestLoopPermutation() = default;
   TestLoopPermutation(const TestLoopPermutation &pass){};
 
   void runOnFunction() override;
 
 private:
   /// Permutation specifying loop i is mapped to permList[i] in
   /// transformed nest (with i going from outermost to innermost).
if (nest.size() < 2)
     return;
 
   SmallVector<unsigned, 4> permMap(permList.begin(), permList.end());
   permuteLoops(nest, permMap);
 }
 
 namespace mlir {
 void registerTestLoopPermutationPass() {
-  PassRegistration<TestLoopPermutation>(
-      PASS_NAME, "Tests affine loop permutation utility");
+  PassRegistration<TestLoopPermutation>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/Affine/TestVectorizationUtils.cpp

 namespace {
 struct VectorizerTestPass
     : public PassWrapper<VectorizerTestPass, FunctionPass> {
   static constexpr auto kTestAffineMapOpName = "test_affine_map";
   static constexpr auto kTestAffineMapAttrName = "affine_map";
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<vector::VectorDialect>();
   }
+  StringRef getArgument() const final { return "affine-super-vectorizer-test"; }
+  StringRef getDescription() const final {
+    return "Tests vectorizer standalone functionality.";
+  }
 
   void runOnFunction() override;
   void testVectorShapeRatio(llvm::raw_ostream &outs);
   void testForwardSlicing(llvm::raw_ostream &outs);
   void testBackwardSlicing(llvm::raw_ostream &outs);
   void testSlicing(llvm::raw_ostream &outs);
   void testComposeMaps(llvm::raw_ostream &outs);
 
if (clTestVecAffineLoopNest)
     testVecAffineLoopNest();
 
   if (!outs.str().empty()) {
     emitRemark(UnknownLoc::get(&getContext()), outs.str());
   }
 }
 
 namespace mlir {
-void registerVectorizerTestPass() {
-  PassRegistration<VectorizerTestPass> pass(
-      "affine-super-vectorizer-test",
-      "Tests vectorizer standalone functionality.");
-}
+void registerVectorizerTestPass() { PassRegistration<VectorizerTestPass>(); }
 } // namespace mlir

mlir/test/lib/Dialect/DLTI/TestDataLayoutQuery.cpp

 
 namespace {
 
 /// A pass that finds "test.data_layout_query" operations and attaches to them
 /// attributes containing the results of data layout queries for operation
 /// result types.
 struct TestDataLayoutQuery
     : public PassWrapper<TestDataLayoutQuery, FunctionPass> {
+  StringRef getArgument() const final { return "test-data-layout-query"; }
+  StringRef getDescription() const final { return "Test data layout queries"; }
   void runOnFunction() override {
     FuncOp func = getFunction();
     Builder builder(func.getContext());
     const DataLayoutAnalysis &layouts = getAnalysis<DataLayoutAnalysis>();
 
     func.walk([&](test::DataLayoutQueryOp op) {
       // Skip the ops with already processed in a deeper call.
       if (op->getAttr("size"))
func.walk([&](test::DataLayoutQueryOp op) {
            builder.getNamedAttr("preferred", builder.getIndexAttr(preferred))});
     });
   }
 };
 } // namespace
 
 namespace mlir {
 namespace test {
-void registerTestDataLayoutQuery() {
-  PassRegistration<TestDataLayoutQuery>("test-data-layout-query",
-                                        "Test data layout queries");
-}
+void registerTestDataLayoutQuery() { PassRegistration<TestDataLayoutQuery>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/GPU/TestConvertGPUKernelToCubin.cpp

 
 using namespace mlir;
 
 #if MLIR_CUDA_CONVERSIONS_ENABLED
 namespace {
 class TestSerializeToCubinPass
     : public PassWrapper<TestSerializeToCubinPass, gpu::SerializeToBlobPass> {
 public:
+  StringRef getArgument() const final { return "test-gpu-to-cubin"; }
+  StringRef getDescription() const final {
+    return "Lower GPU kernel function to CUBIN binary annotations";
+  }
   TestSerializeToCubinPass();
 
 private:
   void getDependentDialects(DialectRegistry &registry) const override;
 
   // Serializes PTX to CUBIN.
   std::unique_ptr<std::vector<char>>
   serializeISA(const std::string &isa) override;
TestSerializeToCubinPass::serializeISA(const std::string &) {
   std::string data = "CUBIN";
   return std::make_unique<std::vector<char>>(data.begin(), data.end());
 }
 
 namespace mlir {
 namespace test {
 // Register test pass to serialize GPU module to a CUBIN binary annotation.
 void registerTestGpuSerializeToCubinPass() {
-  PassRegistration<TestSerializeToCubinPass> registerSerializeToCubin(
-      "test-gpu-to-cubin",
-      "Lower GPU kernel function to CUBIN binary annotations", [] {
-        // Initialize LLVM NVPTX backend.
-        LLVMInitializeNVPTXTarget();
-        LLVMInitializeNVPTXTargetInfo();
-        LLVMInitializeNVPTXTargetMC();
-        LLVMInitializeNVPTXAsmPrinter();
+  PassRegistration<TestSerializeToCubinPass>([] {
 
-        return std::make_unique<TestSerializeToCubinPass>();
-      });
 }
 } // namespace test
 } // namespace mlir
 #endif // MLIR_CUDA_CONVERSIONS_ENABLED

mlir/test/lib/Dialect/GPU/TestConvertGPUKernelToHsaco.cpp

 
 using namespace mlir;
 
 #if MLIR_ROCM_CONVERSIONS_ENABLED
 namespace {
 class TestSerializeToHsacoPass
     : public PassWrapper<TestSerializeToHsacoPass, gpu::SerializeToBlobPass> {
 public:
+  StringRef getArgument() const final { return "test-gpu-to-hsaco"; }
+  StringRef getDescription() const final {
+    return "Lower GPU kernel function to HSAco binary annotations";
+  }
   TestSerializeToHsacoPass();
 
 private:
   void getDependentDialects(DialectRegistry &registry) const override;
 
   // Serializes ROCDL IR to HSACO.
   std::unique_ptr<std::vector<char>>
   serializeISA(const std::string &isa) override;
TestSerializeToHsacoPass::serializeISA(const std::string &) {
   std::string data = "HSACO";
   return std::make_unique<std::vector<char>>(data.begin(), data.end());
 }
 
 namespace mlir {
 namespace test {
 // Register test pass to serialize GPU module to a HSAco binary annotation.
 void registerTestGpuSerializeToHsacoPass() {
-  PassRegistration<TestSerializeToHsacoPass> registerSerializeToHsaco(
-      "test-gpu-to-hsaco",
-      "Lower GPU kernel function to HSAco binary annotations", [] {
-        // Initialize LLVM AMDGPU backend.
-        LLVMInitializeAMDGPUTarget();
-        LLVMInitializeAMDGPUTargetInfo();
-        LLVMInitializeAMDGPUTargetMC();
-        LLVMInitializeAMDGPUAsmPrinter();
+  PassRegistration<TestSerializeToHsacoPass>([] {
 
-        return std::make_unique<TestSerializeToHsacoPass>();
-      });
 }
 } // namespace test
 } // namespace mlir
 #endif // MLIR_ROCM_CONVERSIONS_ENABLED

mlir/test/lib/Dialect/GPU/TestGpuMemoryPromotion.cpp

 /// or beneficial (e.g., makes previously uncoalesced loads coalesced).
 class TestGpuMemoryPromotionPass
     : public PassWrapper<TestGpuMemoryPromotionPass,
                          OperationPass<gpu::GPUFuncOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, memref::MemRefDialect, StandardOpsDialect,
                     scf::SCFDialect>();
   }
+  StringRef getArgument() const final { return "test-gpu-memory-promotion"; }
+  StringRef getDescription() const final {
+    return "Promotes the annotated arguments of gpu.func to workgroup memory.";
+  }
 
   void runOnOperation() override {
     gpu::GPUFuncOp op = getOperation();
     for (unsigned i = 0, e = op.getNumArguments(); i < e; ++i) {
       if (op.getArgAttrOfType<UnitAttr>(i, "gpu.test_promote_workgroup"))
         promoteToWorkgroupMemory(op, i);
     }
   }
 };
 } // end namespace
 
 namespace mlir {
 void registerTestGpuMemoryPromotionPass() {
-  PassRegistration<TestGpuMemoryPromotionPass>(
-      "test-gpu-memory-promotion",
-      "Promotes the annotated arguments of gpu.func to workgroup memory.");
+  PassRegistration<TestGpuMemoryPromotionPass>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/GPU/TestGpuParallelLoopMapping.cpp

 using namespace mlir;
 
 namespace {
 /// Simple pass for testing the mapping of parallel loops to hardware ids using
 /// a greedy mapping strategy.
 class TestGpuGreedyParallelLoopMappingPass
     : public PassWrapper<TestGpuGreedyParallelLoopMappingPass,
                          OperationPass<FuncOp>> {
+  StringRef getArgument() const final {
+    return "test-gpu-greedy-parallel-loop-mapping";
+  }
+  StringRef getDescription() const final {
+    return "Greedily maps all parallel loops to gpu hardware ids.";
+  }
   void runOnOperation() override {
     Operation *op = getOperation();
     for (Region &region : op->getRegions())
       greedilyMapParallelSCFToGPU(region);
   }
 };
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestGpuParallelLoopMappingPass() {
-  PassRegistration<TestGpuGreedyParallelLoopMappingPass> registration(
-      "test-gpu-greedy-parallel-loop-mapping",
-      "Greedily maps all parallel loops to gpu hardware ids.");
+  PassRegistration<TestGpuGreedyParallelLoopMappingPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/GPU/TestGpuRewrite.cpp

 using namespace mlir;
 
 namespace {
 struct TestGpuRewritePass
     : public PassWrapper<TestGpuRewritePass, OperationPass<ModuleOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<StandardOpsDialect, memref::MemRefDialect>();
   }
+  StringRef getArgument() const final { return "test-gpu-rewrite"; }
+  StringRef getDescription() const final {
+    return "Applies all rewrite patterns within the GPU dialect.";
+  }
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateGpuRewritePatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 } // namespace
 
 namespace mlir {
 void registerTestAllReduceLoweringPass() {
-  PassRegistration<TestGpuRewritePass> pass(
-      "test-gpu-rewrite",
-      "Applies all rewrite patterns within the GPU dialect.");
+  PassRegistration<TestGpuRewritePass>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/Linalg/TestConvVectorization.cpp

 using namespace mlir;
 using namespace vector;
 
 namespace {
 /// A pass converting MLIR Linalg ops into Vector ops.
 class TestConvVectorization
     : public PassWrapper<TestConvVectorization, OperationPass<ModuleOp>> {
 public:
+  StringRef getArgument() const final { return "test-conv-vectorization"; }
+  StringRef getDescription() const final {
+    return "Test vectorization of convolutions";
+  }
   TestConvVectorization() = default;
   TestConvVectorization(const TestConvVectorization &) {}
   explicit TestConvVectorization(ArrayRef<int64_t> tileSizesParam) {
     tileSizes = tileSizesParam;
   }
 
   void runOnOperation() override;
 
void TestConvVectorization::runOnOperation() {
   module.walk([](linalg::LinalgOp op) {
     op->removeAttr(linalg::LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
 namespace mlir {
 namespace test {
 void registerTestConvVectorization() {
-  PassRegistration<TestConvVectorization> testTransformPatternsPass(
-      "test-conv-vectorization", "Test vectorization of convolutions");
+  PassRegistration<TestConvVectorization>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Linalg/TestLinalgCodegenStrategy.cpp

 #include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgCodegenStrategy
     : public PassWrapper<TestLinalgCodegenStrategy, FunctionPass> {
+  StringRef getArgument() const final { return "test-linalg-codegen-strategy"; }
+  StringRef getDescription() const final {
+    return "Test Linalg Codegen Strategy.";
+  }
   TestLinalgCodegenStrategy() = default;
   TestLinalgCodegenStrategy(const TestLinalgCodegenStrategy &pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     // clang-format off
     registry.insert<AffineDialect,
                     gpu::GPUDialect,
                     linalg::LinalgDialect,
void TestLinalgCodegenStrategy::runOnFunction() {
   else
     runStrategy<LinalgOp>(tilingOptions, registerTilingOptions,
                           vectorContractLowering, vectorTransferSplit);
 }
 
 namespace mlir {
 namespace test {
 void registerTestLinalgCodegenStrategy() {
-  PassRegistration<TestLinalgCodegenStrategy> testLinalgCodegenStrategyPass(
-      "test-linalg-codegen-strategy", "Test Linalg Codegen Strategy.");
+  PassRegistration<TestLinalgCodegenStrategy>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Linalg/TestLinalgDistribution.cpp

static LinalgLoopDistributionOptions getDistributionOptions() {
   opts.procInfoMap.insert(std::make_pair("block_x", getGpuBlockInfo<'x'>));
   opts.procInfoMap.insert(std::make_pair("block_y", getGpuBlockInfo<'y'>));
   return opts;
 }
 
 namespace {
 struct TestLinalgDistribution
     : public PassWrapper<TestLinalgDistribution, FunctionPass> {
+  StringRef getArgument() const final { return "test-linalg-distribution"; }
+  StringRef getDescription() const final { return "Test Linalg distribution."; }
   TestLinalgDistribution() = default;
   TestLinalgDistribution(const TestLinalgDistribution &pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, gpu::GPUDialect>();
   }
 
   void runOnFunction() override;
 };
void TestLinalgDistribution::runOnFunction() {
   funcOp.walk([](LinalgOp op) {
     op->removeAttr(LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
 namespace mlir {
 namespace test {
 void registerTestLinalgDistribution() {
-  PassRegistration<TestLinalgDistribution> testTestLinalgDistributionPass(
-      "test-linalg-distribution", "Test Linalg distribution.");
+  PassRegistration<TestLinalgDistribution>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Linalg/TestLinalgElementwiseFusion.cpp

 
 namespace {
 struct TestLinalgElementwiseFusion
     : public PassWrapper<TestLinalgElementwiseFusion, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     tensor::TensorDialect>();
   }
+  StringRef getArgument() const final {
+    return "test-linalg-elementwise-fusion-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test Linalg element wise operation fusion patterns";
+  }
 
   void runOnFunction() override {
     MLIRContext *context = &this->getContext();
     FuncOp funcOp = this->getFunction();
     RewritePatternSet fusionPatterns(context);
 
     linalg::populateElementwiseOpsFusionPatterns(
         fusionPatterns,
         linalg::LinalgElementwiseFusionOptions()
             .setControlElementwiseOpsFusionFn(setFusedOpOperandLimit<4>));
 
     (void)applyPatternsAndFoldGreedily(funcOp.getBody(),
                                        std::move(fusionPatterns));
   }
 };
 
 struct TestPushExpandingReshape
     : public PassWrapper<TestPushExpandingReshape, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<AffineDialect, linalg::LinalgDialect, tensor::TensorDialect>();
   }
+  StringRef getArgument() const final { return "test-linalg-push-reshape"; }
+  StringRef getDescription() const final {
+    return "Test Linalg reshape push patterns";
+  }
 
   void runOnFunction() override {
     MLIRContext *context = &this->getContext();
     FuncOp funcOp = this->getFunction();
     RewritePatternSet patterns(context);
     linalg::populatePushReshapeOpsPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(funcOp.getBody(), std::move(patterns));
   }
 };
 } // namespace
 
 namespace test {
 void registerTestLinalgElementwiseFusion() {
-  PassRegistration<TestLinalgElementwiseFusion> testElementwiseFusionPass(
-      "test-linalg-elementwise-fusion-patterns",
-      "Test Linalg element wise operation fusion patterns");
+  PassRegistration<TestLinalgElementwiseFusion>();
 }
 
 void registerTestPushExpandingReshape() {
-  PassRegistration<TestPushExpandingReshape> testPushExpandingReshapePass(
-      "test-linalg-push-reshape", "Test Linalg reshape push patterns");
+  PassRegistration<TestPushExpandingReshape>();
 }
 } // namespace test
 
 } // namespace mlir

mlir/test/lib/Dialect/Linalg/TestLinalgFusionTransforms.cpp

patterns.add<LinalgTileAndFusePattern<GenericOp>>(
           ArrayRef<Identifier>(),
           Identifier::get("after_transpose_fusion_producer", context)),
       LinalgTransformationFilter(
           ArrayRef<Identifier>(),
           Identifier::get("after_transpose_fusion_original", context)));
 }
 
 namespace {
-template <LinalgTilingLoopType LoopType = LinalgTilingLoopType::ParallelLoops>
+template <LinalgTilingLoopType LoopType>
 struct TestLinalgFusionTransforms
     : public PassWrapper<TestLinalgFusionTransforms<LoopType>, FunctionPass> {
-  TestLinalgFusionTransforms() = default;
-  TestLinalgFusionTransforms(const TestLinalgFusionTransforms &pass) {}
-
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect, StandardOpsDialect>();
   }
+  TestLinalgFusionTransforms() = default;
+  TestLinalgFusionTransforms(const TestLinalgFusionTransforms &pass) {}
 
   void runOnFunction() override {
     MLIRContext *context = &this->getContext();
     FuncOp funcOp = this->getFunction();
     RewritePatternSet fusionPatterns(context);
     Aliases alias;
     LinalgDependenceGraph dependenceGraph =
         LinalgDependenceGraph::buildDependenceGraph(alias, funcOp);
     fillFusionPatterns<LoopType>(context, dependenceGraph, fusionPatterns);
     (void)applyPatternsAndFoldGreedily(funcOp, std::move(fusionPatterns));
   }
 };
+
+struct TestLinalgFusionTransformsParallelLoops
+    : public TestLinalgFusionTransforms<LinalgTilingLoopType::ParallelLoops> {
+  StringRef getArgument() const final {
+    return "test-linalg-fusion-transform-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test Linalg fusion transformation patterns by applying them "
+           "greedily.";
+  }
+};
+
+struct TestLinalgFusionTransformsLoops
+    : public TestLinalgFusionTransforms<LinalgTilingLoopType::Loops> {
+  StringRef getArgument() const final {
+    return "test-linalg-tensor-fusion-transform-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test Linalg on tensor fusion transformation "
+           "patterns by applying them greedily.";
+  }
+};
+
+struct TestLinalgFusionTransformsTiledLoops
+    : public TestLinalgFusionTransforms<LinalgTilingLoopType::TiledLoops> {
+  StringRef getArgument() const final {
+    return "test-linalg-tiled-loop-fusion-transform-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test Linalg on tensor fusion transformation "
+           "patterns by applying them greedily.";
+  }
+};
 } // namespace
 
 static LogicalResult fuseLinalgOpsGreedily(FuncOp f) {
   OpBuilder b(f);
   DenseSet<Operation *> eraseSet;
 
   // Save original Linalg ops, we only want to make a pass over those.
   SmallVector<LinalgOp, 8> linalgOps;

 
 namespace {
 struct TestLinalgGreedyFusion
     : public PassWrapper<TestLinalgGreedyFusion, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect>();
   }
+  StringRef getArgument() const final { return "test-linalg-greedy-fusion"; }
+  StringRef getDescription() const final {
+    return "Test Linalg fusion by applying a greedy test transformation.";
+  }
   void runOnFunction() override {
     MLIRContext *context = &getContext();
     RewritePatternSet patterns =
         linalg::getLinalgTilingCanonicalizationPatterns(context);
     patterns.add<AffineMinSCFCanonicalizationPattern>(context);
     FrozenRewritePatternSet frozenPatterns(std::move(patterns));
     while (succeeded(fuseLinalgOpsGreedily(getFunction()))) {
       (void)applyPatternsAndFoldGreedily(getFunction(), frozenPatterns);
       PassManager pm(context);
       pm.addPass(createLoopInvariantCodeMotionPass());
       pm.addPass(createCanonicalizerPass());
       pm.addPass(createCSEPass());
       LogicalResult res = pm.run(getFunction()->getParentOfType<ModuleOp>());
       if (failed(res))
         this->signalPassFailure();
     }
   }
 };
 
 /// Pass to test tile and fuse of sequence of operations. Intended only for
 /// testing.
 struct TestLinalgTileAndFuseSequencePass
     : public PassWrapper<TestLinalgTileAndFuseSequencePass, FunctionPass> {
+  StringRef getArgument() const final { return "test-linalg-tile-and-fuse"; }
+  StringRef getDescription() const final {
+    return "Test Linalg tiling and fusion of a sequence of Linalg operations.";
+  }
   TestLinalgTileAndFuseSequencePass() = default;
   TestLinalgTileAndFuseSequencePass(
       const TestLinalgTileAndFuseSequencePass &pass){};
 
   ListOption<int64_t> tileSizes{
       *this, "tile-sizes", llvm::cl::desc("Tile sizes to use for ops"),
       llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated};
 
if (linalgOps.back().hasTensorSemantics()) {
       linalgOps.back().getOperation()->replaceAllUsesWith(
           tileAndFuseOps->fusedLoops.front());
     }
     for (auto op : linalgOps)
       if (op.hasBufferSemantics())
         op.erase();
   }
 };
+
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestLinalgFusionTransforms() {
-  PassRegistration<TestLinalgFusionTransforms<>> testFusionTransformsPass(
-      "test-linalg-fusion-transform-patterns",
-      "Test Linalg fusion transformation patterns by applying them greedily.");
+  PassRegistration<TestLinalgFusionTransformsParallelLoops>();
 }
 void registerTestLinalgTensorFusionTransforms() {
-  PassRegistration<TestLinalgFusionTransforms<LinalgTilingLoopType::Loops>>
-      testTensorFusionTransformsPass(
-          "test-linalg-tensor-fusion-transform-patterns",
-          "Test Linalg on tensor fusion transformation "
-          "patterns by applying them greedily.");
+  PassRegistration<TestLinalgFusionTransformsLoops>();
 }
 void registerTestLinalgTiledLoopFusionTransforms() {
-  PassRegistration<TestLinalgFusionTransforms<LinalgTilingLoopType::TiledLoops>>
-      testTiledLoopFusionTransformsPass(
-          "test-linalg-tiled-loop-fusion-transform-patterns",
-          "Test Linalg on tensor fusion transformation "
-          "patterns by applying them greedily.");
+  PassRegistration<TestLinalgFusionTransformsTiledLoops>();
 }
 void registerTestLinalgGreedyFusion() {
-  PassRegistration<TestLinalgGreedyFusion> testFusionTransformsPass(
-      "test-linalg-greedy-fusion",
-      "Test Linalg fusion by applying a greedy test transformation.");
+  PassRegistration<TestLinalgGreedyFusion>();
 }
 void registerTestLinalgTileAndFuseSequencePass() {
-  PassRegistration<TestLinalgTileAndFuseSequencePass>
-      testTileAndFuseSequencePass(
-          "test-linalg-tile-and-fuse",
-          "Test Linalg tiling and fusion of a sequence of Linalg operations.");
+  PassRegistration<TestLinalgTileAndFuseSequencePass>();
 }
 
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Linalg/TestLinalgHoisting.cpp

 namespace {
 struct TestLinalgHoisting
     : public PassWrapper<TestLinalgHoisting, FunctionPass> {
   TestLinalgHoisting() = default;
   TestLinalgHoisting(const TestLinalgHoisting &pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect>();
   }
+  StringRef getArgument() const final { return "test-linalg-hoisting"; }
+  StringRef getDescription() const final {
+    return "Test Linalg hoisting functions.";
+  }
 
   void runOnFunction() override;
 
   Option<bool> testHoistRedundantTransfers{
       *this, "test-hoist-redundant-transfers",
       llvm::cl::desc("Test hoisting transfer_read/transfer_write pairs"),
       llvm::cl::init(false)};
 };
 } // end anonymous namespace
 
 void TestLinalgHoisting::runOnFunction() {
   if (testHoistRedundantTransfers) {
     hoistRedundantVectorTransfers(getFunction());
     hoistRedundantVectorTransfersOnTensor(getFunction());
     return;
   }
 }
 
 namespace mlir {
 namespace test {
-void registerTestLinalgHoisting() {
-  PassRegistration<TestLinalgHoisting> testTestLinalgHoistingPass(
-      "test-linalg-hoisting", "Test Linalg hoisting functions.");
-}
+void registerTestLinalgHoisting() { PassRegistration<TestLinalgHoisting>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Linalg/TestLinalgTransforms.cpp

void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect,
                     memref::MemRefDialect,
                     scf::SCFDialect,
                     StandardOpsDialect,
                     vector::VectorDialect,
                     gpu::GPUDialect>();
     // clang-format on
   }
+  StringRef getArgument() const final {
+    return "test-linalg-transform-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test Linalg transformation patterns by applying them greedily.";
+  }
 
   void runOnFunction() override;
 
   Option<bool> testPatterns{*this, "test-patterns",
                             llvm::cl::desc("Test a mixed set of patterns"),
                             llvm::cl::init(false)};
   Option<bool> testMatmulToVectorPatterns1dTiling{
       *this, "test-matmul-to-vector-patterns-tile-1d",
void TestLinalgTransforms::runOnFunction() {
   }
   if (testInterchangePattern.hasValue())
     return applyInterchangePattern(getFunction(), testInterchangePattern);
 }
 
 namespace mlir {
 namespace test {
 void registerTestLinalgTransforms() {
-  PassRegistration<TestLinalgTransforms> testTransformPatternsPass(
-      "test-linalg-transform-patterns",
-      "Test Linalg transformation patterns by applying them greedily.");
+  PassRegistration<TestLinalgTransforms>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Math/TestExpandTanh.cpp

 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 struct TestExpandTanhPass
     : public PassWrapper<TestExpandTanhPass, FunctionPass> {
   void runOnFunction() override;
+  StringRef getArgument() const final { return "test-expand-tanh"; }
+  StringRef getDescription() const final { return "Test expanding tanh"; }
 };
 } // end anonymous namespace
 
 void TestExpandTanhPass::runOnFunction() {
   RewritePatternSet patterns(&getContext());
   populateExpandTanhPattern(patterns);
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 namespace test {
-void registerTestExpandTanhPass() {
-  PassRegistration<TestExpandTanhPass> pass("test-expand-tanh",
-                                            "Test expanding tanh");
-}
+void registerTestExpandTanhPass() { PassRegistration<TestExpandTanhPass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Math/TestPolynomialApproximation.cpp

 namespace {
 struct TestMathPolynomialApproximationPass
     : public PassWrapper<TestMathPolynomialApproximationPass, FunctionPass> {
   void runOnFunction() override;
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<vector::VectorDialect, math::MathDialect, LLVM::LLVMDialect>();
   }
+  StringRef getArgument() const final {
+    return "test-math-polynomial-approximation";
+  }
+  StringRef getDescription() const final {
+    return "Test math polynomial approximations";
+  }
 };
 } // end anonymous namespace
 
 void TestMathPolynomialApproximationPass::runOnFunction() {
   RewritePatternSet patterns(&getContext());
   populateMathPolynomialApproximationPatterns(patterns);
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 namespace test {
 void registerTestMathPolynomialApproximationPass() {
-  PassRegistration<TestMathPolynomialApproximationPass> pass(
-      "test-math-polynomial-approximation",
-      "Test math polynomial approximations");
+  PassRegistration<TestMathPolynomialApproximationPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp

 #include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 
 namespace {
 class TestSCFForUtilsPass
     : public PassWrapper<TestSCFForUtilsPass, FunctionPass> {
 public:
-  explicit TestSCFForUtilsPass() {}
+  StringRef getArgument() const final { return "test-scf-for-utils"; }
+  StringRef getDescription() const final { return "test scf.for utils"; }
+  explicit TestSCFForUtilsPass() = default;
 
   void runOnFunction() override {
     FuncOp func = getFunction();
     SmallVector<scf::ForOp, 4> toErase;
 
     func.walk([&](Operation *fakeRead) {
       if (fakeRead->getName().getStringRef() != "fake_read")
         return;
void runOnFunction() override {
     for (auto loop : llvm::reverse(toErase))
       loop.erase();
   }
 };
 
 class TestSCFIfUtilsPass
     : public PassWrapper<TestSCFIfUtilsPass, FunctionPass> {
 public:
-  explicit TestSCFIfUtilsPass() {}
+  StringRef getArgument() const final { return "test-scf-if-utils"; }
+  StringRef getDescription() const final { return "test scf.if utils"; }
+  explicit TestSCFIfUtilsPass() = default;
 
   void runOnFunction() override {
     int count = 0;
     FuncOp func = getFunction();
     func.walk([&](scf::IfOp ifOp) {
       auto strCount = std::to_string(count++);
       FuncOp thenFn, elseFn;
       OpBuilder b(ifOp);
       outlineIfOp(b, ifOp, &thenFn, std::string("outlined_then") + strCount,
                   &elseFn, std::string("outlined_else") + strCount);
     });
   }
 };
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestSCFUtilsPass() {
-  PassRegistration<TestSCFForUtilsPass>("test-scf-for-utils",
-                                        "test scf.for utils");
-  PassRegistration<TestSCFIfUtilsPass>("test-scf-if-utils",
-                                       "test scf.if utils");
+  PassRegistration<TestSCFForUtilsPass>();
+  PassRegistration<TestSCFIfUtilsPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

 // Printing op availability pass
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A pass for testing SPIR-V op availability.
 struct PrintOpAvailability
     : public PassWrapper<PrintOpAvailability, FunctionPass> {
   void runOnFunction() override;
+  StringRef getArgument() const final { return "test-spirv-op-availability"; }
+  StringRef getDescription() const final {
+    return "Test SPIR-V op availability";
+  }
 };
 } // end anonymous namespace
 
 void PrintOpAvailability::runOnFunction() {
   auto f = getFunction();
   llvm::outs() << f.getName() << "\n";
 
   Dialect *spvDialect = getContext().getLoadedDialect("spv");
f->walk([&](Operation *op) {
     os.flush();
 
     return WalkResult::advance();
   });
 }
 
 namespace mlir {
 void registerPrintOpAvailabilityPass() {
-  PassRegistration<PrintOpAvailability> printOpAvailabilityPass(
-      "test-spirv-op-availability", "Test SPIR-V op availability");
+  PassRegistration<PrintOpAvailability>();
 }
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Converting target environment pass
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A pass for testing SPIR-V op availability.
 struct ConvertToTargetEnv
     : public PassWrapper<ConvertToTargetEnv, FunctionPass> {
+  StringRef getArgument() const override { return "test-spirv-target-env"; }
+  StringRef getDescription() const override {
+    return "Test SPIR-V target environment";
+  }
   void runOnFunction() override;
 };
 
 struct ConvertToAtomCmpExchangeWeak : public RewritePattern {
   ConvertToAtomCmpExchangeWeak(MLIRContext *context);
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const override;
 };
ConvertToSubgroupBallot::matchAndRewrite(Operation *op,
 
   rewriter.replaceOpWithNewOp<spirv::SubgroupBallotKHROp>(
       op, op->getResult(0).getType(), predicate);
   return success();
 }
 
 namespace mlir {
 void registerConvertToTargetEnvPass() {
-  PassRegistration<ConvertToTargetEnv> convertToTargetEnvPass(
-      "test-spirv-target-env", "Test SPIR-V target environment");
+  PassRegistration<ConvertToTargetEnv>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/SPIRV/TestEntryPointAbi.cpp

 using namespace mlir;
 
 namespace {
 /// Pass to set the spv.entry_point_abi
 class TestSpirvEntryPointABIPass
     : public PassWrapper<TestSpirvEntryPointABIPass,
                          OperationPass<gpu::GPUModuleOp>> {
 public:
+  StringRef getArgument() const final { return "test-spirv-entry-point-abi"; }
+  StringRef getDescription() const final {
+    return "Set the spv.entry_point_abi attribute on GPU kernel function "
+           "within the "
+           "module, intended for testing only";
+  }
   TestSpirvEntryPointABIPass() = default;
   TestSpirvEntryPointABIPass(const TestSpirvEntryPointABIPass &) {}
   void runOnOperation() override;
 
 private:
   Pass::ListOption<int32_t> workgroupSize{
       *this, "workgroup-size",
       llvm::cl::desc(
for (gpu::GPUFuncOp gpuFunc : gpuModule.getOps<gpu::GPUFuncOp>()) {
     workgroupSizeVec.resize(3, 1);
     gpuFunc->setAttr(attrName,
                      spirv::getEntryPointABIAttr(workgroupSizeVec, context));
   }
 }
 
 namespace mlir {
 void registerTestSpirvEntryPointABIPass() {
-  PassRegistration<TestSpirvEntryPointABIPass> registration(
-      "test-spirv-entry-point-abi",
-      "Set the spv.entry_point_abi attribute on GPU kernel function within the "
-      "module, intended for testing only");
+  PassRegistration<TestSpirvEntryPointABIPass>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/SPIRV/TestGLSLCanonicalization.cpp

 namespace {
 class TestGLSLCanonicalizationPass
     : public PassWrapper<TestGLSLCanonicalizationPass,
                          OperationPass<mlir::ModuleOp>> {
 public:
   TestGLSLCanonicalizationPass() = default;
   TestGLSLCanonicalizationPass(const TestGLSLCanonicalizationPass &) {}
   void runOnOperation() override;
+  StringRef getArgument() const final {
+    return "test-spirv-glsl-canonicalization";
+  }
+  StringRef getDescription() const final {
+    return "Tests SPIR-V canonicalization patterns for GLSL extension.";
+  }
 };
 } // namespace
 
 void TestGLSLCanonicalizationPass::runOnOperation() {
   RewritePatternSet patterns(&getContext());
   spirv::populateSPIRVGLSLCanonicalizationPatterns(patterns);
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 void registerTestSpirvGLSLCanonicalizationPass() {
-  PassRegistration<TestGLSLCanonicalizationPass> registration(
-      "test-spirv-glsl-canonicalization",
-      "Tests SPIR-V canonicalization patterns for GLSL extension.");
+  PassRegistration<TestGLSLCanonicalizationPass>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/SPIRV/TestModuleCombiner.cpp

 
 using namespace mlir;
 
 namespace {
 class TestModuleCombinerPass
     : public PassWrapper<TestModuleCombinerPass,
                          OperationPass<mlir::ModuleOp>> {
 public:
+  StringRef getArgument() const final { return "test-spirv-module-combiner"; }
+  StringRef getDescription() const final {
+    return "Tests SPIR-V module combiner library";
+  }
   TestModuleCombinerPass() = default;
   TestModuleCombinerPass(const TestModuleCombinerPass &) {}
   void runOnOperation() override;
 
 private:
   OwningOpRef<spirv::ModuleOp> combinedModule;
 };
 } // namespace
 
 void TestModuleCombinerPass::runOnOperation() {
   auto modules = llvm::to_vector<4>(getOperation().getOps<spirv::ModuleOp>());
 
   OpBuilder combinedModuleBuilder(modules[0]);
   combinedModule = spirv::combine(modules, combinedModuleBuilder, nullptr);
 
   for (spirv::ModuleOp module : modules)
     module.erase();
 }
 
 namespace mlir {
 void registerTestSpirvModuleCombinerPass() {
-  PassRegistration<TestModuleCombinerPass> registration(
-      "test-spirv-module-combiner", "Tests SPIR-V module combiner library");
+  PassRegistration<TestModuleCombinerPass>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/Shape/TestShapeFunctions.cpp

 
 using namespace mlir;
 
 namespace {
 /// This is a pass that reports shape functions associated with ops.
 struct ReportShapeFnPass
     : public PassWrapper<ReportShapeFnPass, OperationPass<ModuleOp>> {
   void runOnOperation() override;
+  StringRef getArgument() const final { return "test-shape-function-report"; }
+  StringRef getDescription() const final {
+    return "Test pass to report associated shape functions";
+  }
 };
 } // end anonymous namespace
 
 void ReportShapeFnPass::runOnOperation() {
   auto module = getOperation();
 
   // Report the shape function available to refine the op.
   auto shapeFnId = Identifier::get("shape.function", &getContext());
func.walk([&](Operation *op) {
       if (!found)
         op->emitRemark() << "no associated way to refine shape";
     });
   });
 }
 
 namespace mlir {
 void registerShapeFunctionTestPasses() {
-  PassRegistration<ReportShapeFnPass>(
-      "test-shape-function-report",
-      "Test pass to report associated shape functions");
+  PassRegistration<ReportShapeFnPass>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/StandardOps/TestComposeSubView.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 struct TestComposeSubViewPass
     : public PassWrapper<TestComposeSubViewPass, FunctionPass> {
+  StringRef getArgument() const final { return "test-compose-subview"; }
+  StringRef getDescription() const final {
+    return "Test combining composed subviews";
+  }
   void runOnFunction() override;
   void getDependentDialects(DialectRegistry &registry) const override;
 };
 
 void TestComposeSubViewPass::getDependentDialects(
     DialectRegistry &registry) const {
   registry.insert<AffineDialect>();
 }
 
 void TestComposeSubViewPass::runOnFunction() {
   OwningRewritePatternList patterns(&getContext());
   populateComposeSubViewPatterns(patterns, &getContext());
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestComposeSubView() {
-  PassRegistration<TestComposeSubViewPass> pass(
-      "test-compose-subview", "Test combining composed subviews");
+  PassRegistration<TestComposeSubViewPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/StandardOps/TestDecomposeCallGraphTypes.cpp

 /// that splits tuple types into their respective element types.
 /// For example, `tuple<T1, T2, T3> --> T1, T2, T3`.
 struct TestDecomposeCallGraphTypes
     : public PassWrapper<TestDecomposeCallGraphTypes, OperationPass<ModuleOp>> {
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<test::TestDialect>();
   }
+  StringRef getArgument() const final {
+    return "test-decompose-call-graph-types";
+  }
+  StringRef getDescription() const final {
+    return "Decomposes types at call graph boundaries.";
+  }
   void runOnOperation() override {
     ModuleOp module = getOperation();
     auto *context = &getContext();
     TypeConverter typeConverter;
     ConversionTarget target(*context);
     ValueDecomposer decomposer;
     RewritePatternSet patterns(context);
 
struct TestDecomposeCallGraphTypes
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
 void registerTestDecomposeCallGraphTypes() {
-  PassRegistration<TestDecomposeCallGraphTypes> pass(
-      "test-decompose-call-graph-types",
-      "Decomposes types at call graph boundaries.");
+  PassRegistration<TestDecomposeCallGraphTypes>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Test/TestPatterns.cpp

Value result = folder.create<TestOpInPlaceFold>(
         rewriter.getI32IntegerAttr(0));
     assert(result);
     rewriter.replaceOp(op, result);
     return success();
   }
 };
 
 struct TestPatternDriver : public PassWrapper<TestPatternDriver, FunctionPass> {
+  StringRef getArgument() const final { return "test-patterns"; }
+  StringRef getDescription() const final { return "Run test dialect patterns"; }
   void runOnFunction() override {
     mlir::RewritePatternSet patterns(&getContext());
     populateWithGenerated(patterns);
 
     // Verify named pattern is generated with expected name.
     patterns.add<FoldingPattern, TestNamedPatternRule>(&getContext());
 
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
static void reifyReturnShape(Operation *op) {
   }
 }
 
 struct TestReturnTypeDriver
     : public PassWrapper<TestReturnTypeDriver, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
+  StringRef getArgument() const final { return "test-return-type"; }
+  StringRef getDescription() const final { return "Run return type functions"; }
 
   void runOnFunction() override {
     if (getFunction().getName() == "testCreateFunctions") {
       std::vector<Operation *> ops;
       // Collect ops to avoid triggering on inserted ops.
       for (auto &op : getFunction().getBody().front())
         ops.push_back(&op);
       // Generate test patterns for each, but skip terminator.
void runOnFunction() override {
     }
   }
 };
 } // end anonymous namespace
 
 namespace {
 struct TestDerivedAttributeDriver
     : public PassWrapper<TestDerivedAttributeDriver, FunctionPass> {
+  StringRef getArgument() const final { return "test-derived-attr"; }
+  StringRef getDescription() const final {
+    return "Run test derived attributes";
+  }
   void runOnFunction() override;
 };
 } // end anonymous namespace
 
 void TestDerivedAttributeDriver::runOnFunction() {
   getFunction().walk([](DerivedAttributeOpInterface dOp) {
     auto dAttr = dOp.materializeDerivedAttributes();
     if (!dAttr)
static Optional<Value> materializeCast(OpBuilder &builder, Type resultType,
     if (inputs.size() == 1)
       return inputs[0];
     return builder.create<TestCastOp>(loc, resultType, inputs).getResult();
   }
 };
 
 struct TestLegalizePatternDriver
     : public PassWrapper<TestLegalizePatternDriver, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-legalize-patterns"; }
+  StringRef getDescription() const final {
+    return "Run test dialect legalization patterns";
+  }
   /// The mode of conversion to use with the driver.
   enum class ConversionMode { Analysis, Full, Partial };
 
   TestLegalizePatternDriver(ConversionMode mode) : mode(mode) {}
 
   void runOnOperation() override {
     TestTypeConverter converter;
     mlir::RewritePatternSet patterns(&getContext());
matchAndRewrite(OneVResOneVOperandOp1 op, ArrayRef<Value> operands,
     rewriter.replaceOpWithNewOp<OneVResOneVOperandOp1>(op, op.getResultTypes(),
                                                        remappedOperands);
     return success();
   }
 };
 
 struct TestRemappedValue
     : public mlir::PassWrapper<TestRemappedValue, FunctionPass> {
+  StringRef getArgument() const final { return "test-remapped-value"; }
+  StringRef getDescription() const final {
+    return "Test public remapped value mechanism in ConversionPatternRewriter";
+  }
   void runOnFunction() override {
     mlir::RewritePatternSet patterns(&getContext());
     patterns.add<OneVResOneVOperandOp1Converter>(&getContext());
 
     mlir::ConversionTarget target(getContext());
     target.addLegalOp<ModuleOp, FuncOp, TestReturnOp>();
     // We make OneVResOneVOperandOp1 legal only when it has more that one
     // operand. This will trigger the conversion that will replace one-operand
if (!isa<TestDialect>(op->getDialect()))
       return failure();
     rewriter.eraseOp(op);
     return success();
   }
 };
 
 struct TestUnknownRootOpDriver
     : public mlir::PassWrapper<TestUnknownRootOpDriver, FunctionPass> {
+  StringRef getArgument() const final {
+    return "test-legalize-unknown-root-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test public remapped value mechanism in ConversionPatternRewriter";
+  }
   void runOnFunction() override {
     mlir::RewritePatternSet patterns(&getContext());
     patterns.add<RemoveTestDialectOps>(&getContext());
 
     mlir::ConversionTarget target(getContext());
     target.addIllegalDialect<TestDialect>();
     if (failed(
             applyPartialConversion(getFunction(), target, std::move(patterns))))
struct TestTypeConversionAnotherProducer
   }
 };
 
 struct TestTypeConversionDriver
     : public PassWrapper<TestTypeConversionDriver, OperationPass<ModuleOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<TestDialect>();
   }
+  StringRef getArgument() const final {
+    return "test-legalize-type-conversion";
+  }
+  StringRef getDescription() const final {
+    return "Test various type conversion functionalities in DialectConversion";
+  }
 
   void runOnOperation() override {
     // Initialize the type converter.
     TypeConverter converter;
 
     /// Add the legal set of type conversions.
     converter.addConversion([](Type type) -> Type {
       // Treat F64 as legal.
matchAndRewrite(SingleBlockImplicitTerminatorOp op, ArrayRef<Value> operands,
     rewriter.updateRootInPlace(op, [] {});
     return success();
   }
 };
 
 struct TestMergeBlocksPatternDriver
     : public PassWrapper<TestMergeBlocksPatternDriver,
                          OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-merge-blocks"; }
+  StringRef getDescription() const final {
+    return "Test Merging operation in ConversionPatternRewriter";
+  }
   void runOnOperation() override {
     MLIRContext *context = &getContext();
     mlir::RewritePatternSet patterns(context);
     patterns.add<TestMergeBlock, TestUndoBlocksMerge, TestMergeSingleBlockOps>(
         context);
     ConversionTarget target(*context);
     target.addLegalOp<FuncOp, ModuleOp, TerminatorOp, TestBranchOp,
                       TestTypeConsumerOp, TestTypeProducerOp, TestReturnOp>();
LogicalResult matchAndRewrite(TestCastOp op,
     rewriter.replaceOp(op, op.getOperand(1));
     return success();
   }
 };
 
 struct TestSelectiveReplacementPatternDriver
     : public PassWrapper<TestSelectiveReplacementPatternDriver,
                          OperationPass<>> {
+  StringRef getArgument() const final {
+    return "test-pattern-selective-replacement";
+  }
+  StringRef getDescription() const final {
+    return "Test selective replacement in the PatternRewriter";
+  }
   void runOnOperation() override {
     MLIRContext *context = &getContext();
     mlir::RewritePatternSet patterns(context);
     patterns.add<TestSelectiveOpReplacementPattern>(context);
     (void)applyPatternsAndFoldGreedily(getOperation()->getRegions(),
                                        std::move(patterns));
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // PassRegistration
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace test {
 void registerPatternsTestPass() {
-  PassRegistration<TestReturnTypeDriver>("test-return-type",
-                                         "Run return type functions");
+  PassRegistration<TestReturnTypeDriver>();
 
-  PassRegistration<TestDerivedAttributeDriver>("test-derived-attr",
-                                               "Run test derived attributes");
+  PassRegistration<TestDerivedAttributeDriver>();
 
-  PassRegistration<TestPatternDriver>("test-patterns",
-                                      "Run test dialect patterns");
+  PassRegistration<TestPatternDriver>();
 
-  PassRegistration<TestLegalizePatternDriver>(
-      "test-legalize-patterns", "Run test dialect legalization patterns", [] {
-        return std::make_unique<TestLegalizePatternDriver>(
-            legalizerConversionMode);
-      });
+  PassRegistration<TestLegalizePatternDriver>([] {
+    return std::make_unique<TestLegalizePatternDriver>(legalizerConversionMode);
 
-  PassRegistration<TestRemappedValue>(
-      "test-remapped-value",
-      "Test public remapped value mechanism in ConversionPatternRewriter");
-
-  PassRegistration<TestUnknownRootOpDriver>(
-      "test-legalize-unknown-root-patterns",
-      "Test public remapped value mechanism in ConversionPatternRewriter");
-
-  PassRegistration<TestTypeConversionDriver>(
-      "test-legalize-type-conversion",
-      "Test various type conversion functionalities in DialectConversion");
-
-  PassRegistration<TestMergeBlocksPatternDriver>{
-      "test-merge-blocks",
-      "Test Merging operation in ConversionPatternRewriter"};
-  PassRegistration<TestSelectiveReplacementPatternDriver>{
-      "test-pattern-selective-replacement",
-      "Test selective replacement in the PatternRewriter"};
+  PassRegistration<TestRemappedValue>();
+
+  PassRegistration<TestUnknownRootOpDriver>();
+
+  PassRegistration<TestTypeConversionDriver>();
+
+  PassRegistration<TestMergeBlocksPatternDriver>();
+  PassRegistration<TestSelectiveReplacementPatternDriver>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Test/TestTraits.cpp

OpFoldResult TestInvolutionTraitSuccesfulOperationFolderOp::fold(
     ArrayRef<Attribute> operands) {
   auto argumentOp = getOperand();
   // The success case should cause the trait fold to be supressed.
   return argumentOp.getDefiningOp() ? argumentOp : OpFoldResult{};
 }
 
 namespace {
 struct TestTraitFolder : public PassWrapper<TestTraitFolder, FunctionPass> {
+  StringRef getArgument() const final { return "test-trait-folder"; }
+  StringRef getDescription() const final { return "Run trait folding"; }
   void runOnFunction() override {
     (void)applyPatternsAndFoldGreedily(getFunction(),
                                        RewritePatternSet(&getContext()));
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
-void registerTestTraitsPass() {
-  PassRegistration<TestTraitFolder>("test-trait-folder", "Run trait folding");
-}
+void registerTestTraitsPass() { PassRegistration<TestTraitFolder>(); }
 } // namespace mlir

mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp

ConvertTosaConv2DOp::matchAndRewrite(Operation *op,
   rewriter.replaceOp(op, {newTosaRescaleOp.getResult()});
   return success();
 }
 
 namespace {
 
 struct TosaTestQuantUtilAPI
     : public PassWrapper<TosaTestQuantUtilAPI, FunctionPass> {
+  StringRef getArgument() const final { return PASS_NAME; }
+  StringRef getDescription() const final {
+    return "TOSA Test: Exercise the APIs in QuantUtils.cpp.";
+  }
   void runOnFunction() override;
 };
 
 void TosaTestQuantUtilAPI::runOnFunction() {
   auto *ctx = &getContext();
   RewritePatternSet patterns(ctx);
   auto func = getFunction();
 
   patterns.add<ConvertTosaNegateOp>(ctx);
   patterns.add<ConvertTosaConv2DOp>(ctx);
   (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
 }
 
 } // anonymous namespace
 
 namespace mlir {
 void registerTosaTestQuantUtilAPIPass() {
-  PassRegistration<TosaTestQuantUtilAPI>(
-      PASS_NAME, "TOSA Test: Exercise the APIs in QuantUtils.cpp.");
+  PassRegistration<TosaTestQuantUtilAPI>();
 }
 } // namespace mlir

mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp

 using namespace mlir;
 using namespace mlir::vector;
 namespace {
 
 struct TestVectorToVectorConversion
     : public PassWrapper<TestVectorToVectorConversion, FunctionPass> {
   TestVectorToVectorConversion() = default;
   TestVectorToVectorConversion(const TestVectorToVectorConversion &pass) {}
+  StringRef getArgument() const final {
+    return "test-vector-to-vector-conversion";
+  }
+  StringRef getDescription() const final {
+    return "Test conversion patterns between ops in the vector dialect";
+  }
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect>();
   }
 
   Option<bool> unroll{*this, "unroll", llvm::cl::desc("Include unrolling"),
                       llvm::cl::init(false)};
 
private:
 
   static LogicalResult filter(Operation *op) {
     return success(isa<AddFOp, SelectOp, CmpFOp, ContractionOp>(op));
   }
 };
 
 struct TestVectorSlicesConversion
     : public PassWrapper<TestVectorSlicesConversion, FunctionPass> {
+  StringRef getArgument() const final {
+    return "test-vector-slices-conversion";
+  }
+  StringRef getDescription() const final {
+    return "Test conversion patterns that lower slices ops in the vector "
+           "dialect";
+  }
   void runOnFunction() override {
     RewritePatternSet patterns(&getContext());
     populateVectorSlicesLoweringPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorContractionConversion
     : public PassWrapper<TestVectorContractionConversion, FunctionPass> {
+  StringRef getArgument() const final {
+    return "test-vector-contraction-conversion";
+  }
+  StringRef getDescription() const final {
+    return "Test conversion patterns that lower contract ops in the vector "
+           "dialect";
+  }
   TestVectorContractionConversion() = default;
   TestVectorContractionConversion(const TestVectorContractionConversion &pass) {
   }
 
   Option<bool> lowerToFlatMatrix{
       *this, "vector-lower-matrix-intrinsics",
       llvm::cl::desc("Lower vector.contract to llvm.intr.matrix.multiply"),
       llvm::cl::init(false)};
void runOnFunction() override {
     populateVectorContractLoweringPatterns(patterns, options);
     populateVectorTransposeLoweringPatterns(patterns, options);
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorUnrollingPatterns
     : public PassWrapper<TestVectorUnrollingPatterns, FunctionPass> {
+  StringRef getArgument() const final {
+    return "test-vector-unrolling-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test conversion patterns to unroll contract ops in the vector "
+           "dialect";
+  }
   TestVectorUnrollingPatterns() = default;
   TestVectorUnrollingPatterns(const TestVectorUnrollingPatterns &pass) {}
   void runOnFunction() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     patterns.add<UnrollVectorPattern>(
         ctx, UnrollVectorOptions()
                  .setNativeShape(ArrayRef<int64_t>{2, 2})
struct TestVectorUnrollingPatterns
   Option<bool> unrollBasedOnType{
       *this, "unroll-based-on-type",
       llvm::cl::desc("Set the unroll factor based on type of the operation"),
       llvm::cl::init(false)};
 };
 
 struct TestVectorDistributePatterns
     : public PassWrapper<TestVectorDistributePatterns, FunctionPass> {
+  StringRef getArgument() const final {
+    return "test-vector-distribute-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test conversion patterns to distribute vector ops in the vector "
+           "dialect";
+  }
   TestVectorDistributePatterns() = default;
   TestVectorDistributePatterns(const TestVectorDistributePatterns &pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<VectorDialect>();
     registry.insert<AffineDialect>();
   }
   ListOption<int32_t> multiplicity{
       *this, "distribution-multiplicity", llvm::cl::MiscFlags::CommaSeparated,
void runOnFunction() override {
     patterns.add<PointwiseExtractPattern>(ctx);
     populateVectorToVectorTransformationPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorToLoopPatterns
     : public PassWrapper<TestVectorToLoopPatterns, FunctionPass> {
+  StringRef getArgument() const final { return "test-vector-to-forloop"; }
+  StringRef getDescription() const final {
+    return "Test conversion patterns to break up a vector op into a for loop";
+  }
   TestVectorToLoopPatterns() = default;
   TestVectorToLoopPatterns(const TestVectorToLoopPatterns &pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<VectorDialect>();
     registry.insert<AffineDialect>();
   }
   Option<int32_t> multiplicity{
       *this, "distribution-multiplicity",
struct TestVectorToLoopPatterns
   }
 };
 
 struct TestVectorTransferUnrollingPatterns
     : public PassWrapper<TestVectorTransferUnrollingPatterns, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect>();
   }
+  StringRef getArgument() const final {
+    return "test-vector-transfer-unrolling-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test conversion patterns to unroll transfer ops in the vector "
+           "dialect";
+  }
   void runOnFunction() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     patterns.add<UnrollVectorPattern>(
         ctx,
         UnrollVectorOptions()
             .setNativeShape(ArrayRef<int64_t>{2, 2})
             .setFilterConstraint([](Operation *op) {
               return success(
                   isa<vector::TransferReadOp, vector::TransferWriteOp>(op));
             }));
     populateVectorToVectorCanonicalizationPatterns(patterns);
     populateVectorToVectorTransformationPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferFullPartialSplitPatterns
     : public PassWrapper<TestVectorTransferFullPartialSplitPatterns,
                          FunctionPass> {
+  StringRef getArgument() const final {
+    return "test-vector-transfer-full-partial-split";
+  }
+  StringRef getDescription() const final {
+    return "Test conversion patterns to split "
+           "transfer ops via scf.if + linalg ops";
+  }
   TestVectorTransferFullPartialSplitPatterns() = default;
   TestVectorTransferFullPartialSplitPatterns(
       const TestVectorTransferFullPartialSplitPatterns &pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect>();
   }
else
       options.setVectorTransferSplit(VectorTransferSplit::VectorTransfer);
     patterns.add<VectorTransferFullPartialRewriter>(ctx, options);
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferOpt
     : public PassWrapper<TestVectorTransferOpt, FunctionPass> {
+  StringRef getArgument() const final { return "test-vector-transferop-opt"; }
+  StringRef getDescription() const final {
+    return "Test optimization transformations for transfer ops";
+  }
   void runOnFunction() override { transferOpflowOpt(getFunction()); }
 };
 
 struct TestVectorTransferLoweringPatterns
     : public PassWrapper<TestVectorTransferLoweringPatterns, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
+  StringRef getArgument() const final {
+    return "test-vector-transfer-lowering-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test conversion patterns to lower transfer ops to other vector ops";
+  }
   void runOnFunction() override {
     RewritePatternSet patterns(&getContext());
     populateVectorTransferLoweringPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorMultiReductionLoweringPatterns
     : public PassWrapper<TestVectorMultiReductionLoweringPatterns,
                          FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
+  StringRef getArgument() const final {
+    return "test-vector-multi-reduction-lowering-patterns";
+  }
+  StringRef getDescription() const final {
+    return "Test conversion patterns to lower vector.multi_reduction to other "
+           "vector ops";
+  }
   void runOnFunction() override {
     RewritePatternSet patterns(&getContext());
     populateVectorMultiReductionLoweringPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
 void registerTestVectorConversions() {
-  PassRegistration<TestVectorToVectorConversion> vectorToVectorPass(
-      "test-vector-to-vector-conversion",
-      "Test conversion patterns between ops in the vector dialect");
-
-  PassRegistration<TestVectorSlicesConversion> slicesPass(
-      "test-vector-slices-conversion",
-      "Test conversion patterns that lower slices ops in the vector dialect");
-
-  PassRegistration<TestVectorContractionConversion> contractionPass(
-      "test-vector-contraction-conversion",
-      "Test conversion patterns that lower contract ops in the vector dialect");
-
-  PassRegistration<TestVectorUnrollingPatterns> contractionUnrollingPass(
-      "test-vector-unrolling-patterns",
-      "Test conversion patterns to unroll contract ops in the vector dialect");
-
-  PassRegistration<TestVectorTransferUnrollingPatterns> transferOpUnrollingPass(
-      "test-vector-transfer-unrolling-patterns",
-      "Test conversion patterns to unroll transfer ops in the vector dialect");
-
-  PassRegistration<TestVectorTransferFullPartialSplitPatterns>
-      vectorTransformFullPartialPass("test-vector-transfer-full-partial-split",
-                                     "Test conversion patterns to split "
-                                     "transfer ops via scf.if + linalg ops");
-
-  PassRegistration<TestVectorDistributePatterns> distributePass(
-      "test-vector-distribute-patterns",
-      "Test conversion patterns to distribute vector ops in the vector "
-      "dialect");
-
-  PassRegistration<TestVectorToLoopPatterns> vectorToForLoop(
-      "test-vector-to-forloop",
-      "Test conversion patterns to break up a vector op into a for loop");
-
-  PassRegistration<TestVectorTransferOpt> transferOpOpt(
-      "test-vector-transferop-opt",
-      "Test optimization transformations for transfer ops");
-
-  PassRegistration<TestVectorTransferLoweringPatterns> transferOpLoweringPass(
-      "test-vector-transfer-lowering-patterns",
-      "Test conversion patterns to lower transfer ops to other vector ops");
-
-  PassRegistration<TestVectorMultiReductionLoweringPatterns>
-      multiDimReductionOpLoweringPass(
-          "test-vector-multi-reduction-lowering-patterns",
-          "Test conversion patterns to lower vector.multi_reduction to other "
-          "vector ops");
+  PassRegistration<TestVectorToVectorConversion>();
+
+  PassRegistration<TestVectorSlicesConversion>();
+
+  PassRegistration<TestVectorContractionConversion>();
+
+  PassRegistration<TestVectorUnrollingPatterns>();
+
+  PassRegistration<TestVectorTransferUnrollingPatterns>();
+
+  PassRegistration<TestVectorTransferFullPartialSplitPatterns>();
+
+  PassRegistration<TestVectorDistributePatterns>();
+
+  PassRegistration<TestVectorToLoopPatterns>();
+
+  PassRegistration<TestVectorTransferOpt>();
+
+  PassRegistration<TestVectorTransferLoweringPatterns>();
+
+  PassRegistration<TestVectorMultiReductionLoweringPatterns>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestDominance.cpp

public:
   }
 
 private:
   Operation *operation;
   DenseMap<Block *, size_t> blockIds;
 };
 
 struct TestDominancePass : public PassWrapper<TestDominancePass, FunctionPass> {
+  StringRef getArgument() const final { return "test-print-dominance"; }
+  StringRef getDescription() const final {
+    return "Print the dominance information for multiple regions.";
+  }
 
   void runOnFunction() override {
     llvm::errs() << "Testing : " << getFunction().getName() << "\n";
     DominanceTest dominanceTest(getFunction());
 
     // Print dominance information.
     llvm::errs() << "--- DominanceInfo ---\n";
     dominanceTest.printDominance(getAnalysis<DominanceInfo>(),
dominanceTest.printDominance(getAnalysis<PostDominanceInfo>(),
                                  /*printCommonDominatorInfo=*/false);
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
-void registerTestDominancePass() {
-  PassRegistration<TestDominancePass>(
-      "test-print-dominance",
-      "Print the dominance information for multiple regions.");
-}
+void registerTestDominancePass() { PassRegistration<TestDominancePass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestFunc.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// This is a test pass for verifying FuncOp's eraseArgument method.
 struct TestFuncEraseArg
     : public PassWrapper<TestFuncEraseArg, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-func-erase-arg"; }
+  StringRef getDescription() const final { return "Test erasing func args."; }
   void runOnOperation() override {
     auto module = getOperation();
 
     for (FuncOp func : module.getOps<FuncOp>()) {
       SmallVector<unsigned, 4> indicesToErase;
       for (auto argIndex : llvm::seq<int>(0, func.getNumArguments())) {
         if (func.getArgAttr(argIndex, "test.erase_this_arg")) {
           // Push back twice to test that duplicate arg indices are handled
           // correctly.
           indicesToErase.push_back(argIndex);
           indicesToErase.push_back(argIndex);
         }
       }
       // Reverse the order to test that unsorted index lists are handled
       // correctly.
       std::reverse(indicesToErase.begin(), indicesToErase.end());
       func.eraseArguments(indicesToErase);
     }
   }
 };
 
 /// This is a test pass for verifying FuncOp's eraseResult method.
 struct TestFuncEraseResult
     : public PassWrapper<TestFuncEraseResult, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-func-erase-result"; }
+  StringRef getDescription() const final {
+    return "Test erasing func results.";
+  }
   void runOnOperation() override {
     auto module = getOperation();
 
     for (FuncOp func : module.getOps<FuncOp>()) {
       SmallVector<unsigned, 4> indicesToErase;
       for (auto resultIndex : llvm::seq<int>(0, func.getNumResults())) {
-        if (func.getResultAttr(resultIndex, "test.erase_this_result")) {
-          // Push back twice to test that duplicate indices are handled
-          // correctly.
+        if (func.getResultAttr(resultIndex, "test.erase_this_"
+                                            "result")) {
+          // Push back twice to test
+          // that duplicate indices
+          // are handled correctly.
           indicesToErase.push_back(resultIndex);
           indicesToErase.push_back(resultIndex);
         }
       }
-      // Reverse the order to test that unsorted index lists are handled
-      // correctly.
+      // Reverse the order to test
+      // that unsorted index lists are
+      // handled correctly.
       std::reverse(indicesToErase.begin(), indicesToErase.end());
       func.eraseResults(indicesToErase);
     }
   }
 };
 
 /// This is a test pass for verifying FuncOp's setType method.
 struct TestFuncSetType
     : public PassWrapper<TestFuncSetType, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-func-set-type"; }
+  StringRef getDescription() const final { return "Test FuncOp::setType."; }
   void runOnOperation() override {
     auto module = getOperation();
     SymbolTable symbolTable(module);
 
     for (FuncOp func : module.getOps<FuncOp>()) {
       auto sym = func->getAttrOfType<FlatSymbolRefAttr>("test.set_type_from");
       if (!sym)
         continue;
       func.setType(symbolTable.lookup<FuncOp>(sym.getValue()).getType());
     }
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 void registerTestFunc() {
-  PassRegistration<TestFuncEraseArg>("test-func-erase-arg",
-                                     "Test erasing func args.");
+  PassRegistration<TestFuncEraseArg>();
 
-  PassRegistration<TestFuncEraseResult>("test-func-erase-result",
-                                        "Test erasing func results.");
+  PassRegistration<TestFuncEraseResult>();
 
-  PassRegistration<TestFuncSetType>("test-func-set-type",
-                                    "Test FuncOp::setType.");
+  PassRegistration<TestFuncSetType>();
 }
 } // namespace mlir

mlir/test/lib/IR/TestInterfaces.cpp

 using namespace mlir;
 using namespace mlir::test;
 
 namespace {
 /// This test checks various aspects of Type interface generation and
 /// application.
 struct TestTypeInterfaces
     : public PassWrapper<TestTypeInterfaces, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-type-interfaces"; }
+  StringRef getDescription() const final {
+    return "Test type interface support.";
+  }
   void runOnOperation() override {
     getOperation().walk([](Operation *op) {
       for (Type type : op->getResultTypes()) {
         if (auto testInterface = type.dyn_cast<TestTypeInterface>()) {
           testInterface.printTypeA(op->getLoc());
           testInterface.printTypeB(op->getLoc());
           testInterface.printTypeC(op->getLoc());
           testInterface.printTypeD(op->getLoc());
           // Just check that we can assign the result to a variable of interface
           // type.
           TestTypeInterface result = testInterface.printTypeRet(op->getLoc());
           (void)result;
         }
         if (auto testType = type.dyn_cast<TestType>())
           testType.printTypeE(op->getLoc());
       }
     });
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
-void registerTestInterfaces() {
-  PassRegistration<TestTypeInterfaces> pass("test-type-interfaces",
-                                            "Test type interface support.");
-}
+void registerTestInterfaces() { PassRegistration<TestTypeInterfaces>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestMatchers.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// This is a test pass for verifying matchers.
 struct TestMatchers : public PassWrapper<TestMatchers, FunctionPass> {
   void runOnFunction() override;
+  StringRef getArgument() const final { return "test-matchers"; }
+  StringRef getDescription() const final {
+    return "Test C++ pattern matchers.";
+  }
 };
 } // end anonymous namespace
 
 // This could be done better but is not worth the variadic template trouble.
 template <typename Matcher>
 static unsigned countMatches(FuncOp f, Matcher &matcher) {
   unsigned count = 0;
   f.walk([&count, &matcher](Operation *op) {
void TestMatchers::runOnFunction() {
   llvm::outs() << f.getName() << "\n";
   if (f.getName() == "test1")
     test1(f);
   if (f.getName() == "test2")
     test2(f);
 }
 
 namespace mlir {
-void registerTestMatchers() {
-  PassRegistration<TestMatchers>("test-matchers", "Test C++ pattern matchers.");
-}
+void registerTestMatchers() { PassRegistration<TestMatchers>(); }
 } // namespace mlir

mlir/test/lib/IR/TestOpaqueLoc.cpp

 
 namespace {
 /// Pass that changes locations to opaque locations for each operation.
 /// It also takes all operations that are not function operations or
 /// terminators and clones them with opaque locations which store the initial
 /// locations.
 struct TestOpaqueLoc
     : public PassWrapper<TestOpaqueLoc, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-opaque-loc"; }
+  StringRef getDescription() const final {
+    return "Changes all leaf locations to opaque locations";
+  }
 
   /// A simple structure which is used for testing as an underlying location in
   /// OpaqueLoc.
   struct MyLocation {
     MyLocation() : id(42) {}
     MyLocation(int id) : id(id) {}
     int getId() { return id; }
 
void runOnOperation() override {
     getOperation().walk([&](Operation *op) { op->emitOpError(); });
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
-void registerTestOpaqueLoc() {
-  PassRegistration<TestOpaqueLoc> pass(
-      "test-opaque-loc", "Changes all leaf locations to opaque locations");
-}
+void registerTestOpaqueLoc() { PassRegistration<TestOpaqueLoc>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestPrintDefUse.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// This pass illustrates the IR def-use chains through printing.
 struct TestPrintDefUsePass
     : public PassWrapper<TestPrintDefUsePass, OperationPass<>> {
+  StringRef getArgument() const final { return "test-print-defuse"; }
+  StringRef getDescription() const final { return "Test various printing."; }
   void runOnOperation() override {
     // Recursively traverse the IR nested under the current operation and print
     // every single operation and their operands and users.
     getOperation()->walk([](Operation *op) {
       llvm::outs() << "Visiting op '" << op->getName() << "' with "
                    << op->getNumOperands() << " operands:\n";
 
       // Print information about the producer of each of the operands.
getOperation()->walk([](Operation *op) {
         }
       }
     });
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
-void registerTestPrintDefUsePass() {
-  PassRegistration<TestPrintDefUsePass>("test-print-defuse",
-                                        "Test various printing.");
-}
+void registerTestPrintDefUsePass() { PassRegistration<TestPrintDefUsePass>(); }
 } // namespace mlir

mlir/test/lib/IR/TestPrintNesting.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// This pass illustrates the IR nesting through printing.
 struct TestPrintNestingPass
     : public PassWrapper<TestPrintNestingPass, OperationPass<>> {
+  StringRef getArgument() const final { return "test-print-nesting"; }
+  StringRef getDescription() const final { return "Test various printing."; }
   // Entry point for the pass.
   void runOnOperation() override {
     Operation *op = getOperation();
     resetIndent();
     printOperation(op);
   }
 
   /// The three methods below are mutually recursive and follow the nesting of
for (int i = 0; i < indent; ++i)
       llvm::outs() << "  ";
     return llvm::outs();
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 void registerTestPrintNestingPass() {
-  PassRegistration<TestPrintNestingPass>("test-print-nesting",
-                                         "Test various printing.");
+  PassRegistration<TestPrintNestingPass>();
 }
 } // namespace mlir

mlir/test/lib/IR/TestSideEffects.cpp

 //===- TestSidEffects.cpp - Pass to test side effects ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestDialect.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 struct SideEffectsPass
     : public PassWrapper<SideEffectsPass, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-side-effects"; }
+  StringRef getDescription() const final {
+    return "Test side effects interfaces";
+  }
   void runOnOperation() override {
     auto module = getOperation();
 
     // Walk operations detecting side effects.
     SmallVector<MemoryEffects::EffectInstance, 8> effects;
     module.walk([&](MemoryEffectOpInterface op) {
       effects.clear();
       op.getEffects(effects);
module.walk([&](TestEffectOpInterface op) {
                         << instance.getParameters();
       }
     });
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
-void registerSideEffectTestPasses() {
-  PassRegistration<SideEffectsPass>("test-side-effects",
-                                    "Test side effects interfaces");
-}
+void registerSideEffectTestPasses() { PassRegistration<SideEffectsPass>(); }
 } // namespace mlir

mlir/test/lib/IR/TestSlicing.cpp

static LogicalResult createBackwardSliceFunction(Operation *op,
   builder.create<ReturnOp>(loc);
   return success();
 }
 
 namespace {
 /// Pass to test slice generated from slice analysis.
 struct SliceAnalysisTestPass
     : public PassWrapper<SliceAnalysisTestPass, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "slice-analysis-test"; }
+  StringRef getDescription() const final {
+    return "Test Slice analysis functionality.";
+  }
   void runOnOperation() override;
   SliceAnalysisTestPass() = default;
   SliceAnalysisTestPass(const SliceAnalysisTestPass &) {}
 };
 } // namespace
 
 void SliceAnalysisTestPass::runOnOperation() {
   ModuleOp module = getOperation();
funcOp.walk([&](Operation *op) {
       opNum++;
       return WalkResult::advance();
     });
   }
 }
 
 namespace mlir {
 void registerSliceAnalysisTestPass() {
-  PassRegistration<SliceAnalysisTestPass> pass(
-      "slice-analysis-test", "Test Slice analysis functionality.");
+  PassRegistration<SliceAnalysisTestPass>();
 }
 } // namespace mlir

mlir/test/lib/IR/TestSymbolUses.cpp

 
 using namespace mlir;
 
 namespace {
 /// This is a symbol test pass that tests the symbol uselist functionality
 /// provided by the symbol table along with erasing from the symbol table.
 struct SymbolUsesPass
     : public PassWrapper<SymbolUsesPass, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-symbol-uses"; }
+  StringRef getDescription() const final {
+    return "Test detection of symbol uses";
+  }
   WalkResult operateOnSymbol(Operation *symbol, ModuleOp module,
                              SmallVectorImpl<FuncOp> &deadFunctions) {
     // Test computing uses on a non symboltable op.
     Optional<SymbolTable::UseRange> symbolUses =
         SymbolTable::getSymbolUses(symbol);
 
     // Test the conservative failure case.
     if (!symbolUses) {
void runOnOperation() override {
     }
   }
 };
 
 /// This is a symbol test pass that tests the symbol use replacement
 /// functionality provided by the symbol table.
 struct SymbolReplacementPass
     : public PassWrapper<SymbolReplacementPass, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-symbol-rauw"; }
+  StringRef getDescription() const final {
+    return "Test replacement of symbol uses";
+  }
   void runOnOperation() override {
     ModuleOp module = getOperation();
 
     // Don't try to replace if we can't collect symbol uses.
     if (!SymbolTable::getSymbolUses(&module.getBodyRegion()))
       return;
 
     SymbolTableCollection symbolTable;
     SymbolUserMap symbolUsers(symbolTable, module);
     module.getBodyRegion().walk([&](Operation *nestedOp) {
       StringAttr newName = nestedOp->getAttrOfType<StringAttr>("sym.new_name");
       if (!newName)
         return;
       symbolUsers.replaceAllUsesWith(nestedOp, newName.getValue());
       SymbolTable::setSymbolName(nestedOp, newName.getValue());
     });
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 void registerSymbolTestPasses() {
-  PassRegistration<SymbolUsesPass>("test-symbol-uses",
-                                   "Test detection of symbol uses");
+  PassRegistration<SymbolUsesPass>();
 
-  PassRegistration<SymbolReplacementPass>("test-symbol-rauw",
-                                          "Test replacement of symbol uses");
+  PassRegistration<SymbolReplacementPass>();
 }
 } // namespace mlir

mlir/test/lib/IR/TestTypes.cpp

 using namespace mlir;
 using namespace mlir::test;
 
 namespace {
 struct TestRecursiveTypesPass
     : public PassWrapper<TestRecursiveTypesPass, FunctionPass> {
   LogicalResult createIRWithTypes();
 
+  StringRef getArgument() const final { return "test-recursive-types"; }
+  StringRef getDescription() const final {
+    return "Test support for recursive types";
+  }
   void runOnFunction() override {
     FuncOp func = getFunction();
 
     // Just make sure recursive types are printed and parsed.
     if (func.getName() == "roundtrip")
       return;
 
     // Create a recursive type and print it as a part of a dummy op.
LogicalResult TestRecursiveTypesPass::createIRWithTypes() {
 
   return success();
 }
 
 namespace mlir {
 namespace test {
 
 void registerTestRecursiveTypesPass() {
-  PassRegistration<TestRecursiveTypesPass> reg(
-      "test-recursive-types", "Test support for recursive types");
+  PassRegistration<TestRecursiveTypesPass>();
 }
 
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestVisitors.cpp

static void testNoSkipErasureCallbacks(Operation *op) {
   cloned->walk<WalkOrder::PostOrder>(noSkipBlockErasure);
   cloned->erase();
 }
 
 namespace {
 /// This pass exercises the different configurations of the IR visitors.
 struct TestIRVisitorsPass
     : public PassWrapper<TestIRVisitorsPass, OperationPass<>> {
+  StringRef getArgument() const final { return "test-ir-visitors"; }
+  StringRef getDescription() const final { return "Test various visitors."; }
   void runOnOperation() override {
     Operation *op = getOperation();
     testPureCallbacks(op);
     testSkipErasureCallbacks(op);
     testNoSkipErasureCallbacks(op);
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
-void registerTestIRVisitorsPass() {
-  PassRegistration<TestIRVisitorsPass>("test-ir-visitors",
-                                       "Test various visitors.");
-}
+void registerTestIRVisitorsPass() { PassRegistration<TestIRVisitorsPass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Pass/TestDynamicPipeline.cpp

 
 using namespace mlir;
 
 namespace {
 
 class TestDynamicPipelinePass
     : public PassWrapper<TestDynamicPipelinePass, OperationPass<>> {
 public:
+  StringRef getArgument() const final { return "test-dynamic-pipeline"; }
+  StringRef getDescription() const final {
+    return "Tests the dynamic pipeline feature by applying "
+           "a pipeline on a selected set of functions";
+  }
   void getDependentDialects(DialectRegistry &registry) const override {
     OpPassManager pm(ModuleOp::getOperationName(),
                      OpPassManager::Nesting::Implicit);
     (void)parsePassPipeline(pipeline, pm, llvm::errs());
     pm.getDependentDialects(registry);
   }
 
   TestDynamicPipelinePass(){};
ListOption<std::string> opNames{
       *this, "op-name", llvm::cl::MiscFlags::CommaSeparated,
       llvm::cl::desc("List of function name to apply the pipeline to")};
 };
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestDynamicPipelinePass() {
-  PassRegistration<TestDynamicPipelinePass>(
-      "test-dynamic-pipeline", "Tests the dynamic pipeline feature by applying "
-                               "a pipeline on a selected set of functions");
+  PassRegistration<TestDynamicPipelinePass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Pass/TestPassManager.cpp

 
 using namespace mlir;
 
 namespace {
 struct TestModulePass
     : public PassWrapper<TestModulePass, OperationPass<ModuleOp>> {
   void runOnOperation() final {}
   StringRef getArgument() const final { return "test-module-pass"; }
+  StringRef getDescription() const final {
+    return "Test a module pass in the pass manager";
+  }
 };
 struct TestFunctionPass : public PassWrapper<TestFunctionPass, FunctionPass> {
   void runOnFunction() final {}
   StringRef getArgument() const final { return "test-function-pass"; }
+  StringRef getDescription() const final {
+    return "Test a function pass in the pass manager";
+  }
 };
 class TestOptionsPass : public PassWrapper<TestOptionsPass, FunctionPass> {
 public:
   struct Options : public PassPipelineOptions<Options> {
     ListOption<int> listOption{*this, "list",
                                llvm::cl::MiscFlags::CommaSeparated,
                                llvm::cl::desc("Example list option")};
     ListOption<std::string> stringListOption{
         *this, "string-list", llvm::cl::MiscFlags::CommaSeparated,
         llvm::cl::desc("Example string list option")};
     Option<std::string> stringOption{*this, "string",
                                      llvm::cl::desc("Example string option")};
   };
   TestOptionsPass() = default;
   TestOptionsPass(const TestOptionsPass &) {}
   TestOptionsPass(const Options &options) {
     listOption = options.listOption;
     stringOption = options.stringOption;
     stringListOption = options.stringListOption;
   }
 
   void runOnFunction() final {}
   StringRef getArgument() const final { return "test-options-pass"; }
+  StringRef getDescription() const final {
+    return "Test options parsing capabilities";
+  }
 
   ListOption<int> listOption{*this, "list", llvm::cl::MiscFlags::CommaSeparated,
                              llvm::cl::desc("Example list option")};
   ListOption<std::string> stringListOption{
       *this, "string-list", llvm::cl::MiscFlags::CommaSeparated,
       llvm::cl::desc("Example string list option")};
   Option<std::string> stringOption{*this, "string",
                                    llvm::cl::desc("Example string option")};
 };
 
 /// A test pass that always aborts to enable testing the crash recovery
 /// mechanism of the pass manager.
 class TestCrashRecoveryPass
     : public PassWrapper<TestCrashRecoveryPass, OperationPass<>> {
   void runOnOperation() final { abort(); }
   StringRef getArgument() const final { return "test-pass-crash"; }
+  StringRef getDescription() const final {
+    return "Test a pass in the pass manager that always crashes";
+  }
 };
 
 /// A test pass that always fails to enable testing the failure recovery
 /// mechanisms of the pass manager.
 class TestFailurePass : public PassWrapper<TestFailurePass, OperationPass<>> {
   void runOnOperation() final { signalPassFailure(); }
+  StringRef getArgument() const final { return "test-pass-failure"; }
+  StringRef getDescription() const final {
+    return "Test a pass in the pass manager that always fails";
+  }
 };
 
 /// A test pass that contains a statistic.
 struct TestStatisticPass
     : public PassWrapper<TestStatisticPass, OperationPass<>> {
   TestStatisticPass() = default;
   TestStatisticPass(const TestStatisticPass &) {}
+  StringRef getArgument() const final { return "test-stats-pass"; }
+  StringRef getDescription() const final { return "Test pass statistics"; }
 
   Statistic opCount{this, "num-ops", "Number of operations counted"};
 
   void runOnOperation() final {
     getOperation()->walk([&](Operation *) { ++opCount; });
   }
 };
 } // end anonymous namespace

 }
 
 static void testNestedPipelineTextual(OpPassManager &pm) {
   (void)parsePassPipeline("test-pm-nested-pipeline", pm);
 }
 
 namespace mlir {
 void registerPassManagerTestPass() {
-  PassRegistration<TestOptionsPass>("test-options-pass",
-                                    "Test options parsing capabilities");
+  PassRegistration<TestOptionsPass>();
 
-  PassRegistration<TestModulePass>("test-module-pass",
-                                   "Test a module pass in the pass manager");
+  PassRegistration<TestModulePass>();
 
-  PassRegistration<TestFunctionPass>(
-      "test-function-pass", "Test a function pass in the pass manager");
+  PassRegistration<TestFunctionPass>();
 
-  PassRegistration<TestCrashRecoveryPass>(
-      "test-pass-crash", "Test a pass in the pass manager that always crashes");
-  PassRegistration<TestFailurePass>(
-      "test-pass-failure", "Test a pass in the pass manager that always fails");
+  PassRegistration<TestCrashRecoveryPass>();
+  PassRegistration<TestFailurePass>();
 
-  PassRegistration<TestStatisticPass> unusedStatP("test-stats-pass",
-                                                  "Test pass statistics");
+  PassRegistration<TestStatisticPass>();
 
   PassPipelineRegistration<>("test-pm-nested-pipeline",
                              "Test a nested pipeline in the pass manager",
                              testNestedPipeline);
   PassPipelineRegistration<>("test-textual-pm-nested-pipeline",
                              "Test a nested pipeline in the pass manager",
                              testNestedPipelineTextual);
   PassPipelineRegistration<>(

mlir/test/lib/Reducer/MLIRTestReducer.cpp

 static llvm::cl::OptionCategory clOptionsCategory(PASS_NAME " options");
 
 namespace {
 
 /// This pass looks for for the presence of an operation with the name
 /// "crashOp" in the input MLIR file and crashes the mlir-opt tool if the
 /// operation is found.
 struct TestReducer : public PassWrapper<TestReducer, FunctionPass> {
+  StringRef getArgument() const final { return PASS_NAME; }
+  StringRef getDescription() const final {
+    return "Tests MLIR Reduce tool by generating failures";
+  }
   TestReducer() = default;
   TestReducer(const TestReducer &pass){};
   void runOnFunction() override;
 };
 
 } // end anonymous namespace
 
 void TestReducer::runOnFunction() {
   for (auto &op : getOperation())
     op.walk([&](Operation *op) {
       StringRef opName = op->getName().getStringRef();
 
       if (opName.contains("op_crash")) {
         llvm::errs() << "MLIR Reducer Test generated failure: Found "
                         "\"crashOp\" operation\n";
         exit(1);
       }
     });
 }
 
 namespace mlir {
-void registerTestReducer() {
-  PassRegistration<TestReducer>(
-      PASS_NAME, "Tests MLIR Reduce tool by generating failures");
-}
+void registerTestReducer() { PassRegistration<TestReducer>(); }
 } // namespace mlir

mlir/test/lib/Rewrite/TestPDLByteCode.cpp

static void customRewriter(ArrayRef<PDLValue> args, ArrayAttr constantParams,
   successOpState.addAttribute("constantParams", constantParams);
   rewriter.createOperation(successOpState);
   rewriter.eraseOp(root);
 }
 
 namespace {
 struct TestPDLByteCodePass
     : public PassWrapper<TestPDLByteCodePass, OperationPass<ModuleOp>> {
+  StringRef getArgument() const final { return "test-pdl-bytecode-pass"; }
+  StringRef getDescription() const final {
+    return "Test PDL ByteCode functionality";
+  }
   void runOnOperation() final {
     ModuleOp module = getOperation();
 
     // The test cases are encompassed via two modules, one containing the
     // patterns and one containing the operations to rewrite.
     ModuleOp patternModule = module.lookupSymbol<ModuleOp>("patterns");
     ModuleOp irModule = module.lookupSymbol<ModuleOp>("ir");
     if (!patternModule || !irModule)
void runOnOperation() final {
     (void)applyPatternsAndFoldGreedily(irModule.getBodyRegion(),
                                        std::move(patternList));
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
-void registerTestPDLByteCodePass() {
-  PassRegistration<TestPDLByteCodePass>("test-pdl-bytecode-pass",
-                                        "Test PDL ByteCode functionality");
-}
+void registerTestPDLByteCodePass() { PassRegistration<TestPDLByteCodePass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestConstantFold.cpp

 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/Utils.h"
 
 using namespace mlir;
 
 namespace {
 /// Simple constant folding pass.
 struct TestConstantFold : public PassWrapper<TestConstantFold, FunctionPass> {
+  StringRef getArgument() const final { return "test-constant-fold"; }
+  StringRef getDescription() const final {
+    return "Test operation constant folding";
+  }
   // All constants in the function post folding.
   SmallVector<Operation *, 8> existingConstants;
 
   void foldOperation(Operation *op, OperationFolder &helper);
   void runOnFunction() override;
 };
 } // end anonymous namespace
 
void TestConstantFold::runOnFunction() {
   for (auto *cst : existingConstants) {
     if (cst->use_empty())
       cst->erase();
   }
 }
 
 namespace mlir {
 namespace test {
-void registerTestConstantFold() {
-  PassRegistration<TestConstantFold>("test-constant-fold",
-                                     "Test operation constant folding");
-}
+void registerTestConstantFold() { PassRegistration<TestConstantFold>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestInlining.cpp

 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/StringSet.h"
 
 using namespace mlir;
 using namespace mlir::test;
 
 namespace {
 struct Inliner : public PassWrapper<Inliner, FunctionPass> {
+  StringRef getArgument() const final { return "test-inline"; }
+  StringRef getDescription() const final {
+    return "Test inlining region calls";
+  }
+
   void runOnFunction() override {
     auto function = getFunction();
 
     // Collect each of the direct function calls within the module.
     SmallVector<CallIndirectOp, 16> callers;
     function.walk([&](CallIndirectOp caller) { callers.push_back(caller); });
 
     // Build the inliner interface.
for (auto caller : callers) {
         callee.erase();
     }
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
-void registerInliner() {
-  PassRegistration<Inliner>("test-inline", "Test inlining region calls");
-}
+void registerInliner() { PassRegistration<Inliner>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopFusion.cpp

 static llvm::cl::opt<bool> clTestLoopFusionTransformation(
     "test-loop-fusion-transformation",
     llvm::cl::desc("Enable testing of loop fusion transformation"),
     llvm::cl::cat(clOptionsCategory));
 
 namespace {
 
 struct TestLoopFusion : public PassWrapper<TestLoopFusion, FunctionPass> {
+  StringRef getArgument() const final { return "test-loop-fusion"; }
+  StringRef getDescription() const final {
+    return "Tests loop fusion utility functions.";
+  }
   void runOnFunction() override;
 };
 
 } // end anonymous namespace
 
 // Run fusion dependence check on 'loops[i]' and 'loops[j]' at loop depths
 // in range ['loopDepth' + 1, 'maxLoopDepth'].
 // Emits a remark on 'loops[i]' if a fusion-preventing dependence exists.
void TestLoopFusion::runOnFunction() {
   if (clTestDependenceCheck)
     iterateLoops(depthToLoops, testDependenceCheck);
   if (clTestSliceComputation)
     iterateLoops(depthToLoops, testSliceComputation);
 }
 
 namespace mlir {
 namespace test {
-void registerTestLoopFusion() {
-  PassRegistration<TestLoopFusion>("test-loop-fusion",
-                                   "Tests loop fusion utility functions.");
-}
+void registerTestLoopFusion() { PassRegistration<TestLoopFusion>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopMapping.cpp

 #include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 
 namespace {
 class TestLoopMappingPass
     : public PassWrapper<TestLoopMappingPass, FunctionPass> {
 public:
+  StringRef getArgument() const final {
+    return "test-mapping-to-processing-elements";
+  }
+  StringRef getDescription() const final {
+    return "test mapping a single loop on a virtual processor grid";
+  }
   explicit TestLoopMappingPass() {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, scf::SCFDialect>();
   }
 
   void runOnFunction() override {
     FuncOp func = getFunction();
func.walk([&processorIds, &numProcessors](scf::ForOp op) {
       mapLoopToProcessorIds(op, processorIds, numProcessors);
     });
   }
 };
 } // namespace
 
 namespace mlir {
 namespace test {
-void registerTestLoopMappingPass() {
-  PassRegistration<TestLoopMappingPass>(
-      "test-mapping-to-processing-elements",
-      "test mapping a single loop on a virtual processor grid");
-}
+void registerTestLoopMappingPass() { PassRegistration<TestLoopMappingPass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopParametricTiling.cpp

 
 namespace {
 
 // Extracts fixed-range loops for top-level loop nests with ranges defined in
 // the pass constructor.  Assumes loops are permutable.
 class SimpleParametricLoopTilingPass
     : public PassWrapper<SimpleParametricLoopTilingPass, FunctionPass> {
 public:
+  StringRef getArgument() const final {
+    return "test-extract-fixed-outer-loops";
+  }
+  StringRef getDescription() const final {
+    return "test application of parametric tiling to the outer loops so that "
+           "the "
+           "ranges of outer loops become static";
+  }
   SimpleParametricLoopTilingPass() = default;
   SimpleParametricLoopTilingPass(const SimpleParametricLoopTilingPass &) {}
   explicit SimpleParametricLoopTilingPass(ArrayRef<int64_t> outerLoopSizes) {
     sizes = outerLoopSizes;
   }
 
   void runOnFunction() override {
     FuncOp func = getFunction();
ListOption<int64_t> sizes{
       llvm::cl::desc(
           "fixed number of iterations that the outer loops should have")};
 };
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerSimpleParametricTilingPass() {
-  PassRegistration<SimpleParametricLoopTilingPass>(
-      "test-extract-fixed-outer-loops",
-      "test application of parametric tiling to the outer loops so that the "
-      "ranges of outer loops become static");
+  PassRegistration<SimpleParametricLoopTilingPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopUnrolling.cpp

if (isa<scf::ForOp>(currOp))
       depth++;
   }
   return depth;
 }
 
 class TestLoopUnrollingPass
     : public PassWrapper<TestLoopUnrollingPass, FunctionPass> {
 public:
+  StringRef getArgument() const final { return "test-loop-unrolling"; }
+  StringRef getDescription() const final {
+    return "Tests loop unrolling transformation";
+  }
   TestLoopUnrollingPass() = default;
   TestLoopUnrollingPass(const TestLoopUnrollingPass &) {}
   explicit TestLoopUnrollingPass(uint64_t unrollFactorParam,
                                  unsigned loopDepthParam) {
     unrollFactor = unrollFactorParam;
     loopDepth = loopDepthParam;
   }
 
public:
   Option<unsigned> loopDepth{*this, "loop-depth", llvm::cl::desc("Loop depth."),
                              llvm::cl::init(0)};
 };
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestLoopUnrollingPass() {
-  PassRegistration<TestLoopUnrollingPass>(
-      "test-loop-unrolling", "Tests loop unrolling transformation");
+  PassRegistration<TestLoopUnrollingPass>();
 }
 } // namespace test
 } // namespace mlir