[mlir] Use 'GEN_PASS_DECL' for pass declarations

[rkayaith]

Summary

Most dialects are using a single a header for all their passes, switch
them over to using GEN_PASS_DECL instead of the individual macros.

[jpienaar]

LG/removing blocker shape side.

mlir/include/mlir/Dialect/Affine/Passes.h

 } // namespace func
 
 class AffineForOp;
 
 /// Fusion mode to attempt. The default mode `Greedy` does both
 /// producer-consumer and sibling fusion.
 enum FusionMode { Greedy, ProducerConsumer, Sibling };
 
-#define GEN_PASS_DECL_AFFINEDATACOPYGENERATION
-#define GEN_PASS_DECL_AFFINELOOPFUSION
-#define GEN_PASS_DECL_AFFINELOOPINVARIANTCODEMOTION
-#define GEN_PASS_DECL_AFFINELOOPTILING
-#define GEN_PASS_DECL_AFFINELOOPUNROLL
-#define GEN_PASS_DECL_AFFINELOOPUNROLLANDJAM
-#define GEN_PASS_DECL_AFFINEPIPELINEDATATRANSFER
-#define GEN_PASS_DECL_AFFINESCALARREPLACEMENT
-#define GEN_PASS_DECL_AFFINEVECTORIZE
-#define GEN_PASS_DECL_AFFINEPARALLELIZE
-#define GEN_PASS_DECL_AFFINELOOPNORMALIZE
-#define GEN_PASS_DECL_LOOPCOALESCING
-#define GEN_PASS_DECL_SIMPLIFYAFFINESTRUCTURES
-#define GEN_PASS_DECL_AFFINEEXPANDINDEXOPS
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Affine/Passes.h.inc"
 
 /// Creates a simplification pass for affine structures (maps and sets). In
 /// addition, this pass also normalizes memrefs to have the trivial (identity)
 /// layout map.
 std::unique_ptr<OperationPass<func::FuncOp>>
 createSimplifyAffineStructuresPass();
 

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

 //===- Passes.h - Pass Entrypoints ------------------------------*- C++ -*-===//
 //
 // 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_ARITHMETIC_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace arith {
 
-#define GEN_PASS_DECL_ARITHMETICBUFFERIZE
-#define GEN_PASS_DECL_ARITHMETICEMULATEWIDEINT
-#define GEN_PASS_DECL_ARITHMETICEXPANDOPS
-#define GEN_PASS_DECL_ARITHMETICUNSIGNEDWHENEQUIVALENT
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
 
 class WideIntEmulationConverter;
 
 /// Create a pass to bufferize Arithmetic ops.
 std::unique_ptr<Pass> createArithmeticBufferizePass();
 
 /// Create a pass to bufferize arith.constant ops.

mlir/include/mlir/Dialect/Async/Passes.h

 #ifndef MLIR_DIALECT_ASYNC_PASSES_H_
 #define MLIR_DIALECT_ASYNC_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 class ModuleOp;
 
-#define GEN_PASS_DECL_ASYNCPARALLELFOR
-#define GEN_PASS_DECL_ASYNCTOASYNCRUNTIME
-#define GEN_PASS_DECL_ASYNCRUNTIMEREFCOUNTING
-#define GEN_PASS_DECL_ASYNCRUNTIMEREFCOUNTINGOPT
-#define GEN_PASS_DECL_ASYNCRUNTIMEPOLICYBASEDREFCOUNTING
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Async/Passes.h.inc"
 
 std::unique_ptr<Pass> createAsyncParallelForPass();
 
 std::unique_ptr<Pass> createAsyncParallelForPass(bool asyncDispatch,
                                                  int32_t numWorkerThreads,
                                                  int32_t minTaskSize);
 

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

 
 namespace bufferization {
 struct OneShotBufferizationOptions;
 
 //===----------------------------------------------------------------------===//
 // Passes
 //===----------------------------------------------------------------------===//
 
-#define GEN_PASS_DECL_BUFFERDEALLOCATION
-#define GEN_PASS_DECL_BUFFERHOISTING
-#define GEN_PASS_DECL_BUFFERLOOPHOISTING
-#define GEN_PASS_DECL_BUFFERRESULTSTOOUTPARAMS
-#define GEN_PASS_DECL_FINALIZINGBUFFERIZE
-#define GEN_PASS_DECL_BUFFERIZATIONBUFFERIZE
-#define GEN_PASS_DECL_DROPEQUIVALENTBUFFERRESULTS
-#define GEN_PASS_DECL_ONESHOTBUFFERIZE
-#define GEN_PASS_DECL_PROMOTEBUFFERSTOSTACK
-#define GEN_PASS_DECL_TENSORCOPYINSERTION
-#define GEN_PASS_DECL_ALLOCTENSORELIMINATION
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
 
 /// Creates an instance of the BufferDeallocation pass to free all allocated
 /// buffers.
 std::unique_ptr<Pass> createBufferDeallocationPass();
 
 /// Run buffer deallocation.
 LogicalResult deallocateBuffers(Operation *op);

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

 namespace bufferization {
 class BufferizeTypeConverter;
 } // namespace bufferization
 
 class RewritePatternSet;
 
 namespace func {
 
-#define GEN_PASS_DECL_FUNCBUFFERIZE
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Func/Transforms/Passes.h.inc"
 
 /// Creates an instance of func bufferization pass.
 std::unique_ptr<Pass> createFuncBufferizePass();
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//

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

 class Module;
 } // namespace llvm
 
 namespace mlir {
 namespace func {
 class FuncOp;
 } // namespace func
 
-#define GEN_PASS_DECL_GPULAUNCHSINKINDEXCOMPUTATIONS
-#define GEN_PASS_DECL_GPUKERNELOUTLINING
-#define GEN_PASS_DECL_GPUASYNCREGION
-#define GEN_PASS_DECL_GPUMAPPARALLELLOOPS
+#define GEN_PASS_DECL
 #include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
 
 /// Pass that moves ops which are likely an index computation into gpu.launch
 /// body.
 std::unique_ptr<Pass> createGpuLauchSinkIndexComputationsPass();
 
 /// Replaces `gpu.launch` with `gpu.launch_func` by moving the region into
 /// a separate kernel function.

mlir/include/mlir/Dialect/Linalg/Passes.h

 namespace func {
 class FuncOp;
 } // namespace func
 
 namespace bufferization {
 struct OneShotBufferizationOptions;
 } // namespace bufferization
 
-#define GEN_PASS_DECL_CONVERTELEMENTWISETOLINALG
-#define GEN_PASS_DECL_LINALGINITTENSORTOALLOCTENSOR
-#define GEN_PASS_DECL_LINALGFOLDUNITEXTENTDIMS
-#define GEN_PASS_DECL_LINALGELEMENTWISEOPFUSION
-#define GEN_PASS_DECL_LINALGNAMEDOPCONVERSION
-#define GEN_PASS_DECL_LINALGINLINESCALAROPERANDS
-#define GEN_PASS_DECL_LINALGLOWERTOAFFINELOOPS
-#define GEN_PASS_DECL_LINALGLOWERTOLOOPSPASS
-#define GEN_PASS_DECL_LINALGLOWERTOPARALLELLOOPS
-#define GEN_PASS_DECL_LINALGBUFFERIZE
-#define GEN_PASS_DECL_LINALGTILINGPASS
-#define GEN_PASS_DECL_LINALGGENERALIZATION
-#define GEN_PASS_DECL_LINALGDETENSORIZE
-#define GEN_PASS_DECL_LINALGSTRATEGYTILEANDFUSEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYTILEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYPADPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYDECOMPOSEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYPEELPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYVECTORIZEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYENABLEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYLOWERVECTORSPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYREMOVEMARKERSPASS
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Linalg/Passes.h.inc"
 
 std::unique_ptr<Pass> createConvertElementwiseToLinalgPass();
 
 std::unique_ptr<Pass> createLinalgFoldUnitExtentDimsPass();
 
 std::unique_ptr<Pass> createLinalgElementwiseOpFusionPass();
 std::unique_ptr<Pass> createFoldReshapeOpsByLinearizationPass();

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

 /// }
 /// ```
 LogicalResult multiBuffer(memref::AllocOp allocOp, unsigned multiplier);
 
 //===----------------------------------------------------------------------===//
 // Passes
 //===----------------------------------------------------------------------===//
 
-#define GEN_PASS_DECL_EXPANDOPS
-#define GEN_PASS_DECL_FOLDMEMREFALIASOPS
-#define GEN_PASS_DECL_NORMALIZEMEMREFS
-#define GEN_PASS_DECL_RESOLVERANKEDSHAPETYPERESULTDIMS
-#define GEN_PASS_DECL_RESOLVESHAPEDTYPERESULTDIMS
+#define GEN_PASS_DECL
 #include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
 
 /// Creates an instance of the ExpandOps pass that legalizes memref dialect ops
 /// to be convertible to LLVM. For example, `memref.reshape` gets converted to
 /// `memref_reinterpret_cast`.
 std::unique_ptr<Pass> createExpandOpsPass();
 
 /// Creates an operation pass to fold memref aliasing ops into consumer

mlir/include/mlir/Dialect/NVGPU/Passes.h

 #ifndef MLIR_DIALECT_NVGPU_PASSES_H_
 #define MLIR_DIALECT_NVGPU_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace nvgpu {
 
-#define GEN_PASS_DECL_OPTIMIZESHAREDMEMORY
+#define GEN_PASS_DECL
 #include "mlir/Dialect/NVGPU/Passes.h.inc"
 
 /// Create a pass to optimize shared memory reads and writes.
 std::unique_ptr<Pass> createOptimizeSharedMemoryPass();
 
 } // namespace nvgpu
 
 //===----------------------------------------------------------------------===//

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

 
 #ifndef MLIR_DIALECT_SCF_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_SCF_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
-#define GEN_PASS_DECL_SCFBUFFERIZE
-#define GEN_PASS_DECL_SCFFORLOOPCANONICALIZATION
-#define GEN_PASS_DECL_SCFFORLOOPPEELING
-#define GEN_PASS_DECL_SCFFORLOOPSPECIALIZATION
-#define GEN_PASS_DECL_SCFPARALLELLOOPFUSION
-#define GEN_PASS_DECL_SCFPARALLELLOOPCOLLAPSING
-#define GEN_PASS_DECL_SCFPARALLELLOOPSPECIALIZATION
-#define GEN_PASS_DECL_SCFPARALLELLOOPTILING
-#define GEN_PASS_DECL_SCFFORLOOPRANGEFOLDING
-#define GEN_PASS_DECL_SCFFORTOWHILELOOP
+#define GEN_PASS_DECL
 #include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
 
 /// Creates a pass that bufferizes the SCF dialect.
 std::unique_ptr<Pass> createSCFBufferizePass();
 
 /// Creates a pass that specializes for loop for unrolling and
 /// vectorization.
 std::unique_ptr<Pass> createForLoopSpecializationPass();

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

 namespace spirv {
 
 class ModuleOp;
 
 //===----------------------------------------------------------------------===//
 // Passes
 //===----------------------------------------------------------------------===//
 
-#define GEN_PASS_DECL_SPIRVCOMPOSITETYPELAYOUT
-#define GEN_PASS_DECL_SPIRVCANONICALIZEGL
-#define GEN_PASS_DECL_SPIRVLOWERABIATTRIBUTES
-#define GEN_PASS_DECL_SPIRVREWRITEINSERTSPASS
-#define GEN_PASS_DECL_SPIRVUNIFYALIASEDRESOURCEPASS
-#define GEN_PASS_DECL_SPIRVUPDATEVCE
+#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

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

 class TypeConverter;
 namespace func {
 class FuncOp;
 } // namespace func
 } // namespace mlir
 
 namespace mlir {
 
-#define GEN_PASS_DECL_SHAPETOSHAPELOWERING
-#define GEN_PASS_DECL_REMOVESHAPECONSTRAINTS
-#define GEN_PASS_DECL_SHAPEBUFFERIZE
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
 
 /// Creates an instance of the ShapeToShapeLowering pass that legalizes Shape
 /// dialect to be convertible to Arithmetic. For example, `shape.num_elements`
 /// get transformed to `shape.reduce`, which can be lowered to SCF and
 /// Arithmetic.
 std::unique_ptr<Pass> createShapeToShapeLowering();
 

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

 /// actually vectorized if (1) allowed by the strategy, and (2) the emitted
 /// code is an actual for-loop (and not a co-iterating while-loop).
 enum class SparseVectorizationStrategy {
   kNone,
   kDenseInnerLoop,
   kAnyStorageInnerLoop
 };
 
-#define GEN_PASS_DECL_SPARSIFICATIONPASS
-#define GEN_PASS_DECL_SPARSETENSORCONVERSIONPASS
-#define GEN_PASS_DECL_SPARSETENSORCODEGEN
+#define GEN_PASS_DECL
 #include "mlir/Dialect/SparseTensor/Transforms/Passes.h.inc"
 
 /// Options for the Sparsification pass.
 struct SparsificationOptions {
   SparsificationOptions(SparseParallelizationStrategy p,
                         SparseVectorizationStrategy v, unsigned vl, bool e,
                         bool vla, bool rt)
       : parallelizationStrategy(p), vectorizationStrategy(v), vectorLength(vl),

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

 //===- Passes.h - Pass Entrypoints ------------------------------*- C++ -*-===//
 //
 // 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_TENSOR_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
-#define GEN_PASS_DECL_TENSORBUFFERIZE
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
 
 /// Creates an instance of `tensor` dialect bufferization pass.
 std::unique_ptr<Pass> createTensorBufferizePass();
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//

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

 #define MLIR_DIALECT_TOSA_TRANSFORMS_PASSES_H
 
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace tosa {
 
-#define GEN_PASS_DECL_TOSALAYERWISECONSTANTFOLD
-#define GEN_PASS_DECL_TOSAINFERSHAPES
-#define GEN_PASS_DECL_TOSAMAKEBROADCASTABLE
-#define GEN_PASS_DECL_TOSAOPTIONALDECOMPOSITIONS
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
 
 // Expose Rewrite Functions that decompose TOSA Ops into further TOSA Ops.
 // The rewrites can be selectively added to a conversion pass.
 void populateTosaDecomposeConv2D(MLIRContext *ctx, RewritePatternSet &patterns);
 void populateTosaDecomposeTransposeConv(MLIRContext *ctx,
                                         RewritePatternSet &patterns);
 void populateTosaDecomposeDepthwise(MLIRContext *ctx,

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

 
 #include "mlir/Pass/Pass.h"
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace transform {
-#define GEN_PASS_DECL_CHECKUSESPASS
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
 
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
 } // namespace transform
 } // namespace mlir
 
 #endif // MLIR_DIALECT_TRANSFORM_TRANSFORMS_PASSES_H

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

 //===- Passes.h - Pass Entrypoints ------------------------------*- C++ -*-===//
 //
 // 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_VECTOR_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_VECTOR_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace vector {
-#define GEN_PASS_DECL_VECTORBUFFERIZE
+#define GEN_PASS_DECL
 #include "mlir/Dialect/Vector/Transforms/Passes.h.inc"
 
 /// Creates an instance of the `vector` dialect bufferization pass.
 std::unique_ptr<Pass> createVectorBufferizePass();
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Reducer/Passes.h

 //===- Passes.h - Reducer Pass Construction and Registration ----*- C++ -*-===//
 //
 // 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_REDUCER_PASSES_H
 #define MLIR_REDUCER_PASSES_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
-#define GEN_PASS_DECL_REDUCTIONTREE
-#define GEN_PASS_DECL_OPTREDUCTION
+#define GEN_PASS_DECL
 #include "mlir/Reducer/Passes.h.inc"
 
 std::unique_ptr<Pass> createReductionTreePass();
 
 std::unique_ptr<Pass> createOptReductionPass();
 
 /// Generate the code for registering reducer passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Reducer/Passes.h.inc"
 
 } // namespace mlir
 
 #endif // MLIR_REDUCER_PASSES_H