[mlir][spirv] Clean up transform pass definitions. NFC.

[kuhar]

Summary

• Make naming more consistent.
• Drop unnecessary custom constructors definitions.
• Move pass documentation to pass descriptions.

[antiagainst]

Thanks for the cleanup!

mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.td

29

s/with/to attach/

[kuhar]

Update pass description

mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.h

 
 //===----------------------------------------------------------------------===//
 // Passes
 //===----------------------------------------------------------------------===//
 
 #define GEN_PASS_DECL
 #include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
 
-/// Creates a pass to run canoncalization patterns that involve GL ops.
-/// These patterns cannot be run in default canonicalization because GL ops
-/// aren't always available. So they should be involed specifically when needed.
-std::unique_ptr<OperationPass<>> createCanonicalizeGLPass();
-
-/// Creates a module pass that converts composite types used by objects in the
-/// StorageBuffer, PhysicalStorageBuffer, Uniform, and PushConstant storage
-/// classes with layout information.
-/// Right now this pass only supports Vulkan layout rules.
-std::unique_ptr<OperationPass<mlir::ModuleOp>>
-createDecorateSPIRVCompositeTypeLayoutPass();
-
-/// Creates an operation pass that deduces and attaches the minimal version/
-/// capabilities/extensions requirements for spirv.module ops.
-/// For each spirv.module op, this pass requires a `spirv.target_env` attribute
-/// on it or an enclosing module-like op to drive the deduction. The reason is
-/// that an op can be enabled by multiple extensions/capabilities. So we need
-/// to know which one to pick. `spirv.target_env` gives the hard limit as for
-/// what the target environment can support; this pass deduces what are
-/// actually needed for a specific spirv.module op.
-std::unique_ptr<OperationPass<spirv::ModuleOp>>
-createUpdateVersionCapabilityExtensionPass();
-
-/// Creates an operation pass that lowers the ABI attributes specified during
-/// SPIR-V Lowering. Specifically,
-/// 1. Creates the global variables for arguments of entry point function using
-///    the specification in the `spirv.interface_var_abi` attribute for each
-///    argument.
-/// 2. Inserts the EntryPointOp and the ExecutionModeOp for entry point
-///    functions using the specification in the `spirv.entry_point_abi`
-///    attribute.
-std::unique_ptr<OperationPass<spirv::ModuleOp>> createLowerABIAttributesPass();
-
-/// Creates an operation pass that rewrites sequential chains of
-/// spirv.CompositeInsert into spirv.CompositeConstruct.
-std::unique_ptr<OperationPass<spirv::ModuleOp>> createRewriteInsertsPass();
-
 /// Creates an operation pass that unifies access of multiple aliased resources
 /// into access of one single resource.
 using GetTargetEnvFn = std::function<spirv::TargetEnvAttr(spirv::ModuleOp)>;
 std::unique_ptr<OperationPass<spirv::ModuleOp>>
 createUnifyAliasedResourcePass(GetTargetEnvFn getTargetEnv = nullptr);
 
 //===----------------------------------------------------------------------===//
 // Registration

mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.td

 //===-- Passes.td - SPIRV pass definition file -------------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES
 #define MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def SPIRVCompositeTypeLayout
-    : Pass<"decorate-spirv-composite-type-layout", "mlir::ModuleOp"> {
-  let summary = "Decorate SPIR-V composite type with layout info";
-  let constructor = "mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass()";
+def SPIRVCanonicalizeGLPass : Pass<"spirv-canonicalize-gl", ""> {
+  let summary = "Canonicalize GLSL ops";
+  let description = [{
+    Pass to run canoncalization patterns that involve GL ops.
+    These patterns cannot be run in default canonicalization because GL ops
+    aren't always available. So they should be involed specifically when needed.
+  }];
 }
 
-def SPIRVCanonicalizeGL : Pass<"spirv-canonicalize-gl", ""> {
-  let summary = "Run canonicalization involving GLSL ops";
-  let constructor = "mlir::spirv::createCanonicalizeGLPass()";
+def SPIRVCompositeTypeLayoutPass
+    : Pass<"decorate-spirv-composite-type-layout", "mlir::ModuleOp"> {
+  let summary = "Decorate SPIR-V composite type with layout info";
+  let description = [{
+    Module pass that converts composite types used by objects in the
+    StorageBuffer, PhysicalStorageBuffer, Uniform, and PushConstant storage
+    classes to attatch layout information.
+    Right now this pass only supports Vulkan layout rules.
+  }];
 }
 
-def SPIRVLowerABIAttributes : Pass<"spirv-lower-abi-attrs", "spirv::ModuleOp"> {
+def SPIRVLowerABIAttributesPass : Pass<"spirv-lower-abi-attrs", "spirv::ModuleOp"> {
   let summary = "Decorate SPIR-V composite type with layout info";
-  let constructor = "mlir::spirv::createLowerABIAttributesPass()";
+  let description = [{
+    Operation pass that lowers the ABI attributes specified during
+    SPIR-V Lowering. Specifically:
+    1. Creates the global variables for arguments of entry point function using
+      the specification in the `spirv.interface_var_abi` attribute for each
+      argument.
+    2. Inserts the EntryPointOp and the ExecutionModeOp for entry point
+      functions using the specification in the `spirv.entry_point_abi`
+      attribute.
+  }];
 }
 
 def SPIRVRewriteInsertsPass : Pass<"spirv-rewrite-inserts", "spirv::ModuleOp"> {
-  let summary = "Rewrite sequential chains of spirv.CompositeInsert operations into "
-                "spirv.CompositeConstruct operations";
-  let constructor = "mlir::spirv::createRewriteInsertsPass()";
+  let summary = "Rewrite sequential chains of `spirv.CompositeInsert` operations "
+                "into `spirv.CompositeConstruct` operations";
 }
 
 def SPIRVUnifyAliasedResourcePass
     : Pass<"spirv-unify-aliased-resource", "spirv::ModuleOp"> {
   let summary = "Unify access of multiple aliased resources into access of one "
                 "single resource";
   let constructor = "mlir::spirv::createUnifyAliasedResourcePass()";
 }
 
-def SPIRVUpdateVCE : Pass<"spirv-update-vce", "spirv::ModuleOp"> {
+def SPIRVUpdateVCEPass : Pass<"spirv-update-vce", "spirv::ModuleOp"> {
   let summary = "Deduce and attach minimal (version, capabilities, extensions) "
                 "requirements to spirv.module ops";
-  let constructor = "mlir::spirv::createUpdateVersionCapabilityExtensionPass()";
+  let description = [{
+    Operation pass that deduces and attaches the minimal version/
+    capabilities/extensions requirements for spirv.module ops.
+    For each spirv.module op, this pass requires a `spirv.target_env` attribute
+    on it or an enclosing module-like op to drive the deduction. The reason is
+    that an op can be enabled by multiple extensions/capabilities. So we need
+    to know which one to pick. `spirv.target_env` gives the hard limit as for
+    what the target environment can support; this pass deduces what are
+    actually needed for a specific spirv.module op.
+  }];
 }
 
 def SPIRVWebGPUPreparePass : Pass<"spirv-webgpu-prepare", "spirv::ModuleOp"> {
   let summary = "Prepare SPIR-V to target WebGPU by expanding unsupported ops "
                 "and replacing with supported ones";
 }
 
 #endif // MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES

mlir/lib/Dialect/SPIRV/Transforms/CanonicalizeGLPass.cpp

 
 #include "mlir/Dialect/SPIRV/IR/SPIRVGLCanonicalization.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 namespace mlir {
 namespace spirv {
-#define GEN_PASS_DEF_SPIRVCANONICALIZEGL
+#define GEN_PASS_DEF_SPIRVCANONICALIZEGLPASS
 #include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
 } // namespace spirv
 } // namespace mlir
 
 using namespace mlir;
 
 namespace {
 class CanonicalizeGLPass final
-    : public spirv::impl::SPIRVCanonicalizeGLBase<CanonicalizeGLPass> {
+    : public spirv::impl::SPIRVCanonicalizeGLPassBase<CanonicalizeGLPass> {
 public:
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     spirv::populateSPIRVGLCanonicalizationPatterns(patterns);
     if (failed(
             applyPatternsAndFoldGreedily(getOperation(), std::move(patterns))))
       return signalPassFailure();
   }
 };
 } // namespace
-
-std::unique_ptr<OperationPass<>> spirv::createCanonicalizeGLPass() {
-  return std::make_unique<CanonicalizeGLPass>();
-}

mlir/lib/Dialect/SPIRV/Transforms/DecorateCompositeTypeLayoutPass.cpp

 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 
 namespace mlir {
 namespace spirv {
-#define GEN_PASS_DEF_SPIRVCOMPOSITETYPELAYOUT
+#define GEN_PASS_DEF_SPIRVCOMPOSITETYPELAYOUTPASS
 #include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
 } // namespace spirv
 } // namespace mlir
 
 namespace {
 class SPIRVGlobalVariableOpLayoutInfoDecoration
     : public OpRewritePattern<spirv::GlobalVariableOp> {
 public:
patterns.add<SPIRVGlobalVariableOpLayoutInfoDecoration,
                SPIRVPassThroughConversion<spirv::AccessChainOp>,
                SPIRVPassThroughConversion<spirv::LoadOp>,
                SPIRVPassThroughConversion<spirv::StoreOp>>(
       patterns.getContext());
 }
 
 namespace {
 class DecorateSPIRVCompositeTypeLayoutPass
-    : public spirv::impl::SPIRVCompositeTypeLayoutBase<
+    : public spirv::impl::SPIRVCompositeTypeLayoutPassBase<
           DecorateSPIRVCompositeTypeLayoutPass> {
   void runOnOperation() override;
 };
 } // namespace
 
 void DecorateSPIRVCompositeTypeLayoutPass::runOnOperation() {
   auto module = getOperation();
   RewritePatternSet patterns(module.getContext());
target.addDynamicallyLegalOp<spirv::AccessChainOp, spirv::LoadOp,
     return true;
   });
 
   FrozenRewritePatternSet frozenPatterns(std::move(patterns));
   for (auto spirvModule : module.getOps<spirv::ModuleOp>())
     if (failed(applyFullConversion(spirvModule, target, frozenPatterns)))
       signalPassFailure();
 }
-
-std::unique_ptr<OperationPass<ModuleOp>>
-mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass() {
-  return std::make_unique<DecorateSPIRVCompositeTypeLayoutPass>();
-}

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/SetVector.h"
 
 namespace mlir {
 namespace spirv {
-#define GEN_PASS_DEF_SPIRVLOWERABIATTRIBUTES
+#define GEN_PASS_DEF_SPIRVLOWERABIATTRIBUTESPASS
 #include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
 } // namespace spirv
 } // namespace mlir
 
 using namespace mlir;
 
 /// Creates a global variable for an argument based on the ABI info.
 static spirv::GlobalVariableOp
public:
 
   LogicalResult
   matchAndRewrite(spirv::FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Pass to implement the ABI information specified as attributes.
 class LowerABIAttributesPass final
-    : public spirv::impl::SPIRVLowerABIAttributesBase<LowerABIAttributesPass> {
+    : public spirv::impl::SPIRVLowerABIAttributesPassBase<
+          LowerABIAttributesPass> {
   void runOnOperation() override;
 };
 } // namespace
 
 LogicalResult ProcessInterfaceVarABI::matchAndRewrite(
     spirv::FuncOp funcOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   if (!funcOp->getAttrOfType<spirv::EntryPointABIAttr>(
module.walk([&](spirv::FuncOp funcOp) {
     }
   });
   for (auto fn : entryPointFns) {
     if (failed(lowerEntryPointABIAttr(fn, builder))) {
       return signalPassFailure();
     }
   }
 }
-
-std::unique_ptr<OperationPass<spirv::ModuleOp>>
-mlir::spirv::createLowerABIAttributesPass() {
-  return std::make_unique<LowerABIAttributesPass>();
-}

mlir/lib/Dialect/SPIRV/Transforms/RewriteInsertsPass.cpp

while (true) {
       indicesArrayAttr = op.getIndices().cast<ArrayAttr>();
       if ((indicesArrayAttr.size() != 1) ||
           (indicesArrayAttr[0].cast<IntegerAttr>().getInt() != index))
         return failure();
     }
   }
   return failure();
 }
-
-std::unique_ptr<mlir::OperationPass<spirv::ModuleOp>>
-mlir::spirv::createRewriteInsertsPass() {
-  return std::make_unique<RewriteInsertsPass>();
-}

mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Visitors.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 
 namespace mlir {
 namespace spirv {
-#define GEN_PASS_DEF_SPIRVUPDATEVCE
+#define GEN_PASS_DEF_SPIRVUPDATEVCEPASS
 #include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
 } // namespace spirv
 } // namespace mlir
 
 using namespace mlir;
 
 namespace {
 /// Pass to deduce minimal version/extension/capability requirements for a
 /// spirv::ModuleOp.
 class UpdateVCEPass final
-    : public spirv::impl::SPIRVUpdateVCEBase<UpdateVCEPass> {
+    : public spirv::impl::SPIRVUpdateVCEPassBase<UpdateVCEPass> {
   void runOnOperation() override;
 };
 } // namespace
 
 /// Checks that `candidates` extension requirements are possible to be satisfied
 /// with the given `targetEnv` and updates `deducedExtensions` if so. Emits
 /// errors attaching to the given `op` on failures.
 ///
void UpdateVCEPass::runOnOperation() {
   // TODO: verify that the deduced version is consistent with
   // SPIR-V ops' maximal version requirements.
 
   auto triple = spirv::VerCapExtAttr::get(
       deducedVersion, deducedCapabilities.getArrayRef(),
       deducedExtensions.getArrayRef(), &getContext());
   module->setAttr(spirv::ModuleOp::getVCETripleAttrName(), triple);
 }
-
-std::unique_ptr<OperationPass<spirv::ModuleOp>>
-mlir::spirv::createUpdateVersionCapabilityExtensionPass() {
-  return std::make_unique<UpdateVCEPass>();
-}

mlir/tools/mlir-spirv-cpu-runner/mlir-spirv-cpu-runner.cpp

static LogicalResult runMLIRPasses(Operation *module,
                                    JitRunnerOptions &options) {
   PassManager passManager(module->getContext(),
                           module->getName().getStringRef());
   applyPassManagerCLOptions(passManager);
   passManager.addPass(createGpuKernelOutliningPass());
   passManager.addPass(createConvertGPUToSPIRVPass(/*mapMemorySpace=*/true));
 
   OpPassManager &nestedPM = passManager.nest<spirv::ModuleOp>();
-  nestedPM.addPass(spirv::createLowerABIAttributesPass());
-  nestedPM.addPass(spirv::createUpdateVersionCapabilityExtensionPass());
+  nestedPM.addPass(spirv::createSPIRVLowerABIAttributesPass());
+  nestedPM.addPass(spirv::createSPIRVUpdateVCEPass());
   passManager.addPass(createLowerHostCodeToLLVMPass());
   passManager.addPass(createConvertSPIRVToLLVMPass());
   return passManager.run(module);
 }
 
 int main(int argc, char **argv) {
   llvm::InitLLVM y(argc, argv);
 

mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp

static LogicalResult runMLIRPasses(Operation *op,
   PassManager passManager(module.getContext());
   applyPassManagerCLOptions(passManager);
 
   passManager.addPass(createGpuKernelOutliningPass());
   passManager.addPass(memref::createFoldMemRefAliasOpsPass());
 
   passManager.addPass(createConvertGPUToSPIRVPass(/*mapMemorySpace=*/true));
   OpPassManager &modulePM = passManager.nest<spirv::ModuleOp>();
-  modulePM.addPass(spirv::createLowerABIAttributesPass());
-  modulePM.addPass(spirv::createUpdateVersionCapabilityExtensionPass());
+  modulePM.addPass(spirv::createSPIRVLowerABIAttributesPass());
+  modulePM.addPass(spirv::createSPIRVUpdateVCEPass());
   if (options.spirvWebGPUPrepare)
     modulePM.addPass(spirv::createSPIRVWebGPUPreparePass());
 
   passManager.addPass(createConvertGpuLaunchFuncToVulkanLaunchFuncPass());
   LowerToLLVMOptions llvmOptions(module.getContext(), DataLayout(module));
   passManager.addPass(createMemRefToLLVMConversionPass());
   passManager.addPass(createConvertVectorToLLVMPass());
   passManager.nest<func::FuncOp>().addPass(LLVM::createRequestCWrappersPass());