[mlir][Pass] Deprecate FunctionPass in favor of OperationPass<FuncOp

[rriddle]

Summary

The only benefit of FunctionPass is that it filters out function
declarations. This isn't enough to justify carrying it around, as we can
simplify filter out declarations when necessary within the pass. We can
also explore with better scheduling primitives to filter out declarations
at the pipeline level in the future.

The definition of FunctionPass is left intact for now to allow time for downstream
users to migrate.

[rriddle]

I did a scan of the majority of FunctionPasses. I couldn't find any (in the quick scan, but I will do a more thorough one before submitting) that actually depend on no-declarations, but a majority do work that is essentially wasted with declarations.

[mehdi_amini]

The main comment I have is the same as the other patch: we should try to migrate these passes to OperationPass<> as much as possible instead: most of them are unlikely to be dependent on FuncOp.

[rriddle]

In D117182#3239496, @mehdi_amini wrote:

The main comment I have is the same as the other patch: we should try to migrate these passes to OperationPass<> as much as possible instead: most of them are unlikely to be dependent on FuncOp.

Yes, I have an intention to try transitioning many of these to OperationPass<>. I refrained from doing that first, given that right now we already have some OperationPass<FuncOp> and some FunctionPass. My main goal right now is to kill FunctionPass, cleanup after its mess, and start evolving the pass infra in general.

[mehdi_amini]

OK, LGTM then :)

mlir/docs/Bufferization.md

 ```
 void mlir::populateTensorBufferizePatterns(
     BufferizeTypeConverter &typeConverter, RewritePatternSet &patterns) {
   patterns.add<BufferizeCastOp, BufferizeExtractOp>(typeConverter,
                                                     patterns.getContext());
 }
 
 struct TensorBufferizePass : public TensorBufferizeBase<TensorBufferizePass> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     auto *context = &getContext();
     BufferizeTypeConverter typeConverter;
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);
 
     populateTensorBufferizePatterns(typeConverter, patterns);
     target.addIllegalOp<tensor::CastOp, tensor::ExtractOp>();
     target.addLegalDialect<StandardOpsDialect>();
 
     if (failed(
-            applyPartialConversion(getFunction(), target, std::move(patterns))))
+            applyPartialConversion(getOperation(), target, std::move(patterns))))
       signalPassFailure();
   }
 };
 ```
 
 The pass has all the hallmarks of a dialect conversion pass that does type
 conversions: a `TypeConverter`, a `RewritePatternSet`, and a `ConversionTarget`,
 and a call to `applyPartialConversion`. Note that a function

mlir/docs/Rationale/Rationale.md

 parallel won't work (at least without some sort of synchronization on the use
 lists, which would be unbearably inefficient).
 
 MLIR now supports a multithreaded pass manager. We do this through several
 design choices:
 
 1.  MLIR makes use of extensive uniqued immutable data structures (affine
     expressions, types, etc are all immutable, uniqued, and immortal).
-2.  Constants are defined in per-function pools, instead of being globally
+2.  Constants are defined in per-operation pools, instead of being globally
     uniqued.
-3.  Functions themselves are not SSA values either, so they don't have the same
-    problem as constants.
-4.  FunctionPasses are copied (through their copy ctor) into one instance per
+3.  Functions, and other global-like operations, themselves are not SSA values
+    either, so they don't have the same problem as constants.
+4.  Passes are copied (through their copy ctor) into one instance per
     thread, avoiding sharing of local state across threads.
 
-This allows MLIR function passes to support efficient multithreaded compilation
+This allows MLIR passes to support efficient multithreaded compilation
 and code generation.

mlir/docs/Tutorials/Toy/Ch-4.md

 
 ```c++
 /// Infer the output shape of the MulOp, this is required by the shape inference
 /// interface.
 void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
 ```
 
 At this point, each of the necessary Toy operations provide a mechanism by which
-to infer their output shapes. The ShapeInferencePass is a FunctionPass: it will
-run on each Function in isolation. MLIR also supports general
-[OperationPasses](../../PassManagement.md/#operation-pass) that run on any isolated
-operation (i.e. other function-like operations), but here our module only
-contains functions, so there is no need to generalize to all operations.
+to infer their output shapes. The ShapeInferencePass will operate on functions:
+it will run on each Function in isolation. MLIR also supports general
+[OperationPasses](../../PassManagement.md#operation-pass) that run on any
+isolated operation (i.e. other function-like operations), but here our module
+only contains functions, so there is no need to generalize to all operations.
 
 Implementing such a pass is done by creating a class inheriting from
-`mlir::FunctionPass` and overriding the `runOnFunction()` method.
+`mlir::OperationPass<FuncOp>` and overriding the `runOnOperation()` method.
 
 ```c++
 class ShapeInferencePass
-    : public mlir::PassWrapper<ShapeInferencePass, FunctionPass> {
-  void runOnFunction() override {
-    FuncOp function = getFunction();
+    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<FuncOp>> {
+  void runOnOperation() override {
+    FuncOp function = getOperation();
     ...
   }
 };
 ```
 
 While at it, let's also create a helper method for instantiating the pass:
 
 ```c++

mlir/docs/Tutorials/Toy/Ch-5.md

 ## Conversion Target
 
 For our purposes, we want to convert the compute-intensive `Toy` operations into
 a combination of operations from the `Affine`, `MemRef` and `Standard` dialects
 for further optimization. To start off the lowering, we first define our
 conversion target:
 
 ```c++
-void ToyToAffineLoweringPass::runOnFunction() {
+void ToyToAffineLoweringPass::runOnOperation() {
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   mlir::ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine`, `Arithmetic`, `MemRef`, and `Standard` dialects.
   target.addLegalDialect<AffineDialect, arith::ArithmeticDialect,
matchAndRewrite(mlir::Operation *op, ArrayRef<mlir::Value> operands,
     return success();
   }
 };
 ```
 
 Now we can prepare the list of patterns to use during the lowering process:
 
 ```c++
-void ToyToAffineLoweringPass::runOnFunction() {
+void ToyToAffineLoweringPass::runOnOperation() {
   ...
 
   // Now that the conversion target has been defined, we just need to provide
   // the set of patterns that will lower the Toy operations.
   mlir::RewritePatternSet patterns(&getContext());
   patterns.add<..., TransposeOpLowering>(&getContext());
 
   ...
 ```
 
 ## Partial Lowering
 
 Once the patterns have been defined, we can perform the actual lowering. The
 `DialectConversion` framework provides several different modes of lowering, but,
 for our purposes, we will perform a partial lowering, as we will not convert
 `toy.print` at this time.
 
 ```c++
-void ToyToAffineLoweringPass::runOnFunction() {
+void ToyToAffineLoweringPass::runOnOperation() {
   ...
 
   // With the target and rewrite patterns defined, we can now attempt the
   // conversion. The conversion will signal failure if any of our *illegal*
   // operations were not converted successfully.
-  auto function = getFunction();
+  mlir::FuncOp function = getOperation();
   if (mlir::failed(mlir::applyPartialConversion(function, target, patterns)))
     signalPassFailure();
 }
 ```
 
 ### Design Considerations With Partial Lowering
 
 Before diving into the result of our lowering, this is a good time to discuss

mlir/examples/toy/Ch4/mlir/ShapeInferencePass.cpp

 
 using namespace mlir;
 using namespace toy;
 
 /// Include the auto-generated definitions for the shape inference interfaces.
 #include "toy/ShapeInferenceOpInterfaces.cpp.inc"
 
 namespace {
-/// The ShapeInferencePass is a FunctionPass that performs intra-procedural
+/// The ShapeInferencePass is a pass that performs intra-procedural
 /// shape inference.
 ///
 ///    Algorithm:
 ///
 ///   1) Build a worklist containing all the operations that return a
 ///      dynamically shaped tensor: these are the operations that need shape
 ///      inference.
 ///   2) Iterate on the worklist:
 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
 class ShapeInferencePass
-    : public mlir::PassWrapper<ShapeInferencePass, FunctionPass> {
+    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<FuncOp>> {
 public:
-  void runOnFunction() override {
-    auto f = getFunction();
+  void runOnOperation() override {
+    auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {
       if (returnsDynamicShape(op))
         opWorklist.insert(op);
     });

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

 // ToyToAffineLoweringPass
 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
-    : public PassWrapper<ToyToAffineLoweringPass, FunctionPass> {
+    : public PassWrapper<ToyToAffineLoweringPass, OperationPass<FuncOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, memref::MemRefDialect, StandardOpsDialect>();
   }
-  void runOnFunction() final;
+  void runOnOperation() final;
 };
 } // namespace
 
-void ToyToAffineLoweringPass::runOnFunction() {
-  auto function = getFunction();
+void ToyToAffineLoweringPass::runOnOperation() {
+  FuncOp function = getOperation();
 
   // We only lower the main function as we expect that all other functions have
   // been inlined.
   if (function.getName() != "main")
     return;
 
   // Verify that the given main has no inputs and results.
   if (function.getNumArguments() || function.getType().getNumResults()) {
void ToyToAffineLoweringPass::runOnOperation() {
   patterns.add<AddOpLowering, ConstantOpLowering, MulOpLowering,
                PrintOpLowering, ReturnOpLowering, TransposeOpLowering>(
       &getContext());
 
   // With the target and rewrite patterns defined, we can now attempt the
   // conversion. The conversion will signal failure if any of our `illegal`
   // operations were not converted successfully.
   if (failed(
-          applyPartialConversion(getFunction(), target, std::move(patterns))))
+          applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
 
 /// Create a pass for lowering operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<Pass> mlir::toy::createLowerToAffinePass() {
   return std::make_unique<ToyToAffineLoweringPass>();
 }

mlir/examples/toy/Ch5/mlir/ShapeInferencePass.cpp

 
 using namespace mlir;
 using namespace toy;
 
 /// Include the auto-generated definitions for the shape inference interfaces.
 #include "toy/ShapeInferenceOpInterfaces.cpp.inc"
 
 namespace {
-/// The ShapeInferencePass is a FunctionPass that performs intra-procedural
+/// The ShapeInferencePass is a pass that performs intra-procedural
 /// shape inference.
 ///
 ///    Algorithm:
 ///
 ///   1) Build a worklist containing all the operations that return a
 ///      dynamically shaped tensor: these are the operations that need shape
 ///      inference.
 ///   2) Iterate on the worklist:
 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
 class ShapeInferencePass
-    : public mlir::PassWrapper<ShapeInferencePass, FunctionPass> {
+    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<FuncOp>> {
 public:
-  void runOnFunction() override {
-    auto f = getFunction();
+  void runOnOperation() override {
+    auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {
       if (returnsDynamicShape(op))
         opWorklist.insert(op);
     });

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

 // ToyToAffineLoweringPass
 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
-    : public PassWrapper<ToyToAffineLoweringPass, FunctionPass> {
+    : public PassWrapper<ToyToAffineLoweringPass, OperationPass<FuncOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, memref::MemRefDialect, StandardOpsDialect>();
   }
-  void runOnFunction() final;
+  void runOnOperation() final;
 };
 } // namespace
 
-void ToyToAffineLoweringPass::runOnFunction() {
-  auto function = getFunction();
+void ToyToAffineLoweringPass::runOnOperation() {
+  auto function = getOperation();
 
   // We only lower the main function as we expect that all other functions have
   // been inlined.
   if (function.getName() != "main")
     return;
 
   // Verify that the given main has no inputs and results.
   if (function.getNumArguments() || function.getType().getNumResults()) {
void ToyToAffineLoweringPass::runOnOperation() {
   patterns.add<AddOpLowering, ConstantOpLowering, MulOpLowering,
                PrintOpLowering, ReturnOpLowering, TransposeOpLowering>(
       &getContext());
 
   // With the target and rewrite patterns defined, we can now attempt the
   // conversion. The conversion will signal failure if any of our `illegal`
   // operations were not converted successfully.
   if (failed(
-          applyPartialConversion(getFunction(), target, std::move(patterns))))
+          applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
 
 /// Create a pass for lowering operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<Pass> mlir::toy::createLowerToAffinePass() {
   return std::make_unique<ToyToAffineLoweringPass>();
 }

mlir/examples/toy/Ch6/mlir/ShapeInferencePass.cpp

 
 using namespace mlir;
 using namespace toy;
 
 /// Include the auto-generated definitions for the shape inference interfaces.
 #include "toy/ShapeInferenceOpInterfaces.cpp.inc"
 
 namespace {
-/// The ShapeInferencePass is a FunctionPass that performs intra-procedural
+/// The ShapeInferencePass is a pass that performs intra-procedural
 /// shape inference.
 ///
 ///    Algorithm:
 ///
 ///   1) Build a worklist containing all the operations that return a
 ///      dynamically shaped tensor: these are the operations that need shape
 ///      inference.
 ///   2) Iterate on the worklist:
 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
 class ShapeInferencePass
-    : public mlir::PassWrapper<ShapeInferencePass, FunctionPass> {
+    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<FuncOp>> {
 public:
-  void runOnFunction() override {
-    auto f = getFunction();
+  void runOnOperation() override {
+    auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {
       if (returnsDynamicShape(op))
         opWorklist.insert(op);
     });

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

 // ToyToAffineLoweringPass
 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
-    : public PassWrapper<ToyToAffineLoweringPass, FunctionPass> {
+    : public PassWrapper<ToyToAffineLoweringPass, OperationPass<FuncOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, memref::MemRefDialect, StandardOpsDialect>();
   }
-  void runOnFunction() final;
+  void runOnOperation() final;
 };
 } // namespace
 
-void ToyToAffineLoweringPass::runOnFunction() {
-  auto function = getFunction();
+void ToyToAffineLoweringPass::runOnOperation() {
+  auto function = getOperation();
 
   // We only lower the main function as we expect that all other functions have
   // been inlined.
   if (function.getName() != "main")
     return;
 
   // Verify that the given main has no inputs and results.
   if (function.getNumArguments() || function.getType().getNumResults()) {
void ToyToAffineLoweringPass::runOnOperation() {
   patterns.add<AddOpLowering, ConstantOpLowering, MulOpLowering,
                PrintOpLowering, ReturnOpLowering, TransposeOpLowering>(
       &getContext());
 
   // With the target and rewrite patterns defined, we can now attempt the
   // conversion. The conversion will signal failure if any of our `illegal`
   // operations were not converted successfully.
   if (failed(
-          applyPartialConversion(getFunction(), target, std::move(patterns))))
+          applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
 
 /// Create a pass for lowering operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<Pass> mlir::toy::createLowerToAffinePass() {
   return std::make_unique<ToyToAffineLoweringPass>();
 }

mlir/examples/toy/Ch7/mlir/ShapeInferencePass.cpp

 
 using namespace mlir;
 using namespace toy;
 
 /// Include the auto-generated definitions for the shape inference interfaces.
 #include "toy/ShapeInferenceOpInterfaces.cpp.inc"
 
 namespace {
-/// The ShapeInferencePass is a FunctionPass that performs intra-procedural
+/// The ShapeInferencePass is a pass that performs intra-procedural
 /// shape inference.
 ///
 ///    Algorithm:
 ///
 ///   1) Build a worklist containing all the operations that return a
 ///      dynamically shaped tensor: these are the operations that need shape
 ///      inference.
 ///   2) Iterate on the worklist:
 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
 class ShapeInferencePass
-    : public mlir::PassWrapper<ShapeInferencePass, FunctionPass> {
+    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<FuncOp>> {
 public:
-  void runOnFunction() override {
-    auto f = getFunction();
+  void runOnOperation() override {
+    auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {
       if (returnsDynamicShape(op))
         opWorklist.insert(op);
     });

mlir/include/mlir/Conversion/Passes.td

let dependentDialects = [
     "vector::VectorDialect"
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // ArithmeticToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertArithmeticToLLVM : FunctionPass<"convert-arith-to-llvm"> {
+def ConvertArithmeticToLLVM : Pass<"convert-arith-to-llvm", "FuncOp"> {
   let summary = "Convert Arithmetic dialect to LLVM dialect";
   let description = [{
     This pass converts supported Arithmetic ops to LLVM dialect instructions.
   }];
   let constructor = "mlir::arith::createConvertArithmeticToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
   let options = [
     Option<"indexBitwidth", "index-bitwidth", "unsigned",
            /*default=kDeriveIndexBitwidthFromDataLayout*/"0",
            "Bitwidth of the index type, 0 to use size of machine word">,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // ArithmeticToSPIRV
 //===----------------------------------------------------------------------===//
 
-def ConvertArithmeticToSPIRV : FunctionPass<"convert-arith-to-spirv"> {
+def ConvertArithmeticToSPIRV : Pass<"convert-arith-to-spirv", "FuncOp"> {
   let summary = "Convert Arithmetic dialect to SPIR-V dialect";
   let constructor = "mlir::arith::createConvertArithmeticToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
     Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
            "bool", /*default=*/"true",
            "Emulate non-32-bit scalar types with 32-bit ones if "
            "missing native support">
def ConvertComplexToLLVM : Pass<"convert-complex-to-llvm", "ModuleOp"> {
   let constructor = "mlir::createConvertComplexToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // ComplexToStandard
 //===----------------------------------------------------------------------===//
 
-def ConvertComplexToStandard : FunctionPass<"convert-complex-to-standard"> {
+def ConvertComplexToStandard : Pass<"convert-complex-to-standard", "FuncOp"> {
   let summary = "Convert Complex dialect to standard dialect";
   let constructor = "mlir::createConvertComplexToStandardPass()";
   let dependentDialects = ["math::MathDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // GPUCommon
 //===----------------------------------------------------------------------===//
let dependentDialects = [
     "vector::VectorDialect",
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // MathToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertMathToLLVM : FunctionPass<"convert-math-to-llvm"> {
+def ConvertMathToLLVM : Pass<"convert-math-to-llvm", "FuncOp"> {
   let summary = "Convert Math dialect to LLVM dialect";
   let description = [{
     This pass converts supported Math ops to LLVM dialect intrinsics.
   }];
   let constructor = "mlir::createConvertMathToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
def SCFToStandard : Pass<"convert-scf-to-std"> {
   let constructor = "mlir::createLowerToCFGPass()";
   let dependentDialects = ["StandardOpsDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // SCFToGPU
 //===----------------------------------------------------------------------===//
 
-def ConvertAffineForToGPU : FunctionPass<"convert-affine-for-to-gpu"> {
+def ConvertAffineForToGPU : Pass<"convert-affine-for-to-gpu", "FuncOp"> {
   let summary = "Convert top-level AffineFor Ops to GPU kernels";
   let constructor = "mlir::createAffineForToGPUPass()";
   let dependentDialects = ["gpu::GPUDialect"];
   let options = [
     Option<"numBlockDims", "gpu-block-dims", "unsigned", /*default=*/"1u",
            "Number of GPU block dimensions for mapping">,
     Option<"numThreadDims", "gpu-thread-dims", "unsigned", /*default=*/"1u",
            "Number of GPU thread dimensions for mapping">
Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
            "missing native support">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // TosaToLinalg
 //===----------------------------------------------------------------------===//
 
-def TosaToLinalg : FunctionPass<"tosa-to-linalg"> {
+def TosaToLinalg : Pass<"tosa-to-linalg", "FuncOp"> {
   let summary = "Lower TOSA to LinAlg on tensors";
   let description = [{
     Pass that converts TOSA operations to the equivalent operations using the
     tensor operations in LinAlg.
   }];
 
   let constructor = "tosa::createTosaToLinalg()";
 }
 
 //===----------------------------------------------------------------------===//
 // TosaToLinalgNamed
 //===----------------------------------------------------------------------===//
 
-def TosaToLinalgNamed : FunctionPass<"tosa-to-linalg-named"> {
+def TosaToLinalgNamed : Pass<"tosa-to-linalg-named", "FuncOp"> {
   let summary = "Lower TOSA to LinAlg named operations";
   let description = [{
     Pass that converts TOSA operations to the equivalent operations using the
     Linalg named operations.
   }];
 
   let constructor = "tosa::createTosaToLinalgNamed()";
 }
def TosaToStandard : Pass<"tosa-to-standard"> {
 
   let constructor = "tosa::createTosaToStandard()";
 }
 
 //===----------------------------------------------------------------------===//
 // VectorToGPU
 //===----------------------------------------------------------------------===//
 
-def ConvertVectorToGPU : FunctionPass<"convert-vector-to-gpu"> {
+def ConvertVectorToGPU : Pass<"convert-vector-to-gpu", "FuncOp"> {
   let summary = "Lower the operations from the vector dialect into the GPU "
                 "dialect";
   let constructor = "mlir::createConvertVectorToGPUPass()";
   let dependentDialects = [
     "memref::MemRefDialect",
     "gpu::GPUDialect"
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // VectorToSCF
 //===----------------------------------------------------------------------===//
 
-def ConvertVectorToSCF : FunctionPass<"convert-vector-to-scf"> {
+def ConvertVectorToSCF : Pass<"convert-vector-to-scf", "FuncOp"> {
   let summary = "Lower the operations from the vector dialect into the SCF "
                 "dialect";
   let constructor = "mlir::createConvertVectorToSCFPass()";
   let dependentDialects = [
     "AffineDialect",
     "memref::MemRefDialect",
     "scf::SCFDialect"
   ];

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

std::unique_ptr<OperationPass<FuncOp>> createAffineDataCopyGenerationPass(
     unsigned tagMemorySpace = 0, int minDmaTransferSize = 1024,
     uint64_t fastMemCapacityBytes = std::numeric_limits<uint64_t>::max());
 /// Overload relying on pass options for initialization.
 std::unique_ptr<OperationPass<FuncOp>> createAffineDataCopyGenerationPass();
 
 /// Creates a pass to replace affine memref accesses by scalars using store to
 /// load forwarding and redundant load elimination; consequently also eliminate
 /// dead allocs.
-std::unique_ptr<FunctionPass> createAffineScalarReplacementPass();
+std::unique_ptr<OperationPass<FuncOp>> createAffineScalarReplacementPass();
 
 /// Creates a pass to perform tiling on loop nests.
 std::unique_ptr<OperationPass<FuncOp>>
 createLoopTilingPass(uint64_t cacheSizeBytes);
 /// Overload relying on pass options for initialization.
 std::unique_ptr<OperationPass<FuncOp>> createLoopTilingPass();
 
 /// Creates a loop unrolling pass with the provided parameters.

mlir/include/mlir/Dialect/Affine/Passes.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_AFFINE_PASSES
 #define MLIR_DIALECT_AFFINE_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def AffineDataCopyGeneration : FunctionPass<"affine-data-copy-generate"> {
+def AffineDataCopyGeneration : Pass<"affine-data-copy-generate", "FuncOp"> {
   let summary = "Generate explicit copying for affine memory operations";
   let constructor = "mlir::createAffineDataCopyGenerationPass()";
   let dependentDialects = ["memref::MemRefDialect"];
   let options = [
     Option<"fastMemoryCapacity", "fast-mem-capacity", "uint64_t",
            /*default=*/"std::numeric_limits<uint64_t>::max()",
            "Set fast memory space capacity in KiB (default: unlimited)">,
     Option<"fastMemorySpace", "fast-mem-space", "unsigned",
Option<"skipNonUnitStrideLoops", "skip-non-unit-stride-loops", "bool",
                                 "choice depths for copy placement">,
     Option<"tagMemorySpace", "tag-mem-space", "unsigned",
            /*default=*/"0",
            "Tag memory space identifier for copy generation (default: 0)">,
   ];
 }
 
 def AffineLoopInvariantCodeMotion
-    : FunctionPass<"affine-loop-invariant-code-motion"> {
+    : Pass<"affine-loop-invariant-code-motion", "FuncOp"> {
   let summary = "Hoist loop invariant instructions outside of affine loops";
   let constructor = "mlir::createAffineLoopInvariantCodeMotionPass()";
 }
 
-def AffineLoopTiling : FunctionPass<"affine-loop-tile"> {
+def AffineLoopTiling : Pass<"affine-loop-tile", "FuncOp"> {
   let summary = "Tile affine loop nests";
   let constructor = "mlir::createLoopTilingPass()";
   let options = [
     Option<"cacheSizeInKiB", "cache-size", "uint64_t", /*default=*/"512",
            "Set size of cache to tile for in KiB">,
     Option<"separate", "separate", "bool", /*default=*/"",
            "Separate full and partial tiles">,
     Option<"tileSize", "tile-size", "unsigned", /*default=*/"",
            "Use this tile size for all loops">,
     ListOption<"tileSizes", "tile-sizes", "unsigned",
                "List of tile sizes for each perfect nest "
                "(overridden by -tile-size)",
                "llvm::cl::ZeroOrMore">,
   ];
 }
 
-def AffineLoopUnroll : FunctionPass<"affine-loop-unroll"> {
+def AffineLoopUnroll : Pass<"affine-loop-unroll", "FuncOp"> {
   let summary = "Unroll affine loops";
   let constructor = "mlir::createLoopUnrollPass()";
   let options = [
     Option<"unrollFactor", "unroll-factor", "unsigned", /*default=*/"4",
            "Use this unroll factor for all loops being unrolled">,
     Option<"unrollUpToFactor", "unroll-up-to-factor", "bool",
            /*default=*/"false", "Allow unrolling up to the factor specified">,
     Option<"unrollFull", "unroll-full", "bool", /*default=*/"false",
            "Fully unroll loops">,
     Option<"numRepetitions", "unroll-num-reps", "unsigned", /*default=*/"1",
            "Unroll innermost loops repeatedly this many times">,
     Option<"unrollFullThreshold", "unroll-full-threshold", "unsigned",
            /*default=*/"1",
            "Unroll all loops with trip count less than or equal to this">,
   ];
 }
 
-def AffineLoopUnrollAndJam : FunctionPass<"affine-loop-unroll-jam"> {
+def AffineLoopUnrollAndJam : Pass<"affine-loop-unroll-jam", "FuncOp"> {
   let summary = "Unroll and jam affine loops";
   let constructor = "mlir::createLoopUnrollAndJamPass()";
   let options = [
     Option<"unrollJamFactor", "unroll-jam-factor", "unsigned",
            /*default=*/"4",
            "Use this unroll jam factor for all loops (default 4)">,
   ];
 }
 
-def AffineScalarReplacement : FunctionPass<"affine-scalrep"> {
+def AffineScalarReplacement : Pass<"affine-scalrep", "FuncOp"> {
   let summary = "Replace affine memref acceses by scalars by forwarding stores "
                 "to loads and eliminating redundant loads";
   let description = [{
     This pass performs store to load forwarding and redundant load elimination
     for affine memref accesses and potentially eliminates the entire memref
     if all its accesses are forwarded.
 
     Input
module {
         return %0 : memref<10x10xf32>
       }
     }
     ```
   }];
   let constructor = "mlir::createAffineScalarReplacementPass()";
 }
 
-def AffineVectorize : FunctionPass<"affine-super-vectorize"> {
+def AffineVectorize : Pass<"affine-super-vectorize", "FuncOp"> {
   let summary = "Vectorize to a target independent n-D vector abstraction";
   let constructor = "mlir::createSuperVectorizePass()";
   let dependentDialects = ["vector::VectorDialect"];
   let options = [
     ListOption<"vectorSizes", "virtual-vector-size", "int64_t",
                "Specify an n-D virtual vector size for vectorization",
                "llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated">,
     // Optionally, the fixed mapping from loop to fastest varying MemRef
ListOption<"fastestVaryingPattern", "test-fastest-varying", "int64_t",
                "llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated">,
     Option<"vectorizeReductions", "vectorize-reductions", "bool",
            /*default=*/"false",
            "Vectorize known reductions expressed via iter_args. "
            "Switched off by default.">
   ];
 }
 
-def AffineParallelize : FunctionPass<"affine-parallelize"> {
+def AffineParallelize : Pass<"affine-parallelize", "FuncOp"> {
   let summary = "Convert affine.for ops into 1-D affine.parallel";
   let constructor = "mlir::createAffineParallelizePass()";
   let options = [
     Option<"maxNested", "max-nested", "unsigned", /*default=*/"-1u",
            "Maximum number of nested parallel loops to produce. "
            "Defaults to unlimited (UINT_MAX).">,
     Option<"parallelReductions", "parallel-reductions", "bool",
            /*default=*/"false",
            "Whether to parallelize reduction loops. Defaults to false.">
   ];
 }
 
-def AffineLoopNormalize : FunctionPass<"affine-loop-normalize"> {
+def AffineLoopNormalize : Pass<"affine-loop-normalize", "FuncOp"> {
   let summary = "Apply normalization transformations to affine loop-like ops";
   let constructor = "mlir::createAffineLoopNormalizePass()";
 }
 
-def SimplifyAffineStructures : FunctionPass<"simplify-affine-structures"> {
+def SimplifyAffineStructures : Pass<"simplify-affine-structures", "FuncOp"> {
   let summary = "Simplify affine expressions in maps/sets and normalize "
                 "memrefs";
   let constructor = "mlir::createSimplifyAffineStructuresPass()";
 }
 
 #endif // MLIR_DIALECT_AFFINE_PASSES

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

 //===-- Passes.td - Arithmetic 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_ARITHMETIC_TRANSFORMS_PASSES
 #define MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def ArithmeticBufferize : FunctionPass<"arith-bufferize"> {
+def ArithmeticBufferize : Pass<"arith-bufferize", "FuncOp"> {
   let summary = "Bufferize Arithmetic dialect ops.";
   let constructor = "mlir::arith::createArithmeticBufferizePass()";
   let dependentDialects = ["bufferization::BufferizationDialect",
                            "memref::MemRefDialect"];
 }
 
-def ArithmeticExpandOps : FunctionPass<"arith-expand"> {
+def ArithmeticExpandOps : Pass<"arith-expand", "FuncOp"> {
   let summary = "Legalize Arithmetic ops to be convertible to LLVM.";
   let constructor = "mlir::arith::createArithmeticExpandOpsPass()";
   let dependentDialects = ["StandardOpsDialect"];
 }
 
 #endif // MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES

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

 //===----------------------------------------------------------------------===//
 
 /// Creates an instance of the BufferDeallocation pass to free all allocated
 /// buffers.
 std::unique_ptr<Pass> createBufferDeallocationPass();
 
 /// Creates a pass that finalizes a partial bufferization by removing remaining
 /// bufferization.to_tensor and bufferization.to_memref operations.
-std::unique_ptr<FunctionPass> createFinalizingBufferizePass();
+std::unique_ptr<OperationPass<FuncOp>> createFinalizingBufferizePass();
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
 
 } // namespace bufferization
 } // namespace mlir
 
 #endif // MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES_H

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

 //===-- Passes.td - Bufferization passes 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_BUFFERIZATION_TRANSFORMS_PASSES
 #define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def BufferDeallocation : FunctionPass<"buffer-deallocation"> {
+def BufferDeallocation : Pass<"buffer-deallocation", "FuncOp"> {
   let summary = "Adds all required dealloc operations for all allocations in "
                 "the input program";
   let description = [{
     This pass implements an algorithm to automatically introduce all required
     deallocation operations for all buffers in the input program. This ensures
     that the resulting program does not have any memory leaks.
 
 
let description = [{
 
     }
     ```
 
   }];
   let constructor = "mlir::bufferization::createBufferDeallocationPass()";
 }
 
-def FinalizingBufferize : FunctionPass<"finalizing-bufferize"> {
+def FinalizingBufferize : Pass<"finalizing-bufferize", "FuncOp"> {
   let summary = "Finalize a partial bufferization";
   let description = [{
     A bufferize pass that finalizes a partial bufferization by removing
     remaining `bufferization.to_tensor` and `bufferization.to_buffer` operations.
 
     The removal of those operations is only possible if the operations only
     exist in pairs, i.e., all uses of `bufferization.to_tensor` operations are
     `bufferization.to_buffer` operations.
 
     This pass will fail if not all operations can be removed or if any operation
     with tensor typed operands remains.
   }];
   let constructor = "mlir::bufferization::createFinalizingBufferizePass()";
 }
 
 #endif // MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/GPU/Passes.td

 include "mlir/Pass/PassBase.td"
 
 def GpuKernelOutlining : Pass<"gpu-kernel-outlining", "ModuleOp"> {
   let summary = "Outline gpu.launch bodies to kernel functions";
   let constructor = "mlir::createGpuKernelOutliningPass()";
   let dependentDialects = ["mlir::DLTIDialect"];
 }
 
-def GpuAsyncRegionPass : FunctionPass<"gpu-async-region"> {
+def GpuAsyncRegionPass : Pass<"gpu-async-region", "FuncOp"> {
   let summary = "Make GPU ops async";
   let constructor = "mlir::createGpuAsyncRegionPass()";
   let dependentDialects = ["async::AsyncDialect"];
 }
 
 #endif // MLIR_DIALECT_GPU_PASSES

mlir/include/mlir/Dialect/Linalg/Passes.td

 
 def LinalgNamedOpConversion: Pass<"linalg-named-op-conversion"> {
   let summary = "Convert from one named linalg op to another.";
   let constructor = "mlir::createLinalgNamedOpConversionPass()";
   let dependentDialects = ["linalg::LinalgDialect", "tensor::TensorDialect"];
 }
 
 def LinalgLowerTiledLoopsToSCF
-    : FunctionPass<"convert-linalg-tiled-loops-to-scf"> {
+    : Pass<"convert-linalg-tiled-loops-to-scf", "FuncOp"> {
   let summary = "Lower linalg tiled loops to SCF loops and parallel loops";
   let constructor = "mlir::createConvertLinalgTiledLoopsToSCFPass()";
   let dependentDialects = [
     "linalg::LinalgDialect",
     "scf::SCFDialect",
     "AffineDialect"
   ];
 }
 
-def LinalgInlineScalarOperands : FunctionPass<"linalg-inline-scalar-operands"> {
+def LinalgInlineScalarOperands : Pass<"linalg-inline-scalar-operands", "FuncOp"> {
   let summary = "Inline scalar operands into linalg generic ops";
   let constructor = "mlir::createLinalgInlineScalarOperandsPass()";
   let dependentDialects = [
     "linalg::LinalgDialect"
   ];
 }
 
-def LinalgLowerToAffineLoops : FunctionPass<"convert-linalg-to-affine-loops"> {
+def LinalgLowerToAffineLoops : Pass<"convert-linalg-to-affine-loops", "FuncOp"> {
   let summary = "Lower the operations from the linalg dialect into affine "
                 "loops";
   let constructor = "mlir::createConvertLinalgToAffineLoopsPass()";
   let dependentDialects = [
     "AffineDialect", "linalg::LinalgDialect", "memref::MemRefDialect"];
 }
 
-def LinalgLowerToLoops : FunctionPass<"convert-linalg-to-loops"> {
+def LinalgLowerToLoops : Pass<"convert-linalg-to-loops", "FuncOp"> {
   let summary = "Lower the operations from the linalg dialect into loops";
   let constructor = "mlir::createConvertLinalgToLoopsPass()";
   let dependentDialects = [
     "linalg::LinalgDialect",
     "scf::SCFDialect",
     "AffineDialect"
   ];
 }
 
 def LinalgLowerToParallelLoops
-    : FunctionPass<"convert-linalg-to-parallel-loops"> {
+    : Pass<"convert-linalg-to-parallel-loops", "FuncOp"> {
   let summary = "Lower the operations from the linalg dialect into parallel "
                 "loops";
   let constructor = "mlir::createConvertLinalgToParallelLoopsPass()";
   let dependentDialects = [
     "AffineDialect",
     "linalg::LinalgDialect",
     "memref::MemRefDialect",
     "scf::SCFDialect"
   ];
 }
 
 def LinalgBufferize : Pass<"linalg-bufferize", "FuncOp"> {
   let summary = "Bufferize the linalg dialect";
   let constructor = "mlir::createLinalgBufferizePass()";
   let dependentDialects = [
     "AffineDialect",
     "bufferization::BufferizationDialect",
     "linalg::LinalgDialect",
     "memref::MemRefDialect",
   ];
 }
 
-def LinalgPromotion : FunctionPass<"linalg-promote-subviews"> {
+def LinalgPromotion : Pass<"linalg-promote-subviews", "FuncOp"> {
   let summary = "Promote subview ops to local buffers";
   let constructor = "mlir::createLinalgPromotionPass()";
   let options = [
     Option<"dynamicBuffers", "test-promote-dynamic", "bool",
            /*default=*/"false", "Test generation of dynamic promoted buffers">,
     Option<"useAlloca", "test-use-alloca", "bool",
            /*default=*/"false", "Test generation of alloca'ed buffers.">
   ];
   let dependentDialects = ["linalg::LinalgDialect"];
 }
 
-def LinalgTiling : FunctionPass<"linalg-tile"> {
+def LinalgTiling : Pass<"linalg-tile", "FuncOp"> {
   let summary = "Tile operations in the linalg dialect";
   let constructor = "mlir::createLinalgTilingPass()";
   let dependentDialects = [
     "AffineDialect",
     "linalg::LinalgDialect",
     "memref::MemRefDialect",
     "scf::SCFDialect"
   ];
   let options = [
     ListOption<"tileSizes", "tile-sizes", "int64_t", "Tile sizes",
                "llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated">,
     Option<"loopType", "loop-type", "std::string", /*default=*/"\"for\"",
            "Specify the type of loops to generate: for, parallel or "
            "tiled_loop">,
     ListOption<"distributionTypes", "distribution-types", "std::string",
                "DistributionTypes (if loop-type=tiled_loop)",
                "llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated">
 
   ];
 }
 
-def LinalgGeneralization : FunctionPass<"linalg-generalize-named-ops"> {
+def LinalgGeneralization : Pass<"linalg-generalize-named-ops", "FuncOp"> {
   let summary = "Convert named ops into generic ops";
   let constructor = "mlir::createLinalgGeneralizationPass()";
   let dependentDialects = ["linalg::LinalgDialect"];
 }
 
 def LinalgDetensorize : Pass<"linalg-detensorize", ""> {
   let summary = "Detensorize linalg ops";
   let constructor = "mlir::createLinalgDetensorizePass()";
let options = [
     Option<"aggressiveMode", "aggressive-mode", "bool", /*default=*/"false",
            "Detensorize all ops that qualify for detensoring along with branch"
            " operands and basic-block arguments.">
 
   ];
 }
 
 def LinalgStrategyTileAndFusePass
-    : FunctionPass<"linalg-strategy-tile-and-fuse-pass"> {
+    : Pass<"linalg-strategy-tile-and-fuse-pass", "FuncOp"> {
   let summary = "Configurable pass to apply pattern-based tiling and fusion.";
   let constructor = "mlir::createLinalgStrategyTileAndFusePass()";
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
     Option<"anchorOpName", "anchor-op", "std::string", /*default=*/"",
       "Which linalg op within the func is the anchor to latch on.">,
   ];
 }
 
 def LinalgStrategyTilePass
-    : FunctionPass<"linalg-strategy-tile-pass"> {
+    : Pass<"linalg-strategy-tile-pass", "FuncOp"> {
   let summary = "Configurable pass to apply pattern-based linalg tiling.";
   let constructor = "mlir::createLinalgStrategyTilePass()";
   let dependentDialects = ["linalg::LinalgDialect"];
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
     Option<"anchorOpName", "anchor-op", "std::string", /*default=*/"",
       "Which linalg op within the func is the anchor to latch on.">,
   ];
 }
 
 def LinalgStrategyPadPass
-    : FunctionPass<"linalg-strategy-pad-pass"> {
+    : Pass<"linalg-strategy-pad-pass", "FuncOp"> {
   let summary = "Configurable pass to apply padding and hoisting.";
   let constructor = "mlir::createLinalgStrategyPadPass()";
   let dependentDialects = ["linalg::LinalgDialect"];
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
     Option<"anchorOpName", "anchor-op", "std::string", /*default=*/"",
       "Which linalg op within the func is the anchor to latch on.">,
   ];
 }
 
 def LinalgStrategyPromotePass
-    : FunctionPass<"linalg-strategy-promote-pass"> {
+    : Pass<"linalg-strategy-promote-pass", "FuncOp"> {
   let summary = "Configurable pass to apply pattern-based linalg promotion.";
   let constructor = "mlir::createLinalgStrategyPromotePass()";
   let dependentDialects = ["linalg::LinalgDialect"];
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
     Option<"anchorOpName", "anchor-op", "std::string", /*default=*/"",
       "Which linalg op within the func is the anchor to latch on.">,
   ];
 }
 
 def LinalgStrategyGeneralizePass
-    : FunctionPass<"linalg-strategy-generalize-pass"> {
+    : Pass<"linalg-strategy-generalize-pass", "FuncOp"> {
   let summary = "Configurable pass to apply pattern-based generalization.";
   let constructor = "mlir::createLinalgStrategyGeneralizePass()";
   let dependentDialects = ["linalg::LinalgDialect"];
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
     Option<"anchorOpName", "anchor-op", "std::string", /*default=*/"",
       "Which linalg op within the func is the anchor to latch on.">,
   ];
 }
 
 // TODO: if/when we need finer control add an anchorOp option.
 def LinalgStrategyDecomposePass
-    : FunctionPass<"linalg-strategy-decompose-pass"> {
+    : Pass<"linalg-strategy-decompose-pass", "FuncOp"> {
   let summary = "Configurable pass to apply pattern-based generalization.";
   let constructor = "mlir::createLinalgStrategyDecomposePass()";
   let dependentDialects = ["linalg::LinalgDialect"];
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
   ];
 }
 
 def LinalgStrategyInterchangePass
-    : FunctionPass<"linalg-strategy-interchange-pass"> {
+    : Pass<"linalg-strategy-interchange-pass", "FuncOp"> {
   let summary = "Configurable pass to apply pattern-based iterator interchange.";
   let constructor = "mlir::createLinalgStrategyInterchangePass()";
   let dependentDialects = ["linalg::LinalgDialect"];
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
   ];
 }
 
 def LinalgStrategyVectorizePass
-    : FunctionPass<"linalg-strategy-vectorize-pass"> {
+    : Pass<"linalg-strategy-vectorize-pass", "FuncOp"> {
   let summary = "Configurable pass to apply pattern-based linalg vectorization.";
   let constructor = "mlir::createLinalgStrategyVectorizePass()";
   let dependentDialects = ["linalg::LinalgDialect"];
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
     Option<"anchorOpName", "anchor-op", "std::string", /*default=*/"",
       "Which linalg op within the func is the anchor to latch on.">,
     Option<"vectorizePadding", "vectorize-padding", "bool", "false",
       "Enable vectorization of padding ops.">,
   ];
 }
 
 def LinalgStrategyEnablePass
-    : FunctionPass<"linalg-strategy-enable-pass"> {
+    : Pass<"linalg-strategy-enable-pass", "FuncOp"> {
   let summary = "Configurable pass to enable the application of other "
     "pattern-based linalg passes.";
   let constructor = "mlir::createLinalgStrategyEnablePass()";
   let dependentDialects = ["linalg::LinalgDialect"];
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
   ];
 }
 
 def LinalgStrategyLowerVectorsPass
-    : FunctionPass<"linalg-strategy-lower-vectors-pass"> {
+    : Pass<"linalg-strategy-lower-vectors-pass", "FuncOp"> {
   let summary = "Configurable pass to lower vector operations.";
   let constructor = "mlir::createLinalgStrategyLowerVectorsPass()";
   let dependentDialects = ["linalg::LinalgDialect"];
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
   ];
 }
 
 def LinalgStrategyRemoveMarkersPass
-    : FunctionPass<"linalg-strategy-remove-markers-pass"> {
+    : Pass<"linalg-strategy-remove-markers-pass", "FuncOp"> {
   let summary = "Cleanup pass that drops markers.";
   let constructor = "mlir::createLinalgStrategyRemoveMarkersPass()";
   let dependentDialects = ["linalg::LinalgDialect"];
   let options = [
     Option<"anchorFuncName", "anchor-func", "std::string", /*default=*/"",
       "Which func op is the anchor to latch on.">,
   ];
 }
 
 #endif // MLIR_DIALECT_LINALG_PASSES

mlir/include/mlir/Dialect/Quant/Passes.td

 //===-- Passes.td - Quant 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_QUANT_PASSES
 #define MLIR_DIALECT_QUANT_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def QuantConvertConst : FunctionPass<"quant-convert-const"> {
+def QuantConvertConst : Pass<"quant-convert-const", "FuncOp"> {
   let summary = "Converts constants followed by qbarrier to actual quantized "
                 "values";
   let constructor = "mlir::quant::createConvertConstPass()";
 }
 
 def QuantConvertSimulatedQuant
-    : FunctionPass<"quant-convert-simulated-quantization"> {
+    : Pass<"quant-convert-simulated-quantization", "FuncOp"> {
   let summary = "Converts training-time simulated quantization ops to "
                 "corresponding quantize/dequantize casts";
   let constructor = "mlir::quant::createConvertSimulatedQuantPass()";
 }
 
 #endif // MLIR_DIALECT_QUANT_PASSES

mlir/include/mlir/Dialect/SCF/Passes.td

 //===-- Passes.td - SCF 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_SCF_PASSES
 #define MLIR_DIALECT_SCF_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def SCFBufferize : FunctionPass<"scf-bufferize"> {
+def SCFBufferize : Pass<"scf-bufferize", "FuncOp"> {
   let summary = "Bufferize the scf dialect.";
   let constructor = "mlir::createSCFBufferizePass()";
   let dependentDialects = ["bufferization::BufferizationDialect",
                            "memref::MemRefDialect"];
 }
 
 // Note: Making these canonicalization patterns would require a dependency
 // of the SCF dialect on the Affine/Tensor/MemRef dialects or vice versa.
 def SCFForLoopCanonicalization
-    : FunctionPass<"for-loop-canonicalization"> {
+    : Pass<"for-loop-canonicalization", "FuncOp"> {
   let summary = "Canonicalize operations within scf.for loop bodies";
   let constructor = "mlir::createSCFForLoopCanonicalizationPass()";
   let dependentDialects = ["AffineDialect", "tensor::TensorDialect",
                            "memref::MemRefDialect"];
 }
 
 def SCFForLoopPeeling
-    : FunctionPass<"for-loop-peeling"> {
+    : Pass<"for-loop-peeling", "FuncOp"> {
   let summary = "Peel `for` loops at their upper bounds.";
   let constructor = "mlir::createForLoopPeelingPass()";
   let options = [
     Option<"skipPartial", "skip-partial", "bool",
            /*default=*/"true",
            "Do not peel loops inside of the last, partial iteration of another "
            "already peeled loop.">
   ];
   let dependentDialects = ["AffineDialect"];
 }
 
 def SCFForLoopSpecialization
-    : FunctionPass<"for-loop-specialization"> {
+    : Pass<"for-loop-specialization", "FuncOp"> {
   let summary = "Specialize `for` loops for vectorization";
   let constructor = "mlir::createForLoopSpecializationPass()";
 }
 
 def SCFParallelLoopFusion : Pass<"parallel-loop-fusion"> {
   let summary = "Fuse adjacent parallel loops";
   let constructor = "mlir::createParallelLoopFusionPass()";
 }
 
 def SCFParallelLoopSpecialization
-    : FunctionPass<"parallel-loop-specialization"> {
+    : Pass<"parallel-loop-specialization", "FuncOp"> {
   let summary = "Specialize parallel loops for vectorization";
   let constructor = "mlir::createParallelLoopSpecializationPass()";
 }
 
-def SCFParallelLoopTiling : FunctionPass<"parallel-loop-tiling"> {
+def SCFParallelLoopTiling : Pass<"parallel-loop-tiling", "FuncOp"> {
   let summary = "Tile parallel loops";
   let constructor = "mlir::createParallelLoopTilingPass()";
   let options = [
     ListOption<"tileSizes", "parallel-loop-tile-sizes", "int64_t",
                "Factors to tile parallel loops by",
                "llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated">,
     Option<"noMinMaxBounds", "no-min-max-bounds", "bool",
            /*default=*/"false",
            "Perform tiling with fixed upper bound with inbound check "
            "inside the internal loops">
   ];
   let dependentDialects = ["AffineDialect"];
 }
 
 def SCFForLoopRangeFolding
     : Pass<"for-loop-range-folding"> {
   let summary = "Fold add/mul ops into loop range";
   let constructor = "mlir::createForLoopRangeFoldingPass()";
 }
 
 def SCFForToWhileLoop
-    : FunctionPass<"scf-for-to-while"> {
+    : Pass<"scf-for-to-while", "FuncOp"> {
   let summary = "Convert SCF for loops to SCF while loops";
   let constructor = "mlir::createForToWhileLoopPass()";
   let description = [{
     This pass transforms SCF.ForOp operations to SCF.WhileOp. The For loop
     condition is placed in the 'before' region of the while operation, and the
     induction variable incrementation and loop body in the 'after' region.
     The loop carried values of the while op are the induction variable (IV) of
     the for-loop + any iter_args specified for the for-loop.

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

 
 // Collects a set of patterns to replace all constraints with passing witnesses.
 // This is intended to then allow all ShapeConstraint related ops and data to
 // have no effects and allow them to be freely removed such as through
 // canonicalization and dead code elimination.
 //
 // After this pass, no cstr_ operations exist.
 void populateRemoveShapeConstraintsPatterns(RewritePatternSet &patterns);
-std::unique_ptr<FunctionPass> createRemoveShapeConstraintsPass();
+std::unique_ptr<OperationPass<FuncOp>> createRemoveShapeConstraintsPass();
 
 /// Populates patterns for shape dialect structural type conversions and sets up
 /// the provided ConversionTarget with the appropriate legality configuration
 /// for the ops to get converted properly.
 ///
 /// A "structural" type conversion is one where the underlying ops are
 /// completely agnostic to the actual types involved and simply need to update
 /// their types consistently. An example of this is shape.assuming -- the
 /// shape.assuming op and the corresponding shape.assuming_yield op need to have
 /// consistent types, but the exact types don't matter. So all that we need to
 /// do for a structural type conversion is to update both of their types
 /// consistently to the new types prescribed by the TypeConverter.
 void populateShapeStructuralTypeConversionsAndLegality(
     TypeConverter &typeConverter, RewritePatternSet &patterns,
     ConversionTarget &target);
 
 // Bufferizes shape dialect ops.
 //
 // Note that most shape dialect ops must be converted to std before
 // bufferization happens, as they are intended to be bufferized at the std
 // level.
-std::unique_ptr<FunctionPass> createShapeBufferizePass();
+std::unique_ptr<OperationPass<FuncOp>> createShapeBufferizePass();
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES_H_

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

 //===-- Passes.td - ShapeOps 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_SHAPE_TRANSFORMS_PASSES
 #define MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def RemoveShapeConstraints : FunctionPass<"remove-shape-constraints"> {
+def RemoveShapeConstraints : Pass<"remove-shape-constraints", "FuncOp"> {
   let summary = "Replace all cstr_ ops with a true witness";
   let constructor = "mlir::createRemoveShapeConstraintsPass()";
 }
 
-def ShapeToShapeLowering : FunctionPass<"shape-to-shape-lowering"> {
+def ShapeToShapeLowering : Pass<"shape-to-shape-lowering", "FuncOp"> {
   let summary = "Legalize Shape dialect to be convertible to Standard";
   let constructor = "mlir::createShapeToShapeLowering()";
 }
 
 // TODO: Generalize this to allow any type conversions desired.
-def ShapeBufferize : FunctionPass<"shape-bufferize"> {
+def ShapeBufferize : Pass<"shape-bufferize", "FuncOp"> {
   let summary = "Bufferize the shape dialect.";
   let constructor = "mlir::createShapeBufferizePass()";
   let dependentDialects = ["bufferization::BufferizationDialect",
                            "memref::MemRefDialect"];
 }
 #endif // MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES

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

 //===-- Passes.td - StandardOps 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_STANDARD_TRANSFORMS_PASSES
 #define MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def StdBufferize : FunctionPass<"std-bufferize"> {
+def StdBufferize : Pass<"std-bufferize", "FuncOp"> {
   let summary = "Bufferize the std dialect";
   let constructor = "mlir::createStdBufferizePass()";
   let dependentDialects = ["bufferization::BufferizationDialect",
                            "memref::MemRefDialect", "scf::SCFDialect"];
 }
 
-def StdExpandOps : FunctionPass<"std-expand"> {
+def StdExpandOps : Pass<"std-expand", "FuncOp"> {
   let summary = "Legalize std operations to be convertible to LLVM.";
   let constructor = "mlir::createStdExpandOpsPass()";
 }
 
 def FuncBufferize : Pass<"func-bufferize", "ModuleOp"> {
   let summary = "Bufferize func/call/return ops";
   let description = [{
     A bufferize pass that bufferizes std.func and std.call ops.

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

 //===-- Passes.td - 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_TENSOR_TRANSFORMS_PASSES
 #define MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def TensorBufferize : FunctionPass<"tensor-bufferize"> {
+def TensorBufferize : Pass<"tensor-bufferize", "FuncOp"> {
   let summary = "Bufferize the `tensor` dialect";
   let constructor = "mlir::createTensorBufferizePass()";
   let dependentDialects = [
     "bufferization::BufferizationDialect",
     "memref::MemRefDialect",
     "scf::SCFDialect"
   ];
 }
 
 #endif // MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_TOSA_TRANSFORMS_PASSES
 #define MLIR_DIALECT_TOSA_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def TosaInferShapes : FunctionPass<"tosa-infer-shapes"> {
+def TosaInferShapes : Pass<"tosa-infer-shapes", "FuncOp"> {
   let summary = "Propagate shapes across TOSA operations";
   let description = [{
     Pass that uses operand types and propagates shapes to TOSA operations.
     This includes legalizing rankless and dynamic shapes towards static.
   }];
 
   let constructor = "createTosaInferShapesPass()";
   let dependentDialects = [
     "StandardOpsDialect",
     "tensor::TensorDialect",
     "tosa::TosaDialect",
   ];
 }
 
-def TosaMakeBroadcastable : FunctionPass<"tosa-make-broadcastable"> {
+def TosaMakeBroadcastable : Pass<"tosa-make-broadcastable", "FuncOp"> {
   let summary = "TOSA rank Reshape to enable Broadcasting";
   let description = [{
     Pass that enables broadcast by making all input arrays have the same
     number of dimensions. Insert RESHAPE operations to prepend dimensions
     of size one until the number of dimensions is equal. Implements
     approach similar to step 1 of Numpy 4-step broadcasting:
     https://numpy.org/doc/stable/reference/ufuncs.html#broadcasting
   }];
 
   let constructor = "createTosaMakeBroadcastablePass()";
 }
 
-def TosaOptionalDecompositions : FunctionPass<"tosa-optional-decompositions"> {
+def TosaOptionalDecompositions
+  : Pass<"tosa-optional-decompositions", "FuncOp"> {
   let summary = "Applies Tosa operations optional decompositions";
   let description = [{
     Pass to apply the Tosa operations decompositions 
     exposed as populate functions in include/mlir/Dialect/Tosa/Transforms/Passes.h
   }];
 
   let constructor = "tosa::createTosaOptionalDecompositions()";
 }
 
 #endif // MLIR_DIALECT_TOSA_TRANSFORMS_PASSES

mlir/include/mlir/Pass/Pass.h

protected:
   Pass(const Pass &other) : Pass(other.passID, other.opName) {}
 
   /// Returns the current pass state.
   detail::PassExecutionState &getPassState() {
     assert(passState && "pass state was never initialized");
     return *passState;
   }
 
-  /// Return the MLIR context for the current function being transformed.
+  /// Return the MLIR context for the current operation being transformed.
   MLIRContext &getContext() { return *getOperation()->getContext(); }
 
   /// The polymorphic API that runs the pass over the currently held operation.
   virtual void runOnOperation() = 0;
 
   /// Initialize any complex state necessary for running this pass. This hook
   /// should not rely on any state accessible during the execution of a pass.
   /// For example, `getContext`/`getOperation`/`getAnalysis`/etc. should not be

 /// Pass to transform an operation of a specific type.
 ///
 /// Operation passes must not:
 ///   - modify any other operations within the parent region, as other threads
 ///     may be manipulating them concurrently.
 ///   - modify any state within the parent operation, this includes adding
 ///     additional operations.
 ///
-/// Derived function passes are expected to provide the following:
+/// Derived operation passes are expected to provide the following:
 ///   - A 'void runOnOperation()' method.
 ///   - A 'StringRef getName() const' method.
 ///   - A 'std::unique_ptr<Pass> clonePass() const' method.
 template <typename OpT = void> class OperationPass : public Pass {
 protected:
   OperationPass(TypeID passID) : Pass(passID, OpT::getOperationName()) {}
   OperationPass(const OperationPass &) = default;
 

 /// Pass to transform an operation.
 ///
 /// Operation passes must not:
 ///   - modify any other operations within the parent region, as other threads
 ///     may be manipulating them concurrently.
 ///   - modify any state within the parent operation, this includes adding
 ///     additional operations.
 ///
-/// Derived function passes are expected to provide the following:
+/// Derived operation passes are expected to provide the following:
 ///   - A 'void runOnOperation()' method.
 ///   - A 'StringRef getName() const' method.
 ///   - A 'std::unique_ptr<Pass> clonePass() const' method.
 template <> class OperationPass<void> : public Pass {
 protected:
   OperationPass(TypeID passID) : Pass(passID) {}
   OperationPass(const OperationPass &) = default;
 };
 
+/// NOTICE: This class is deprecated in favor of `OperationPass<FuncOp>`
+/// and will be removed soon.
 /// A model for providing function pass specific utilities.
 ///
 /// Derived function passes are expected to provide the following:
 ///   - A 'void runOnFunction()' method.
 ///   - A 'StringRef getName() const' method.
 ///   - A 'std::unique_ptr<Pass> clonePass() const' method.
 class FunctionPass : public OperationPass<FuncOp> {
 public:

mlir/include/mlir/Pass/PassBase.td

class PassBase<string passArg, string base> {
   // A set of statistics provided by this pass.
   list<Statistic> statistics = [];
 }
 
 // This class represents an mlir::OperationPass.
 class Pass<string passArg, string operation = "">
   : PassBase<passArg, "::mlir::OperationPass<" # operation # ">">;
 
+/// NOTICE: This class is deprecated in favor of `Pass<..., "mlir::FuncOp">`
+/// and will be removed soon.
 // This class represents an mlir::FunctionPass.
 class FunctionPass<string passArg> : PassBase<passArg, "::mlir::FunctionPass">;
 
 #endif // MLIR_PASS_PASSBASE

mlir/include/mlir/Transforms/Passes.td

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TRANSFORMS_PASSES
 #define MLIR_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 include "mlir/Rewrite/PassUtil.td"
 
-def AffineLoopFusion : FunctionPass<"affine-loop-fusion"> {
+def AffineLoopFusion : Pass<"affine-loop-fusion", "FuncOp"> {
   let summary = "Fuse affine loop nests";
   let description = [{
     This pass performs fusion of loop nests using a slicing-based approach. It
     combines two fusion strategies: producer-consumer fusion and sibling fusion.
     Producer-consumer fusion is aimed at fusing pairs of loops where the first
     one writes to a memref that the second reads. Sibling fusion targets pairs
     of loops that share no dependences between them but that load from the same
     memref. The fused loop nests, when possible, are rewritten to access
Option<"affineFusionMode", "mode", "enum FusionMode",
            "\"producer\", \"Perform only producer-consumer fusion\"), "
            "clEnumValN( mlir::FusionMode::Sibling, "
            "\"sibling\", \"Perform only sibling fusion\"))">,
     ];
   let dependentDialects = ["memref::MemRefDialect"];
 }
 
 def AffinePipelineDataTransfer
-    : FunctionPass<"affine-pipeline-data-transfer"> {
+    : Pass<"affine-pipeline-data-transfer", "FuncOp"> {
   let summary = "Pipeline non-blocking data transfers between explicitly "
                 "managed levels of the memory hierarchy";
   let description = [{
     This pass performs a transformation to overlap non-blocking DMA operations
     in a loop with computations through double buffering. This is achieved by
     advancing dma_start operations with respect to other operations.
 
     Input
module {
         return
       }
     }
     ```
   }];
   let constructor = "mlir::createPipelineDataTransferPass()";
 }
 
-def BufferHoisting : FunctionPass<"buffer-hoisting"> {
+def BufferHoisting : Pass<"buffer-hoisting", "FuncOp"> {
   let summary = "Optimizes placement of allocation operations by moving them "
                 "into common dominators and out of nested regions";
   let description = [{
     This pass implements an approach to aggressively move allocations upwards
     into common dominators and out of nested regions.
   }];
   let constructor = "mlir::createBufferHoistingPass()";
 }
 
-def BufferLoopHoisting : FunctionPass<"buffer-loop-hoisting"> {
+def BufferLoopHoisting : Pass<"buffer-loop-hoisting", "FuncOp"> {
   let summary = "Optimizes placement of allocation operations by moving them "
                 "out of loop nests";
   let description = [{
     This pass implements an approach to aggressively move allocations upwards
     out of loop nests. It does not move allocations into common dominators.
   }];
   let constructor = "mlir::createBufferLoopHoistingPass()";
 }
 
-def PromoteBuffersToStack : FunctionPass<"promote-buffers-to-stack"> {
+def PromoteBuffersToStack : Pass<"promote-buffers-to-stack", "FuncOp"> {
   let summary = "Promotes heap-based allocations to automatically managed "
                 "stack-based allocations";
   let description = [{
     This pass implements a simple algorithm to convert heap-based memory
     allocations to stack-based ones. It uses a built-in heuristic to decide
     whether it makes sense to convert an allocation. Furthermore, dynamic
     shaped buffers that are limited by the rank of the tensor can be
     converted. They are only transformed if they are considered to be small.
let options = [
     Option<"fileName", "filename", "std::string", /*default=*/"",
            "The filename to print the generated IR">,
     Option<"tag", "tag", "std::string", /*default=*/"",
            "A tag to use when fusing the new locations with the "
            "original. If unset, the locations are replaced.">,
   ];
 }
 
-def LoopCoalescing : FunctionPass<"loop-coalescing"> {
+def LoopCoalescing : Pass<"loop-coalescing", "FuncOp"> {
   let summary = "Coalesce nested loops with independent bounds into a single "
                 "loop";
   let constructor = "mlir::createLoopCoalescingPass()";
   let dependentDialects = ["arith::ArithmeticDialect"];
 }
 
 def LoopInvariantCodeMotion : Pass<"loop-invariant-code-motion"> {
   let summary = "Hoist loop invariant instructions outside of the loop";

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

 // Pass Definition
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ConvertArithmeticToLLVMPass
     : public ConvertArithmeticToLLVMBase<ConvertArithmeticToLLVMPass> {
   ConvertArithmeticToLLVMPass() = default;
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     LLVMConversionTarget target(getContext());
     RewritePatternSet patterns(&getContext());
 
     LowerToLLVMOptions options(&getContext());
     if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
       options.overrideIndexBitwidth(indexBitwidth);
 
     LLVMTypeConverter converter(&getContext(), options);
     mlir::arith::populateArithmeticToLLVMConversionPatterns(converter,
                                                             patterns);
 
-    if (failed(
-            applyPartialConversion(getFunction(), target, std::move(patterns))))
+    if (failed(applyPartialConversion(getOperation(), target,
+                                      std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Pattern Population
 //===----------------------------------------------------------------------===//

mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp

 
 //===----------------------------------------------------------------------===//
 // Pass Definition
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ConvertArithmeticToSPIRVPass
     : public ConvertArithmeticToSPIRVBase<ConvertArithmeticToSPIRVPass> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     auto module = getOperation()->getParentOfType<ModuleOp>();
     auto targetAttr = spirv::lookupTargetEnvOrDefault(module);
     auto target = SPIRVConversionTarget::get(targetAttr);
 
     SPIRVTypeConverter::Options options;
     options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
     SPIRVTypeConverter typeConverter(targetAttr, options);
 

mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp

patterns.add<
       NegOpConversion,
       SignOpConversion>(patterns.getContext());
   // clang-format on
 }
 
 namespace {
 struct ConvertComplexToStandardPass
     : public ConvertComplexToStandardBase<ConvertComplexToStandardPass> {
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
-void ConvertComplexToStandardPass::runOnFunction() {
-  auto function = getFunction();
+void ConvertComplexToStandardPass::runOnOperation() {
+  auto function = getOperation();
 
   // Convert to the Standard dialect using the converter defined above.
   RewritePatternSet patterns(&getContext());
   populateComplexToStandardConversionPatterns(patterns);
 
   ConversionTarget target(getContext());
   target.addLegalDialect<arith::ArithmeticDialect, StandardOpsDialect,
                          math::MathDialect>();

mlir/lib/Conversion/MathToLLVM/MathToLLVM.cpp

return LLVM::detail::handleMultidimensionalVectors(
         rewriter);
   }
 };
 
 struct ConvertMathToLLVMPass
     : public ConvertMathToLLVMBase<ConvertMathToLLVMPass> {
   ConvertMathToLLVMPass() = default;
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     LLVMTypeConverter converter(&getContext());
     populateMathToLLVMConversionPatterns(converter, patterns);
     LLVMConversionTarget target(getContext());
-    if (failed(
-            applyPartialConversion(getFunction(), target, std::move(patterns))))
+    if (failed(applyPartialConversion(getOperation(), target,
+                                      std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 void mlir::populateMathToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                                 RewritePatternSet &patterns) {
   // clang-format off

mlir/lib/Conversion/SCFToGPU/SCFToGPUPass.cpp

 // walk the function recursively to avoid considering nested loops.
 struct ForLoopMapper : public ConvertAffineForToGPUBase<ForLoopMapper> {
   ForLoopMapper() = default;
   ForLoopMapper(unsigned numBlockDims, unsigned numThreadDims) {
     this->numBlockDims = numBlockDims;
     this->numThreadDims = numThreadDims;
   }
 
-  void runOnFunction() override {
-    for (Operation &op : llvm::make_early_inc_range(getFunction().getOps())) {
+  void runOnOperation() override {
+    for (Operation &op : llvm::make_early_inc_range(getOperation().getOps())) {
       if (auto forOp = dyn_cast<AffineForOp>(&op)) {
         if (failed(convertAffineLoopNestToGPULaunch(forOp, numBlockDims,
                                                     numThreadDims)))
           signalPassFailure();
       }
     }
   }
 };

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamedPass.cpp

 struct TosaToLinalgNamed : public TosaToLinalgNamedBase<TosaToLinalgNamed> {
 public:
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, linalg::LinalgDialect,
                     math::MathDialect, StandardOpsDialect,
                     tensor::TensorDialect, scf::SCFDialect>();
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
     target.addLegalDialect<linalg::LinalgDialect, StandardOpsDialect,
                            tosa::TosaDialect, tensor::TensorDialect,
                            scf::SCFDialect>();
 
     // Not every TOSA op can be legalized to linalg.
     target.addIllegalOp<tosa::Conv2DOp>();
     target.addIllegalOp<tosa::DepthwiseConv2DOp>();
     target.addIllegalOp<tosa::MaxPool2dOp>();
     target.addIllegalOp<tosa::AvgPool2dOp>();
     target.addIllegalOp<tosa::MatMulOp>();
     target.addIllegalOp<tosa::FullyConnectedOp>();
 
     target.markUnknownOpDynamicallyLegal([](Operation *) { return true; });
 
-    FuncOp func = getFunction();
+    FuncOp func = getOperation();
     mlir::tosa::populateTosaToLinalgNamedConversionPatterns(&patterns);
     if (failed(applyFullConversion(func, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::tosa::createTosaToLinalgNamed() {
   return std::make_unique<TosaToLinalgNamed>();
 }

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgPass.cpp

 struct TosaToLinalg : public TosaToLinalgBase<TosaToLinalg> {
 public:
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, linalg::LinalgDialect,
                     math::MathDialect, StandardOpsDialect,
                     tensor::TensorDialect, scf::SCFDialect>();
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
     target.addLegalDialect<linalg::LinalgDialect, StandardOpsDialect,
                            tensor::TensorDialect, scf::SCFDialect>();
     target.addIllegalDialect<tosa::TosaDialect>();
 
     // Not every TOSA op can be legalized to linalg.
     target.addLegalOp<tosa::ApplyScaleOp>();
     target.addLegalOp<tosa::IfOp>();
     target.addLegalOp<tosa::ConstOp>();
     target.addLegalOp<tosa::WhileOp>();
     target.addLegalOp<tosa::SliceOp>();
 
     target.markUnknownOpDynamicallyLegal([](Operation *) { return true; });
 
-    FuncOp func = getFunction();
+    FuncOp func = getOperation();
     mlir::tosa::populateTosaToLinalgConversionPatterns(&patterns);
     if (failed(applyFullConversion(func, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::tosa::createTosaToLinalg() {

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

void convertVectorToMMAOps(FuncOp funcOp) {
   }
 }
 
 } // namespace mlir
 namespace {
 
 struct ConvertVectorToGPUPass
     : public ConvertVectorToGPUBase<ConvertVectorToGPUPass> {
-  void runOnFunction() override {
-    RewritePatternSet patterns(getFunction().getContext());
+  void runOnOperation() override {
+    RewritePatternSet patterns(getOperation().getContext());
     populatePrepareVectorToMMAPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 
-    convertVectorToMMAOps(getFunction());
+    convertVectorToMMAOps(getOperation());
   }
 };
 
 } // namespace
 
 std::unique_ptr<Pass> mlir::createConvertVectorToGPUPass() {
   return std::make_unique<ConvertVectorToGPUPass>();
 }

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

struct ConvertVectorToSCFPass
   ConvertVectorToSCFPass() = default;
   ConvertVectorToSCFPass(const VectorTransferToSCFOptions &options) {
     this->fullUnroll = options.unroll;
     this->targetRank = options.targetRank;
     this->lowerPermutationMaps = options.lowerPermutationMaps;
     this->lowerTensors = options.lowerTensors;
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     VectorTransferToSCFOptions options;
     options.unroll = fullUnroll;
     options.targetRank = targetRank;
     options.lowerPermutationMaps = lowerPermutationMaps;
     options.lowerTensors = lowerTensors;
 
     // Lower permutation maps first.
     if (lowerPermutationMaps) {
-      RewritePatternSet lowerTransferPatterns(getFunction().getContext());
+      RewritePatternSet lowerTransferPatterns(getOperation().getContext());
       mlir::vector::populateVectorTransferPermutationMapLoweringPatterns(
           lowerTransferPatterns);
-      (void)applyPatternsAndFoldGreedily(getFunction(),
+      (void)applyPatternsAndFoldGreedily(getOperation(),
                                          std::move(lowerTransferPatterns));
     }
 
-    RewritePatternSet patterns(getFunction().getContext());
+    RewritePatternSet patterns(getOperation().getContext());
     populateVectorToSCFConversionPatterns(patterns, options);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 } // namespace
 
 std::unique_ptr<Pass>
 mlir::createConvertVectorToSCFPass(const VectorTransferToSCFOptions &options) {
   return std::make_unique<ConvertVectorToSCFPass>(options);
 }

mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp

explicit AffineDataCopyGeneration(unsigned slowMemorySpace,
                                     uint64_t fastMemCapacityBytes) {
     this->slowMemorySpace = slowMemorySpace;
     this->fastMemorySpace = fastMemorySpace;
     this->tagMemorySpace = tagMemorySpace;
     this->minDmaTransferSize = minDmaTransferSize;
     this->fastMemoryCapacity = fastMemCapacityBytes / 1024;
   }
 
-  void runOnFunction() override;
+  void runOnOperation() override;
   void runOnBlock(Block *block, DenseSet<Operation *> &copyNests);
 
   // Constant zero index to avoid too many duplicates.
   Value zeroIndex = nullptr;
 };
 
 } // namespace
 
assert(!curBegin->hasTrait<OpTrait::IsTerminator>() &&
            "can't be a terminator");
     // Exclude the affine.yield - hence, the std::prev.
     (void)affineDataCopyGenerate(/*begin=*/curBegin,
                                  /*end=*/std::prev(block->end()), copyOptions,
                                  /*filterMemRef=*/llvm::None, copyNests);
   }
 }
 
-void AffineDataCopyGeneration::runOnFunction() {
-  FuncOp f = getFunction();
+void AffineDataCopyGeneration::runOnOperation() {
+  FuncOp f = getOperation();
   OpBuilder topBuilder(f.getBody());
   zeroIndex = topBuilder.create<arith::ConstantIndexOp>(f.getLoc(), 0);
 
   // Nests that are copy-in's or copy-out's; the root AffineForOps of those
   // nests are stored herein.
   DenseSet<Operation *> copyNests;
 
   // Clear recorded copy nests.

mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp

 
 /// Loop invariant code motion (LICM) pass.
 /// TODO: The pass is missing zero-trip tests.
 /// TODO: Check for the presence of side effects before hoisting.
 /// TODO: This code should be removed once the new LICM pass can handle its
 ///       uses.
 struct LoopInvariantCodeMotion
     : public AffineLoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
-  void runOnFunction() override;
+  void runOnOperation() override;
   void runOnAffineForOp(AffineForOp forOp);
 };
 } // namespace
 
 static bool
 checkInvarianceOfNestedIfOps(Operation *op, Value indVar, ValueRange iterArgs,
                              SmallPtrSetImpl<Operation *> &opsWithUsers,
                              SmallPtrSetImpl<Operation *> &opsToHoist);
void LoopInvariantCodeMotion::runOnAffineForOp(AffineForOp forOp) {
   // right before the for loop.
   for (auto *op : opsToMove) {
     op->moveBefore(forOp);
   }
 
   LLVM_DEBUG(forOp->print(llvm::dbgs() << "Modified loop\n"));
 }
 
-void LoopInvariantCodeMotion::runOnFunction() {
+void LoopInvariantCodeMotion::runOnOperation() {
   // Walk through all loops in a function in innermost-loop-first order.  This
   // way, we first LICM from the inner loop, and place the ops in
   // the outer loop, which in turn can be further LICM'ed.
-  getFunction().walk([&](AffineForOp op) {
+  getOperation().walk([&](AffineForOp op) {
     LLVM_DEBUG(op->print(llvm::dbgs() << "\nOriginal loop\n"));
     runOnAffineForOp(op);
   });
 }
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createAffineLoopInvariantCodeMotionPass() {
   return std::make_unique<LoopInvariantCodeMotion>();
 }

mlir/lib/Dialect/Affine/Transforms/AffineLoopNormalize.cpp

 namespace {
 
 /// Normalize affine.parallel ops so that lower bounds are 0 and steps are 1.
 /// As currently implemented, this pass cannot fail, but it might skip over ops
 /// that are already in a normalized form.
 struct AffineLoopNormalizePass
     : public AffineLoopNormalizeBase<AffineLoopNormalizePass> {
 
-  void runOnFunction() override {
-    getFunction().walk([](Operation *op) {
+  void runOnOperation() override {
+    getOperation().walk([](Operation *op) {
       if (auto affineParallel = dyn_cast<AffineParallelOp>(op))
         normalizeAffineParallel(affineParallel);
       else if (auto affineFor = dyn_cast<AffineForOp>(op))
         normalizeAffineFor(affineFor);
     });
   }
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>> mlir::createAffineLoopNormalizePass() {
   return std::make_unique<AffineLoopNormalizePass>();
 }

mlir/lib/Dialect/Affine/Transforms/AffineParallelize.cpp

 
 #define DEBUG_TYPE "affine-parallel"
 
 using namespace mlir;
 
 namespace {
 /// Convert all parallel affine.for op into 1-D affine.parallel op.
 struct AffineParallelize : public AffineParallelizeBase<AffineParallelize> {
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
 /// Descriptor of a potentially parallelizable loop.
 struct ParallelizationCandidate {
   ParallelizationCandidate(AffineForOp l, SmallVector<LoopReduction> &&r)
       : loop(l), reductions(std::move(r)) {}
 
   /// The potentially parallelizable loop.
   AffineForOp loop;
   /// Desciprtors of reductions that can be parallelized in the loop.
   SmallVector<LoopReduction> reductions;
 };
 } // namespace
 
-void AffineParallelize::runOnFunction() {
-  FuncOp f = getFunction();
+void AffineParallelize::runOnOperation() {
+  FuncOp f = getOperation();
 
   // The walker proceeds in pre-order to process the outer loops first
   // and control the number of outer parallel loops.
   std::vector<ParallelizationCandidate> parallelizableLoops;
   f.walk<WalkOrder::PreOrder>([&](AffineForOp loop) {
     SmallVector<LoopReduction> reductions;
     if (isLoopParallel(loop, parallelReductions ? &reductions : nullptr))
       parallelizableLoops.emplace_back(loop, std::move(reductions));

mlir/lib/Dialect/Affine/Transforms/AffineScalarReplacement.cpp

 
 #define DEBUG_TYPE "affine-scalrep"
 
 using namespace mlir;
 
 namespace {
 struct AffineScalarReplacement
     : public AffineScalarReplacementBase<AffineScalarReplacement> {
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
 } // namespace
 
-std::unique_ptr<FunctionPass> mlir::createAffineScalarReplacementPass() {
+std::unique_ptr<OperationPass<FuncOp>>
+mlir::createAffineScalarReplacementPass() {
   return std::make_unique<AffineScalarReplacement>();
 }
 
-void AffineScalarReplacement::runOnFunction() {
-  affineScalarReplace(getFunction(), getAnalysis<DominanceInfo>(),
+void AffineScalarReplacement::runOnOperation() {
+  affineScalarReplace(getOperation(), getAnalysis<DominanceInfo>(),
                       getAnalysis<PostDominanceInfo>());
 }

mlir/lib/Dialect/Affine/Transforms/LoopTiling.cpp

 /// A pass to perform loop tiling on all suitable loop nests of a Function.
 struct LoopTiling : public AffineLoopTilingBase<LoopTiling> {
   LoopTiling() = default;
   explicit LoopTiling(uint64_t cacheSizeBytes, bool avoidMaxMinBounds = true)
       : avoidMaxMinBounds(avoidMaxMinBounds) {
     this->cacheSizeInKiB = cacheSizeBytes / 1024;
   }
 
-  void runOnFunction() override;
+  void runOnOperation() override;
   void getTileSizes(ArrayRef<AffineForOp> band,
                     SmallVectorImpl<unsigned> *tileSizes);
 
   // Default tile size if nothing is provided.
   constexpr static unsigned kDefaultTileSize = 4;
 
   // If true, tile sizes are set to avoid max/min in bounds if possible.
   bool avoidMaxMinBounds = true;
else
       (*tileSizes)[i] = std::max(
           1U, static_cast<unsigned>(excessFactor / cumulProductOfTileSizes));
     cumulProductOfTileSizes *= (*tileSizes)[i];
   }
   if (avoidMaxMinBounds)
     adjustToDivisorsOfTripCounts(band, tileSizes);
 }
 
-void LoopTiling::runOnFunction() {
+void LoopTiling::runOnOperation() {
   // Bands of loops to tile.
   std::vector<SmallVector<AffineForOp, 6>> bands;
-  getTileableBands(getFunction(), &bands);
+  getTileableBands(getOperation(), &bands);
 
   // Tile each band.
   for (auto &band : bands) {
     // Set up tile sizes; fill missing tile sizes at the end with default tile
     // size or tileSize if one was provided.
     SmallVector<unsigned, 6> tileSizes;
     getTileSizes(band, &tileSizes);
     if (llvm::DebugFlag) {

mlir/lib/Dialect/Affine/Transforms/LoopUnroll.cpp

explicit LoopUnroll(
       const std::function<unsigned(AffineForOp)> &getUnrollFactor = nullptr)
       : getUnrollFactor(getUnrollFactor) {
     if (unrollFactor)
       this->unrollFactor = *unrollFactor;
     this->unrollUpToFactor = unrollUpToFactor;
     this->unrollFull = unrollFull;
   }
 
-  void runOnFunction() override;
+  void runOnOperation() override;
 
   /// Unroll this for op. Returns failure if nothing was done.
   LogicalResult runOnAffineForOp(AffineForOp forOp);
 };
 } // namespace
 
 /// Returns true if no other affine.for ops are nested within.
 static bool isInnermostAffineForOp(AffineForOp forOp) {

 static void gatherInnermostLoops(FuncOp f,
                                  SmallVectorImpl<AffineForOp> &loops) {
   f.walk([&](AffineForOp forOp) {
     if (isInnermostAffineForOp(forOp))
       loops.push_back(forOp);
   });
 }
 
-void LoopUnroll::runOnFunction() {
+void LoopUnroll::runOnOperation() {
+  FuncOp func = getOperation();
+  if (func.isExternal())
+    return;
+
   if (unrollFull && unrollFullThreshold.hasValue()) {
     // Store short loops as we walk.
     SmallVector<AffineForOp, 4> loops;
 
     // Gathers all loops with trip count <= minTripCount. Do a post order walk
     // so that loops are gathered from innermost to outermost (or else unrolling
     // an outer one may delete gathered inner ones).
-    getFunction().walk([&](AffineForOp forOp) {
+    getOperation().walk([&](AffineForOp forOp) {
       Optional<uint64_t> tripCount = getConstantTripCount(forOp);
       if (tripCount.hasValue() && tripCount.getValue() <= unrollFullThreshold)
         loops.push_back(forOp);
     });
     for (auto forOp : loops)
       (void)loopUnrollFull(forOp);
     return;
   }
 
   // If the call back is provided, we will recurse until no loops are found.
-  FuncOp func = getFunction();
   SmallVector<AffineForOp, 4> loops;
   for (unsigned i = 0; i < numRepetitions || getUnrollFactor; i++) {
     loops.clear();
     gatherInnermostLoops(func, loops);
     if (loops.empty())
       break;
     bool unrolled = false;
     for (auto forOp : loops)

mlir/lib/Dialect/Affine/Transforms/LoopUnrollAndJam.cpp

 /// Loop unroll jam pass. Currently, this just unroll jams the first
 /// outer loop in a Function.
 struct LoopUnrollAndJam : public AffineLoopUnrollAndJamBase<LoopUnrollAndJam> {
   explicit LoopUnrollAndJam(Optional<unsigned> unrollJamFactor = None) {
     if (unrollJamFactor)
       this->unrollJamFactor = *unrollJamFactor;
   }
 
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createLoopUnrollAndJamPass(int unrollJamFactor) {
   return std::make_unique<LoopUnrollAndJam>(
       unrollJamFactor == -1 ? None : Optional<unsigned>(unrollJamFactor));
 }
 
-void LoopUnrollAndJam::runOnFunction() {
+void LoopUnrollAndJam::runOnOperation() {
+  if (getOperation().isExternal())
+    return;
+
   // Currently, just the outermost loop from the first loop nest is
   // unroll-and-jammed by this pass. However, runOnAffineForOp can be called on
   // any for operation.
-  auto &entryBlock = getFunction().front();
+  auto &entryBlock = getOperation().front();
   if (auto forOp = dyn_cast<AffineForOp>(entryBlock.front()))
     (void)loopUnrollJamByFactor(forOp, unrollJamFactor);
 }

mlir/lib/Dialect/Affine/Transforms/SimplifyAffineStructures.cpp

 namespace {
 
 /// Simplifies affine maps and sets appearing in the operations of the Function.
 /// This part is mainly to test the simplifyAffineExpr method. In addition,
 /// all memrefs with non-trivial layout maps are converted to ones with trivial
 /// identity layout ones.
 struct SimplifyAffineStructures
     : public SimplifyAffineStructuresBase<SimplifyAffineStructures> {
-  void runOnFunction() override;
+  void runOnOperation() override;
 
   /// Utility to simplify an affine attribute and update its entry in the parent
   /// operation if necessary.
   template <typename AttributeT>
   void simplifyAndUpdateAttribute(Operation *op, StringAttr name,
                                   AttributeT attr) {
     auto &simplified = simplifiedAttributes[attr];
     if (simplified == attr)

 
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createSimplifyAffineStructuresPass() {
   return std::make_unique<SimplifyAffineStructures>();
 }
 
-void SimplifyAffineStructures::runOnFunction() {
-  auto func = getFunction();
+void SimplifyAffineStructures::runOnOperation() {
+  auto func = getOperation();
   simplifiedAttributes.clear();
   RewritePatternSet patterns(func.getContext());
   AffineApplyOp::getCanonicalizationPatterns(patterns, func.getContext());
   AffineForOp::getCanonicalizationPatterns(patterns, func.getContext());
   AffineIfOp::getCanonicalizationPatterns(patterns, func.getContext());
   FrozenRewritePatternSet frozenPatterns(std::move(patterns));
 
   // The simplification of affine attributes will likely simplify the op. Try to

mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp

 
 namespace {
 
 /// Base state for the vectorize pass.
 /// Command line arguments are preempted by non-empty pass arguments.
 struct Vectorize : public AffineVectorizeBase<Vectorize> {
   Vectorize() = default;
   Vectorize(ArrayRef<int64_t> virtualVectorSize);
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
 } // namespace
 
 Vectorize::Vectorize(ArrayRef<int64_t> virtualVectorSize) {
   vectorSizes = virtualVectorSize;
 }
 
createSuperVectorizePass(ArrayRef<int64_t> virtualVectorSize) {
   return std::make_unique<Vectorize>(virtualVectorSize);
 }
 std::unique_ptr<OperationPass<FuncOp>> createSuperVectorizePass() {
   return std::make_unique<Vectorize>();
 }
 
 /// Applies vectorization to the current function by searching over a bunch of
 /// predetermined patterns.
-void Vectorize::runOnFunction() {
-  FuncOp f = getFunction();
+void Vectorize::runOnOperation() {
+  FuncOp f = getOperation();
   if (!fastestVaryingPattern.empty() &&
       fastestVaryingPattern.size() != vectorSizes.size()) {
     f.emitRemark("Fastest varying pattern specified with different size than "
                  "the vector size.");
     return signalPassFailure();
   }
 
   if (vectorizeReductions && vectorSizes.size() != 1) {

mlir/lib/Dialect/Arithmetic/Transforms/Bufferize.cpp

rewriter.replaceOpWithNewOp<arith::IndexCastOp>(
         MemRefType::get(tensorType.getShape(), tensorType.getElementType()));
     return success();
   }
 };
 
 /// Pass to bufferize Arithmetic ops.
 struct ArithmeticBufferizePass
     : public ArithmeticBufferizeBase<ArithmeticBufferizePass> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     bufferization::BufferizeTypeConverter typeConverter;
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
 
     target.addLegalDialect<arith::ArithmeticDialect, memref::MemRefDialect>();
 
     arith::populateArithmeticBufferizePatterns(typeConverter, patterns);
 
     target.addDynamicallyLegalOp<arith::IndexCastOp>(
         [&](arith::IndexCastOp op) {
           return typeConverter.isLegal(op.getType());
         });
 
-    if (failed(
-            applyPartialConversion(getFunction(), target, std::move(patterns))))
+    if (failed(applyPartialConversion(getOperation(), target,
+                                      std::move(patterns))))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 void mlir::arith::populateArithmeticBufferizePatterns(
     bufferization::BufferizeTypeConverter &typeConverter,
     RewritePatternSet &patterns) {
   patterns.add<BufferizeIndexCastOp>(typeConverter, patterns.getContext());
 }
 
 std::unique_ptr<Pass> mlir::arith::createArithmeticBufferizePass() {
   return std::make_unique<ArithmeticBufferizePass>();
 }

mlir/lib/Dialect/Arithmetic/Transforms/ExpandOps.cpp

LogicalResult matchAndRewrite(OpTy op,
     Value cmp = rewriter.create<arith::CmpIOp>(loc, pred, lhs, rhs);
     rewriter.replaceOpWithNewOp<SelectOp>(op, cmp, lhs, rhs);
     return success();
   }
 };
 
 struct ArithmeticExpandOpsPass
     : public ArithmeticExpandOpsBase<ArithmeticExpandOpsPass> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
 
     arith::populateArithmeticExpandOpsPatterns(patterns);
 
     target.addLegalDialect<arith::ArithmeticDialect, StandardOpsDialect>();
     // clang-format off
     target.addIllegalOp<
       arith::CeilDivSIOp,
       arith::CeilDivUIOp,
       arith::FloorDivSIOp,
       arith::MaxFOp,
       arith::MaxSIOp,
       arith::MaxUIOp,
       arith::MinFOp,
       arith::MinSIOp,
       arith::MinUIOp
     >();
     // clang-format on
-    if (failed(
-            applyPartialConversion(getFunction(), target, std::move(patterns))))
+    if (failed(applyPartialConversion(getOperation(), target,
+                                      std::move(patterns))))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 void mlir::arith::populateArithmeticExpandOpsPatterns(
     RewritePatternSet &patterns) {

mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp

 /// necessary. It uses the algorithm described at the top of the file.
 struct BufferDeallocationPass : BufferDeallocationBase<BufferDeallocationPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<bufferization::BufferizationDialect>();
     registry.insert<memref::MemRefDialect>();
     registry.addOpInterface<memref::AllocOp, DefaultAllocationInterface>();
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
+    FuncOp func = getOperation();
+    if (func.isExternal())
+      return;
+
     // Ensure that there are supported loops only.
-    FuncOp func = getFunction();
     Backedges backedges(func);
     if (backedges.size()) {
       func.emitError("Only structured control-flow loops are supported.");
       return signalPassFailure();
     }
 
     // Check that the control flow structures are supported.
     if (!validateSupportedControlFlow(func.getRegion()))

mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp

 }
 
 namespace {
 struct FinalizingBufferizePass
     : public FinalizingBufferizeBase<FinalizingBufferizePass> {
   using FinalizingBufferizeBase<
       FinalizingBufferizePass>::FinalizingBufferizeBase;
 
-  void runOnFunction() override {
-    auto func = getFunction();
+  void runOnOperation() override {
+    auto func = getOperation();
     auto *context = &getContext();
 
     BufferizeTypeConverter typeConverter;
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);
 
     populateEliminateBufferizeMaterializationsPatterns(typeConverter, patterns);
 
target.markUnknownOpDynamicallyLegal(
         [&](Operation *op) { return typeConverter.isLegal(op); });
 
     if (failed(applyFullConversion(func, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
-std::unique_ptr<FunctionPass>
+std::unique_ptr<OperationPass<FuncOp>>
 mlir::bufferization::createFinalizingBufferizePass() {
   return std::make_unique<FinalizingBufferizePass>();
 }

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

 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 namespace {
 class GpuAsyncRegionPass : public GpuAsyncRegionPassBase<GpuAsyncRegionPass> {
   struct ThreadTokenCallback;
   struct DeferWaitCallback;
   struct SingleTokenUseCallback;
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 } // namespace
 
 static bool isTerminator(Operation *op) {
   return op->mightHaveTrait<OpTrait::IsTerminator>();
 }
 static bool hasSideEffects(Operation *op) {
   return !MemoryEffectOpInterface::hasNoEffect(op);
for (auto index : indices) {
         std::get<0>(pair).set(std::get<1>(pair));
     }
   }
 };
 
 // Replaces synchronous GPU ops in the op's region with asynchronous ones and
 // inserts the necessary synchronization (as gpu.wait ops). Assumes sequential
 // execution semantics and that no GPU ops are asynchronous yet.
-void GpuAsyncRegionPass::runOnFunction() {
-  if (getFunction()->walk(ThreadTokenCallback(getContext())).wasInterrupted())
+void GpuAsyncRegionPass::runOnOperation() {
+  if (getOperation()->walk(ThreadTokenCallback(getContext())).wasInterrupted())
     return signalPassFailure();
 
   // Collect gpu.wait ops that we can move out of async.execute regions.
-  getFunction().getRegion().walk(DeferWaitCallback());
+  getOperation().getRegion().walk(DeferWaitCallback());
   // Makes each !gpu.async.token returned from async.execute op have single use.
-  getFunction().getRegion().walk(SingleTokenUseCallback());
+  getOperation().getRegion().walk(SingleTokenUseCallback());
 }
 
 std::unique_ptr<OperationPass<FuncOp>> mlir::createGpuAsyncRegionPass() {
   return std::make_unique<GpuAsyncRegionPass>();
 }

mlir/lib/Dialect/Linalg/Transforms/Generalization.cpp

FailureOr<GenericOp> mlir::linalg::generalizeNamedOp(RewriterBase &rewriter,
   rewriter.replaceOp(linalgOp, genericOp->getResults());
   return genericOp;
 }
 
 namespace {
 
 struct LinalgGeneralizationPass
     : public LinalgGeneralizationBase<LinalgGeneralizationPass> {
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
 } // namespace
 
-void LinalgGeneralizationPass::runOnFunction() {
-  FuncOp func = getFunction();
+void LinalgGeneralizationPass::runOnOperation() {
+  FuncOp func = getOperation();
   RewritePatternSet patterns(&getContext());
   populateLinalgNamedOpsGeneralizationPatterns(patterns);
   (void)applyPatternsAndFoldGreedily(func.getBody(), std::move(patterns));
 }
 
 void mlir::linalg::populateLinalgNamedOpsGeneralizationPatterns(
     RewritePatternSet &patterns, const LinalgTransformationFilter &marker) {
   patterns.add<LinalgGeneralizationPattern>(patterns.getContext(), marker);
 }
 
 std::unique_ptr<OperationPass<FuncOp>> mlir::createLinalgGeneralizationPass() {
   return std::make_unique<LinalgGeneralizationPass>();
 }

mlir/lib/Dialect/Linalg/Transforms/InlineScalarOperands.cpp

void mlir::linalg::populateInlineConstantOperandsPatterns(
   auto *context = patterns.getContext();
   patterns.add<InlineScalarOperands>(context);
 }
 
 namespace {
 /// Pass that removes unit-extent dims within generic ops.
 struct LinalgInlineScalarOperandsPass
     : public LinalgInlineScalarOperandsBase<LinalgInlineScalarOperandsPass> {
-  void runOnFunction() override {
-    FuncOp funcOp = getFunction();
+  void runOnOperation() override {
+    FuncOp funcOp = getOperation();
     MLIRContext *context = funcOp.getContext();
     RewritePatternSet patterns(context);
 
     populateInlineConstantOperandsPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(funcOp.getBody(), std::move(patterns));
   }
 };
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createLinalgInlineScalarOperandsPass() {
   return std::make_unique<LinalgInlineScalarOperandsPass>();
 }

mlir/lib/Dialect/Linalg/Transforms/LinalgStrategyPasses.cpp

struct LinalgStrategyTileAndFusePass
 
   LinalgStrategyTileAndFusePass(StringRef opName,
                                 LinalgTilingAndFusionOptions opt,
                                 LinalgTransformationFilter filt)
       : options(std::move(opt)), filter(std::move(filt)) {
     this->anchorOpName.setValue(opName.str());
   }
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
 
     RewritePatternSet tilingAndFusionPattern(funcOp.getContext());
     if (!anchorOpName.empty()) {
       tilingAndFusionPattern.add<LinalgTileAndFuseTensorOpsPattern>(
           anchorOpName, funcOp.getContext(), options, filter);
     } else {
struct LinalgStrategyTilePass
   LinalgStrategyTilePass() = default;
 
   LinalgStrategyTilePass(StringRef opName, LinalgTilingOptions opt,
                          LinalgTransformationFilter filt)
       : options(std::move(opt)), filter(std::move(filt)) {
     this->anchorOpName.setValue(opName.str());
   }
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
 
     MLIRContext *ctx = funcOp.getContext();
     RewritePatternSet tilingPattern(ctx);
     if (!anchorOpName.empty())
       tilingPattern.add<LinalgTilingPattern>(anchorOpName, ctx, options,
                                              filter);
struct LinalgStrategyPadPass
   LinalgStrategyPadPass() = default;
 
   LinalgStrategyPadPass(StringRef opName, LinalgPaddingOptions opt,
                         LinalgTransformationFilter filt)
       : options(std::move(opt)), filter(std::move(filt)) {
     this->anchorOpName.setValue(opName.str());
   }
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
 
     RewritePatternSet paddingPattern(funcOp.getContext());
     if (!anchorOpName.empty()) {
       paddingPattern.add<LinalgPaddingPattern>(
           anchorOpName, funcOp.getContext(), options, filter);
     } else {
struct LinalgStrategyGeneralizePass
   LinalgStrategyGeneralizePass() = default;
 
   LinalgStrategyGeneralizePass(StringRef opName,
                                LinalgTransformationFilter filter)
       : filter(std::move(filter)) {
     this->anchorOpName.setValue(opName.str());
   }
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
 
     RewritePatternSet generalizationPattern(funcOp.getContext());
     if (!anchorOpName.empty()) {
       generalizationPattern.add<LinalgGeneralizationPattern>(
           anchorOpName, funcOp.getContext(), filter);
     } else {

 struct LinalgStrategyDecomposePass
     : public LinalgStrategyDecomposePassBase<LinalgStrategyDecomposePass> {
 
   LinalgStrategyDecomposePass() = default;
 
   LinalgStrategyDecomposePass(LinalgTransformationFilter filter)
       : filter(std::move(filter)) {}
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
     RewritePatternSet decompositionPattern(funcOp.getContext());
     populateDecomposeConvolutionPatterns(decompositionPattern, filter);
     if (failed(applyPatternsAndFoldGreedily(funcOp,
                                             std::move(decompositionPattern))))
       signalPassFailure();
   }
 
   LinalgTransformationFilter filter;
 };
 
 /// Configurable pass to apply pattern-based linalg generalization.
 struct LinalgStrategyInterchangePass
     : public LinalgStrategyInterchangePassBase<LinalgStrategyInterchangePass> {
 
   LinalgStrategyInterchangePass() = default;
 
   LinalgStrategyInterchangePass(ArrayRef<int64_t> iteratorInterchange,
                                 LinalgTransformationFilter filter)
       : iteratorInterchange(iteratorInterchange.begin(),
                             iteratorInterchange.end()),
         filter(std::move(filter)) {}
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
 
     SmallVector<unsigned> interchangeVector(iteratorInterchange.begin(),
                                             iteratorInterchange.end());
     RewritePatternSet interchangePattern(funcOp.getContext());
     interchangePattern.add<GenericOpInterchangePattern>(
         funcOp.getContext(), interchangeVector, filter);
struct LinalgStrategyPromotePass
   LinalgStrategyPromotePass() = default;
 
   LinalgStrategyPromotePass(StringRef opName, LinalgPromotionOptions opt,
                             LinalgTransformationFilter filt)
       : options(std::move(opt)), filter(std::move(filt)) {
     this->anchorOpName.setValue(opName.str());
   }
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
 
     RewritePatternSet promotionPattern(funcOp.getContext());
     if (!anchorOpName.empty()) {
       promotionPattern.add<LinalgBasePromotionPattern>(
           anchorOpName, funcOp.getContext(), options, filter);
     } else {
struct LinalgStrategyVectorizePass
   LinalgStrategyVectorizePass(StringRef opName, LinalgVectorizationOptions opt,
                               LinalgTransformationFilter filt,
                               bool padVectorize = false)
       : options(opt), filter(std::move(filt)) {
     this->anchorOpName.setValue(opName.str());
     this->vectorizePadding.setValue(padVectorize);
   }
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
 
     RewritePatternSet vectorizationPatterns(funcOp.getContext());
     if (!anchorOpName.empty()) {
       vectorizationPatterns.add<LinalgVectorizationPattern>(
           anchorOpName, funcOp.getContext(), options, filter);
     } else {

 /// passes.
 struct LinalgStrategyEnablePass
     : public LinalgStrategyEnablePassBase<LinalgStrategyEnablePass> {
 
   LinalgStrategyEnablePass(LinalgEnablingOptions opt,
                            LinalgTransformationFilter filt)
       : options(opt), filter(std::move(filt)) {}
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
 
     MLIRContext *context = funcOp.getContext();
     RewritePatternSet patterns =
         linalg::getLinalgTilingCanonicalizationPatterns(context);
     scf::populateSCFForLoopCanonicalizationPatterns(patterns);
     if (failed(applyPatternsAndFoldGreedily(funcOp, std::move(patterns))))

 struct LinalgStrategyLowerVectorsPass
     : public LinalgStrategyLowerVectorsPassBase<
           LinalgStrategyLowerVectorsPass> {
 
   LinalgStrategyLowerVectorsPass(LinalgVectorLoweringOptions opt,
                                  LinalgTransformationFilter filt)
       : options(opt), filter(std::move(filt)) {}
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
 
     MLIRContext *context = funcOp.getContext();
     RewritePatternSet patterns(context);
     vector::populateVectorToVectorCanonicalizationPatterns(patterns);
     // In a progressive lowering of vectors, this would be the 1st step.
     if (options.contractionLowering) {
struct LinalgStrategyLowerVectorsPass
   LinalgTransformationFilter filter;
 };
 
 /// Configurable pass to lower vector operations.
 struct LinalgStrategyRemoveMarkersPass
     : public LinalgStrategyRemoveMarkersPassBase<
           LinalgStrategyRemoveMarkersPass> {
 
-  void runOnFunction() override {
-    auto funcOp = getFunction();
+  void runOnOperation() override {
+    auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
     funcOp.walk([](LinalgOp op) {
       op->removeAttr(LinalgTransforms::kLinalgTransformMarker);
     });
   }
 };
 } // namespace

mlir/lib/Dialect/Linalg/Transforms/Loops.cpp

static void lowerLinalgToLoopsImpl(FuncOp funcOp) {
   (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
 }
 
 struct LowerToAffineLoops
     : public LinalgLowerToAffineLoopsBase<LowerToAffineLoops> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
-  void runOnFunction() override {
-    lowerLinalgToLoopsImpl<AffineForOp>(getFunction());
+  void runOnOperation() override {
+    lowerLinalgToLoopsImpl<AffineForOp>(getOperation());
   }
 };
 
 struct LowerToLoops : public LinalgLowerToLoopsBase<LowerToLoops> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect, scf::SCFDialect>();
   }
-  void runOnFunction() override {
-    lowerLinalgToLoopsImpl<scf::ForOp>(getFunction());
+  void runOnOperation() override {
+    lowerLinalgToLoopsImpl<scf::ForOp>(getOperation());
   }
 };
 
 struct LowerToParallelLoops
     : public LinalgLowerToParallelLoopsBase<LowerToParallelLoops> {
-  void runOnFunction() override {
-    lowerLinalgToLoopsImpl<scf::ParallelOp>(getFunction());
+  void runOnOperation() override {
+    lowerLinalgToLoopsImpl<scf::ParallelOp>(getOperation());
   }
 };
 
 struct LowerTiledLoopsToSCF
     : public LinalgLowerTiledLoopsToSCFBase<LowerTiledLoopsToSCF> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext *context = &getContext();
     RewritePatternSet patterns(context);
     populateTiledLoopToSCFPattern(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 } // namespace
 
 /// Rewrite a TiledLoopOp with bounds/step that potentially do not divide evenly
 /// into two TiledLoopOps: One where the step divides the iteration space
 /// evenly, followed another one for the last (partial) iteration (if any). This
 /// function only rewrites the `idx`-th loop of the loop nest represented by

mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp

 namespace {
 struct LinalgPromotionPass : public LinalgPromotionBase<LinalgPromotionPass> {
   LinalgPromotionPass() = default;
   LinalgPromotionPass(bool dynamicBuffers, bool useAlloca) {
     this->dynamicBuffers = dynamicBuffers;
     this->useAlloca = useAlloca;
   }
 
-  void runOnFunction() override {
-    getFunction().walk([&](LinalgOp op) {
+  void runOnOperation() override {
+    getOperation().walk([&](LinalgOp op) {
       auto options = LinalgPromotionOptions()
                          .setDynamicBuffers(dynamicBuffers)
                          .setUseAlloca(useAlloca);
       if (failed(promoteSubviewsPrecondition(op, options)))
         return;
       LLVM_DEBUG(llvm::dbgs() << "Promote: " << *(op.getOperation()) << "\n");
       ImplicitLocOpBuilder b(op.getLoc(), op);
       // TODO: signalPassFailure() ?

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

LinalgTilingPass(ArrayRef<int64_t> tileSizes, LinalgTilingLoopType loopType,
                    ArrayRef<StringRef> distributionTypes) {
     this->tileSizes = tileSizes;
     this->loopType = "";
     this->loopTypeEnum = loopType;
     this->distributionTypes = llvm::to_vector<2>(llvm::map_range(
         distributionTypes, [](StringRef ref) { return ref.str(); }));
   }
 
-  void runOnFunction() override {
-    FuncOp funcOp = getFunction();
+  void runOnOperation() override {
+    FuncOp funcOp = getOperation();
     LinalgTilingLoopType type =
         llvm::StringSwitch<LinalgTilingLoopType>(loopType)
             .Case("for", LinalgTilingLoopType::Loops)
             .Case("affine", LinalgTilingLoopType::AffineLoops)
             .Case("parallel", LinalgTilingLoopType::ParallelLoops)
             .Case("tiled_loop", LinalgTilingLoopType::TiledLoops)
             .Default(loopTypeEnum);
     auto distTypes = llvm::to_vector<2>(llvm::map_range(

mlir/lib/Dialect/Quant/Transforms/ConvertConst.cpp

 #include "mlir/IR/Matchers.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 using namespace mlir::quant;
 
 namespace {
 struct ConvertConstPass : public QuantConvertConstBase<ConvertConstPass> {
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
 struct QuantizedConstRewrite : public OpRewritePattern<QuantizeCastOp> {
   using OpRewritePattern<QuantizeCastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(QuantizeCastOp qbarrier,
                                 PatternRewriter &rewriter) const override;
 };
auto fusedLoc = rewriter.getFusedLoc(
       {qbarrier.arg().getDefiningOp()->getLoc(), qbarrier.getLoc()});
   auto newConstOp = rewriter.create<arith::ConstantOp>(
       fusedLoc, newConstValueType, newConstValue);
   rewriter.replaceOpWithNewOp<StorageCastOp>(qbarrier, qbarrier.getType(),
                                              newConstOp);
   return success();
 }
 
-void ConvertConstPass::runOnFunction() {
+void ConvertConstPass::runOnOperation() {
   RewritePatternSet patterns(&getContext());
-  auto func = getFunction();
+  auto func = getOperation();
   auto *context = &getContext();
   patterns.add<QuantizedConstRewrite>(context);
   (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
 }
 
 std::unique_ptr<OperationPass<FuncOp>> mlir::quant::createConvertConstPass() {
   return std::make_unique<ConvertConstPass>();
 }

mlir/lib/Dialect/Quant/Transforms/ConvertSimQuant.cpp

 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 using namespace mlir::quant;
 
 namespace {
 struct ConvertSimulatedQuantPass
     : public QuantConvertSimulatedQuantBase<ConvertSimulatedQuantPass> {
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
 /// Base class rewrites ConstFakeQuant into a qbarrier/dbarrier pair.
 template <typename ConcreteRewriteClass, typename FakeQuantOp>
 class FakeQuantRewrite : public OpRewritePattern<FakeQuantOp> {
 public:
   using OpRewritePattern<FakeQuantOp>::OpRewritePattern;
 
QuantizedType convertFakeQuantAttrsToType(ConstFakeQuantPerAxis fqOp,
     return fakeQuantAttrsToType(fqOp.getLoc(), fqOp.num_bits(), fqOp.axis(),
                                 min, max, fqOp.narrow_range(), expressedType,
                                 fqOp.is_signed());
   }
 };
 
 } // namespace
 
-void ConvertSimulatedQuantPass::runOnFunction() {
+void ConvertSimulatedQuantPass::runOnOperation() {
   bool hadFailure = false;
-  auto func = getFunction();
+  auto func = getOperation();
   RewritePatternSet patterns(func.getContext());
   auto *ctx = func.getContext();
   patterns.add<ConstFakeQuantRewrite, ConstFakeQuantPerAxisRewrite>(
       ctx, &hadFailure);
   (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
   if (hadFailure)
     signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::quant::createConvertSimulatedQuantPass() {
   return std::make_unique<ConvertSimulatedQuantPass>();
 }

mlir/lib/Dialect/SCF/Transforms/Bufferize.cpp

 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 using namespace mlir::scf;
 
 namespace {
 struct SCFBufferizePass : public SCFBufferizeBase<SCFBufferizePass> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     auto func = getOperation();
     auto *context = &getContext();
 
     bufferization::BufferizeTypeConverter typeConverter;
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);
 
     bufferization::populateBufferizeMaterializationLegality(target);

mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp

for (const auto &arg : llvm::enumerate(forOp.getResults()))
       arg.value().replaceAllUsesWith(whileOp.getResult(arg.index() + 1));
 
     rewriter.eraseOp(forOp);
     return success();
   }
 };
 
 struct ForToWhileLoop : public SCFForToWhileLoopBase<ForToWhileLoop> {
-  void runOnFunction() override {
-    FuncOp funcOp = getFunction();
+  void runOnOperation() override {
+    FuncOp funcOp = getOperation();
     MLIRContext *ctx = funcOp.getContext();
     RewritePatternSet patterns(ctx);
     patterns.add<ForLoopLoweringPattern>(ctx);
     (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::createForToWhileLoopPass() {
   return std::make_unique<ForToWhileLoop>();
 }

mlir/lib/Dialect/SCF/Transforms/LoopCanonicalization.cpp

LogicalResult matchAndRewrite(OpTy op,
 
     return scf::canonicalizeMinMaxOpInLoop(rewriter, op, op.getAffineMap(),
                                            op.operands(), IsMin, loopMatcher);
   }
 };
 
 struct SCFForLoopCanonicalization
     : public SCFForLoopCanonicalizationBase<SCFForLoopCanonicalization> {
-  void runOnFunction() override {
-    FuncOp funcOp = getFunction();
+  void runOnOperation() override {
+    FuncOp funcOp = getOperation();
     MLIRContext *ctx = funcOp.getContext();
     RewritePatternSet patterns(ctx);
     scf::populateSCFForLoopCanonicalizationPatterns(patterns);
     if (failed(applyPatternsAndFoldGreedily(funcOp, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace

mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp

struct ForLoopPeelingPattern : public OpRewritePattern<ForOp> {
   /// the direct parent.
   bool skipPartial;
 };
 } // namespace
 
 namespace {
 struct ParallelLoopSpecialization
     : public SCFParallelLoopSpecializationBase<ParallelLoopSpecialization> {
-  void runOnFunction() override {
-    getFunction().walk(
+  void runOnOperation() override {
+    getOperation().walk(
         [](ParallelOp op) { specializeParallelLoopForUnrolling(op); });
   }
 };
 
 struct ForLoopSpecialization
     : public SCFForLoopSpecializationBase<ForLoopSpecialization> {
-  void runOnFunction() override {
-    getFunction().walk([](ForOp op) { specializeForLoopForUnrolling(op); });
+  void runOnOperation() override {
+    getOperation().walk([](ForOp op) { specializeForLoopForUnrolling(op); });
   }
 };
 
 struct ForLoopPeeling : public SCFForLoopPeelingBase<ForLoopPeeling> {
-  void runOnFunction() override {
-    FuncOp funcOp = getFunction();
+  void runOnOperation() override {
+    FuncOp funcOp = getOperation();
     MLIRContext *ctx = funcOp.getContext();
     RewritePatternSet patterns(ctx);
     patterns.add<ForLoopPeelingPattern>(ctx, skipPartial);
     (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
 
     // Drop the markers.
     funcOp.walk([](Operation *op) {
       op->removeAttr(kPeeledLoopLabel);

mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp

struct ParallelLoopTiling
     : public SCFParallelLoopTilingBase<ParallelLoopTiling> {
   ParallelLoopTiling() = default;
   explicit ParallelLoopTiling(ArrayRef<int64_t> tileSizes,
                               bool noMinMaxBounds = false) {
     this->tileSizes = tileSizes;
     this->noMinMaxBounds = noMinMaxBounds;
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     SmallVector<ParallelOp, 2> innermostPloops;
-    getInnermostParallelLoops(getFunction().getOperation(), innermostPloops);
+    getInnermostParallelLoops(getOperation().getOperation(), innermostPloops);
     for (ParallelOp ploop : innermostPloops) {
       // FIXME: Add reduction support.
       if (ploop.getNumReductions() == 0)
         tileParallelLoop(ploop, tileSizes, noMinMaxBounds);
     }
   }
 };
 } // namespace
 
 std::unique_ptr<Pass>
 mlir::createParallelLoopTilingPass(ArrayRef<int64_t> tileSizes,
                                    bool noMinMaxBounds) {
   return std::make_unique<ParallelLoopTiling>(tileSizes, noMinMaxBounds);
 }

mlir/lib/Dialect/Shape/Transforms/Bufferize.cpp

 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Shape/Transforms/Passes.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 struct ShapeBufferizePass : public ShapeBufferizeBase<ShapeBufferizePass> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext &ctx = getContext();
 
     RewritePatternSet patterns(&ctx);
     bufferization::BufferizeTypeConverter typeConverter;
     ConversionTarget target(ctx);
 
     bufferization::populateBufferizeMaterializationLegality(target);
     populateShapeStructuralTypeConversionsAndLegality(typeConverter, patterns,
                                                       target);
 
-    if (failed(
-            applyPartialConversion(getFunction(), target, std::move(patterns))))
+    if (failed(applyPartialConversion(getOperation(), target,
+                                      std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
-std::unique_ptr<FunctionPass> mlir::createShapeBufferizePass() {
+std::unique_ptr<OperationPass<FuncOp>> mlir::createShapeBufferizePass() {
   return std::make_unique<ShapeBufferizePass>();
 }

mlir/lib/Dialect/Shape/Transforms/RemoveShapeConstraints.cpp

LogicalResult matchAndRewrite(shape::CstrEqOp op,
     return success();
   }
 };
 
 /// Removal pass.
 class RemoveShapeConstraintsPass
     : public RemoveShapeConstraintsBase<RemoveShapeConstraintsPass> {
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext &ctx = getContext();
 
     RewritePatternSet patterns(&ctx);
     populateRemoveShapeConstraintsPatterns(patterns);
 
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 } // namespace
 
 void mlir::populateRemoveShapeConstraintsPatterns(RewritePatternSet &patterns) {
   patterns.add<RemoveCstrBroadcastableOp, RemoveCstrEqOp>(
       patterns.getContext());
 }
 
-std::unique_ptr<FunctionPass> mlir::createRemoveShapeConstraintsPass() {
+std::unique_ptr<OperationPass<FuncOp>>
+mlir::createRemoveShapeConstraintsPass() {
   return std::make_unique<RemoveShapeConstraintsPass>();
 }

mlir/lib/Dialect/Shape/Transforms/ShapeToShapeLowering.cpp

NumElementsOpConverter::matchAndRewrite(NumElementsOp op,
 
   rewriter.replaceOp(op, reduce.getResult());
   return success();
 }
 
 namespace {
 struct ShapeToShapeLowering
     : public ShapeToShapeLoweringBase<ShapeToShapeLowering> {
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 } // namespace
 
-void ShapeToShapeLowering::runOnFunction() {
+void ShapeToShapeLowering::runOnOperation() {
   MLIRContext &ctx = getContext();
 
   RewritePatternSet patterns(&ctx);
   populateShapeRewritePatterns(patterns);
 
   ConversionTarget target(getContext());
   target.addLegalDialect<arith::ArithmeticDialect, ShapeDialect,
                          StandardOpsDialect>();
   target.addIllegalOp<NumElementsOp>();
-  if (failed(mlir::applyPartialConversion(getFunction(), target,
+  if (failed(mlir::applyPartialConversion(getOperation(), target,
                                           std::move(patterns))))
     signalPassFailure();
 }
 
 void mlir::populateShapeRewritePatterns(RewritePatternSet &patterns) {
   patterns.add<NumElementsOpConverter>(patterns.getContext());
 }
 
 std::unique_ptr<Pass> mlir::createShapeToShapeLowering() {
   return std::make_unique<ShapeToShapeLowering>();
 }

mlir/lib/Dialect/StandardOps/Transforms/Bufferize.cpp

 void mlir::populateStdBufferizePatterns(
     bufferization::BufferizeTypeConverter &typeConverter,
     RewritePatternSet &patterns) {
   patterns.add<BufferizeSelectOp>(typeConverter, patterns.getContext());
 }
 
 namespace {
 struct StdBufferizePass : public StdBufferizeBase<StdBufferizePass> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     auto *context = &getContext();
     bufferization::BufferizeTypeConverter typeConverter;
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);
 
     target.addLegalDialect<scf::SCFDialect, StandardOpsDialect,
                            memref::MemRefDialect>();
 
     populateStdBufferizePatterns(typeConverter, patterns);
     // We only bufferize the case of tensor selected type and scalar condition,
     // as that boils down to a select over memref descriptors (don't need to
     // touch the data).
     target.addDynamicallyLegalOp<SelectOp>([&](SelectOp op) {
       return typeConverter.isLegal(op.getType()) ||
              !op.getCondition().getType().isa<IntegerType>();
     });
-    if (failed(
-            applyPartialConversion(getFunction(), target, std::move(patterns))))
+    if (failed(applyPartialConversion(getOperation(), target,
+                                      std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::createStdBufferizePass() {
   return std::make_unique<StdBufferizePass>();
 }

mlir/lib/Dialect/StandardOps/Transforms/ExpandOps.cpp

LogicalResult matchAndRewrite(memref::ReshapeOp op,
     rewriter.replaceOpWithNewOp<memref::ReinterpretCastOp>(
         op, op.getType(), op.source(), /*offset=*/rewriter.getIndexAttr(0),
         sizes, strides);
     return success();
   }
 };
 
 struct StdExpandOpsPass : public StdExpandOpsBase<StdExpandOpsPass> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext &ctx = getContext();
 
     RewritePatternSet patterns(&ctx);
     populateStdExpandOpsPatterns(patterns);
     ConversionTarget target(getContext());
 
     target.addLegalDialect<arith::ArithmeticDialect, memref::MemRefDialect,
                            StandardOpsDialect>();
     target.addDynamicallyLegalOp<memref::AtomicRMWOp>(
         [](memref::AtomicRMWOp op) {
           return op.kind() != arith::AtomicRMWKind::maxf &&
                  op.kind() != arith::AtomicRMWKind::minf;
         });
     target.addDynamicallyLegalOp<memref::ReshapeOp>([](memref::ReshapeOp op) {
       return !op.shape().getType().cast<MemRefType>().hasStaticShape();
     });
-    if (failed(
-            applyPartialConversion(getFunction(), target, std::move(patterns))))
+    if (failed(applyPartialConversion(getOperation(), target,
+                                      std::move(patterns))))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 void mlir::populateStdExpandOpsPatterns(RewritePatternSet &patterns) {
   patterns.add<AtomicRMWOpConverter, MemRefReshapeOpConverter>(
       patterns.getContext());
 }
 
 std::unique_ptr<Pass> mlir::createStdExpandOpsPass() {
   return std::make_unique<StdExpandOpsPass>();
 }

mlir/lib/Dialect/Tensor/Transforms/Bufferize.cpp

matchAndRewrite(tensor::RankOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<memref::RankOp>(op, op.getType(),
                                                 adaptor.tensor());
     return success();
   }
 };
 
 struct TensorBufferizePass : public TensorBufferizeBase<TensorBufferizePass> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     auto *context = &getContext();
     bufferization::BufferizeTypeConverter typeConverter;
 
     ConversionTarget target(*context);
     target.addLegalDialect<scf::SCFDialect, memref::MemRefDialect>();
     target.addDynamicallyLegalDialect<arith::ArithmeticDialect,
                                       StandardOpsDialect>(
         [&](Operation *op) { return typeConverter.isLegal(op); });
     target.addLegalOp<CallOp, ReturnOp>();
     target.addIllegalOp<tensor::CastOp, tensor::ExtractOp,
                         tensor::FromElementsOp, tensor::GenerateOp>();
     bufferization::populateBufferizeMaterializationLegality(target);
 
     RewritePatternSet patterns(context);
     populateTensorBufferizePatterns(typeConverter, patterns);
-    if (failed(
-            applyPartialConversion(getFunction(), target, std::move(patterns))))
+    if (failed(applyPartialConversion(getOperation(), target,
+                                      std::move(patterns))))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 void mlir::populateTensorBufferizePatterns(
     bufferization::BufferizeTypeConverter &typeConverter,

mlir/lib/Dialect/Tosa/Transforms/TosaInferShapes.cpp

for (auto it : shapesStorage) {
     }
   }
 }
 
 /// Pass that performs shape propagation across TOSA operations. This includes
 /// migrating to within the regions of if/while operations.
 struct TosaInferShapes : public TosaInferShapesBase<TosaInferShapes> {
 public:
-  void runOnFunction() override {
+  void runOnOperation() override {
     FuncOp func = getOperation();
 
     IRRewriter rewriter(func.getContext());
 
     propagateShapesInRegion(func.body());
 
     // Insert UnrealizedConversionCasts to guarantee ReturnOp agress with
     // the FuncOp type.

mlir/lib/Dialect/Tosa/Transforms/TosaMakeBroadcastable.cpp

 } // namespace
 
 namespace {
 /// Pass that enables broadcast by making all input arrays have the same
 /// number of dimensions. Insert RESHAPE operations to lower rank operand
 struct TosaMakeBroadcastable
     : public TosaMakeBroadcastableBase<TosaMakeBroadcastable> {
 public:
-  void runOnFunction() override {
-    auto func = getFunction();
+  void runOnOperation() override {
+    auto func = getOperation();
     RewritePatternSet patterns(func.getContext());
     MLIRContext *ctx = func.getContext();
     // Add the generated patterns to the list.
     patterns.add<ConvertTosaOp<tosa::BitwiseAndOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::BitwiseOrOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::BitwiseXorOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::AddOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::SubOp>>(ctx);

mlir/lib/Dialect/Tosa/Transforms/TosaOptionalDecompositions.cpp

 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 
 struct TosaOptionalDecompositions
     : public TosaOptionalDecompositionsBase<TosaOptionalDecompositions> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     auto *ctx = &getContext();
     RewritePatternSet patterns(ctx);
-    auto func = getFunction();
+    auto func = getOperation();
 
     mlir::tosa::populateTosaDecomposeConv2D(ctx, patterns);
     mlir::tosa::populateTosaDecomposeTransposeConv(ctx, patterns);
     mlir::tosa::populateTosaDecomposeDepthwise(ctx, patterns);
 
     if (applyPatternsAndFoldGreedily(func, std::move(patterns)).failed())
       signalPassFailure();
   }
 };
 
 } // namespace
 
 std::unique_ptr<Pass> mlir::tosa::createTosaOptionalDecompositions() {
   return std::make_unique<TosaOptionalDecompositions>();
 }

mlir/lib/Transforms/BufferOptimizations.cpp

 //===----------------------------------------------------------------------===//
 // BufferOptimizationPasses
 //===----------------------------------------------------------------------===//
 
 /// The buffer hoisting pass that hoists allocation nodes into dominating
 /// blocks.
 struct BufferHoistingPass : BufferHoistingBase<BufferHoistingPass> {
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     // Hoist all allocations into dominator blocks.
     BufferAllocationHoisting<BufferAllocationHoistingState> optimizer(
-        getFunction());
+        getOperation());
     optimizer.hoist();
   }
 };
 
 /// The buffer loop hoisting pass that hoists allocation nodes out of loops.
 struct BufferLoopHoistingPass : BufferLoopHoistingBase<BufferLoopHoistingPass> {
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     // Hoist all allocations out of loops.
     BufferAllocationHoisting<BufferAllocationLoopHoistingState> optimizer(
-        getFunction());
+        getOperation());
     optimizer.hoist();
   }
 };
 
 /// The promote buffer to stack pass that tries to convert alloc nodes into
 /// alloca nodes.
 class PromoteBuffersToStackPass
     : public PromoteBuffersToStackBase<PromoteBuffersToStackPass> {
if (isSmallAlloc == nullptr) {
         return defaultIsSmallAlloc(alloc, maxAllocSizeInBytes,
                                    bitwidthOfIndexType,
                                    maxRankOfAllocatedMemRef);
       };
     }
     return success();
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     // Move all allocation nodes and convert candidates into allocas.
-    BufferPlacementPromotion optimizer(getFunction());
+    BufferPlacementPromotion optimizer(getOperation());
     optimizer.promote(isSmallAlloc);
   }
 
 private:
   std::function<bool(Value)> isSmallAlloc;
 };
 
 } // namespace

mlir/lib/Transforms/LoopCoalescing.cpp

for (unsigned end = loops.size(); end > 0; --end) {
       }
       // If a band was found and transformed, keep looking at the loops above
       // the outermost transformed loop.
       if (start != end - 1)
         end = start + 1;
     }
   }
 
-  void runOnFunction() override {
-    FuncOp func = getFunction();
+  void runOnOperation() override {
+    FuncOp func = getOperation();
     func.walk([&](Operation *op) {
       if (auto scfForOp = dyn_cast<scf::ForOp>(op))
         walkLoop(scfForOp);
       else if (auto affineForOp = dyn_cast<AffineForOp>(op))
         walkLoop(affineForOp);
     });
   }
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>> mlir::createLoopCoalescingPass() {
   return std::make_unique<LoopCoalescingPass>();
 }

mlir/lib/Transforms/LoopFusion.cpp

struct LoopFusion : public AffineLoopFusionBase<LoopFusion> {
   LoopFusion(unsigned fastMemorySpace, uint64_t localBufSizeThresholdBytes,
              bool maximalFusion, enum FusionMode affineFusionMode) {
     this->fastMemorySpace = fastMemorySpace;
     this->localBufSizeThreshold = localBufSizeThresholdBytes / 1024;
     this->maximalFusion = maximalFusion;
     this->affineFusionMode = affineFusionMode;
   }
 
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createLoopFusionPass(unsigned fastMemorySpace,
                            uint64_t localBufSizeThreshold, bool maximalFusion,
                            enum FusionMode affineFusionMode) {
for (auto &pair : mdg->memrefEdgeCount) {
       if (isa_and_nonnull<memref::AllocOp>(op))
         op->erase();
     }
   }
 };
 
 } // namespace
 
-void LoopFusion::runOnFunction() {
+void LoopFusion::runOnOperation() {
   MemRefDependenceGraph g;
-  if (!g.init(getFunction()))
+  if (!g.init(getOperation()))
     return;
 
   Optional<unsigned> fastMemorySpaceOpt;
   if (fastMemorySpace.hasValue())
     fastMemorySpaceOpt = fastMemorySpace;
   unsigned localBufSizeThresholdBytes = localBufSizeThreshold * 1024;
   GreedyFusion fusion(&g, localBufSizeThresholdBytes, fastMemorySpaceOpt,
                       maximalFusion, computeToleranceThreshold);
 
   if (affineFusionMode == FusionMode::ProducerConsumer)
     fusion.runProducerConsumerFusionOnly();
   else if (affineFusionMode == FusionMode::Sibling)
     fusion.runSiblingFusionOnly();
   else
     fusion.runGreedyFusion();
 }

mlir/lib/Transforms/PipelineDataTransfer.cpp

 
 #define DEBUG_TYPE "affine-pipeline-data-transfer"
 
 using namespace mlir;
 
 namespace {
 struct PipelineDataTransfer
     : public AffinePipelineDataTransferBase<PipelineDataTransfer> {
-  void runOnFunction() override;
+  void runOnOperation() override;
   void runOnAffineForOp(AffineForOp forOp);
 
   std::vector<AffineForOp> forOps;
 };
 
 } // namespace
 
 /// Creates a pass to pipeline explicit movement of data across levels of the
static bool doubleBuffer(Value oldMemRef, AffineForOp forOp) {
   // Insert the dealloc op right after the for loop.
   bOuter.setInsertionPointAfter(forOp);
   bOuter.create<memref::DeallocOp>(forOp.getLoc(), newMemRef);
 
   return true;
 }
 
 /// Returns success if the IR is in a valid state.
-void PipelineDataTransfer::runOnFunction() {
+void PipelineDataTransfer::runOnOperation() {
   // Do a post order walk so that inner loop DMAs are processed first. This is
   // necessary since 'affine.for' operations nested within would otherwise
   // become invalid (erased) when the outer loop is pipelined (the pipelined one
   // gets deleted and replaced by a prologue, a new steady-state loop and an
   // epilogue).
   forOps.clear();
-  getFunction().walk([&](AffineForOp forOp) { forOps.push_back(forOp); });
+  getOperation().walk([&](AffineForOp forOp) { forOps.push_back(forOp); });
   for (auto forOp : forOps)
     runOnAffineForOp(forOp);
 }
 
 // Check if tags of the dma start op and dma wait op match.
 static bool checkTagMatch(AffineDmaStartOp startOp, AffineDmaWaitOp waitOp) {
   if (startOp.getTagMemRef() != waitOp.getTagMemRef())
     return false;

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> {
+struct TestLivenessPass
+    : public PassWrapper<TestLivenessPass, OperationPass<FuncOp>> {
   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";
+  void runOnOperation() override {
+    llvm::errs() << "Testing : " << getOperation().getName() << "\n";
     getAnalysis<Liveness>().print(llvm::errs());
   }
 };
 
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestLivenessPass() { PassRegistration<TestLivenessPass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestMatchReduction.cpp

if (reducedValue) {
     return;
   }
 
   redRegionOp->emitRemark("Reduction NOT found in output #")
       << numOutput << "!";
 }
 
 struct TestMatchReductionPass
-    : public PassWrapper<TestMatchReductionPass, FunctionPass> {
+    : public PassWrapper<TestMatchReductionPass, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-match-reduction"; }
   StringRef getDescription() const final {
     return "Test the match reduction utility.";
   }
 
-  void runOnFunction() override {
-    FuncOp func = getFunction();
+  void runOnOperation() override {
+    FuncOp func = getOperation();
     func->emitRemark("Testing function");
 
     func.walk<WalkOrder::PreOrder>([](Operation *op) {
       if (isa<FuncOp>(op))
         return;
 
       // Limit testing to ops with only one region.
       if (op->getNumRegions() != 1)

mlir/test/lib/Analysis/TestMemRefBoundCheck.cpp

 #define DEBUG_TYPE "memref-bound-check"
 
 using namespace mlir;
 
 namespace {
 
 /// Checks for out of bound memref access subscripts..
 struct TestMemRefBoundCheck
-    : public PassWrapper<TestMemRefBoundCheck, FunctionPass> {
+    : public PassWrapper<TestMemRefBoundCheck, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-memref-bound-check"; }
   StringRef getDescription() const final {
     return "Check memref access bounds in a Function";
   }
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
 } // namespace
 
-void TestMemRefBoundCheck::runOnFunction() {
-  getFunction().walk([](Operation *opInst) {
+void TestMemRefBoundCheck::runOnOperation() {
+  getOperation().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>(); }
 } // 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> {
+    : public PassWrapper<TestMemRefDependenceCheck, OperationPass<FuncOp>> {
   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;
+  void runOnOperation() override;
 };
 
 } // namespace
 
 // Returns a result string which represents the direction vector (if there was
 // a dependence), returns the string "false" otherwise.
 static std::string
 getDirectionVectorStr(bool ret, unsigned numCommonLoops, unsigned loopNestDepth,
for (unsigned j = 0; j < e; ++j) {
                                      dependenceComponents);
       }
     }
   }
 }
 
 // Walks the Function 'f' adding load and store ops to 'loadsAndStores'.
 // Runs pair-wise dependence checks.
-void TestMemRefDependenceCheck::runOnFunction() {
+void TestMemRefDependenceCheck::runOnOperation() {
   // Collect the loads and stores within the function.
   loadsAndStores.clear();
-  getFunction().walk([&](Operation *op) {
+  getOperation().walk([&](Operation *op) {
     if (isa<AffineLoadOp, AffineStoreOp>(op))
       loadsAndStores.push_back(op);
   });
 
   checkDependences(loadsAndStores);
 }
 
 namespace mlir {
 namespace test {
 void registerTestMemRefDependenceCheck() {
   PassRegistration<TestMemRefDependenceCheck>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestMemRefStrideCalculation.cpp

 //===- TestMemRefStrideCalculation.cpp - Pass to test strides computation--===//
 //
 // 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 "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 struct TestMemRefStrideCalculation
-    : public PassWrapper<TestMemRefStrideCalculation, FunctionPass> {
+    : public PassWrapper<TestMemRefStrideCalculation, OperationPass<FuncOp>> {
   StringRef getArgument() const final {
     return "test-memref-stride-calculation";
   }
   StringRef getDescription() const final {
     return "Test operation constant folding";
   }
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 } // namespace
 
 /// Traverse AllocOp and compute strides of each MemRefType independently.
-void TestMemRefStrideCalculation::runOnFunction() {
-  llvm::outs() << "Testing: " << getFunction().getName() << "\n";
-  getFunction().walk([&](memref::AllocOp allocOp) {
+void TestMemRefStrideCalculation::runOnOperation() {
+  llvm::outs() << "Testing: " << getOperation().getName() << "\n";
+  getOperation().walk([&](memref::AllocOp allocOp) {
     auto memrefType = allocOp.getResult().getType().cast<MemRefType>();
     int64_t offset;
     SmallVector<int64_t, 4> strides;
     if (failed(getStridesAndOffset(memrefType, strides, offset))) {
       llvm::outs() << "MemRefType " << memrefType << " cannot be converted to "
                    << "strided form\n";
       return;
     }

mlir/test/lib/Analysis/TestSlice.cpp

 
 using namespace mlir;
 
 static const StringLiteral kOrderMarker = "__test_sort_original_idx__";
 
 namespace {
 
 struct TestTopologicalSortPass
-    : public PassWrapper<TestTopologicalSortPass, FunctionPass> {
+    : public PassWrapper<TestTopologicalSortPass, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-print-topological-sort"; }
   StringRef getDescription() const final {
     return "Print operations in topological order";
   }
-  void runOnFunction() override {
+  void runOnOperation() override {
     std::map<int, Operation *> ops;
-    getFunction().walk([&ops](Operation *op) {
+    getOperation().walk([&ops](Operation *op) {
       if (auto originalOrderAttr = op->getAttrOfType<IntegerAttr>(kOrderMarker))
         ops[originalOrderAttr.getInt()] = op;
     });
     SetVector<Operation *> sortedOp;
     for (auto op : ops)
       sortedOp.insert(op.second);
     sortedOp = topologicalSort(sortedOp);
-    llvm::errs() << "Testing : " << getFunction().getName() << "\n";
+    llvm::errs() << "Testing : " << getOperation().getName() << "\n";
     for (Operation *op : sortedOp) {
       op->print(llvm::errs());
       llvm::errs() << "\n";
     }
   }
 };
 
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestSliceAnalysisPass() {
   PassRegistration<TestTopologicalSortPass>();
 }
 } // 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> {
+    : public PassWrapper<TestAffineDataCopy, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine data copy utility functions.";
   }
   TestAffineDataCopy() = default;
   TestAffineDataCopy(const TestAffineDataCopy &pass) : PassWrapper(pass){};
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
-  void runOnFunction() override;
+  void runOnOperation() override;
 
 private:
   Option<bool> clMemRefFilter{
       *this, "memref-filter",
       llvm::cl::desc(
           "Enable memref filter testing in affine data copy optimization"),
       llvm::cl::init(false)};
   Option<bool> clTestGenerateCopyForMemRegion{
       *this, "for-memref-region",
       llvm::cl::desc("Test copy generation for a single memref region"),
       llvm::cl::init(false)};
 };
 
 } // namespace
 
-void TestAffineDataCopy::runOnFunction() {
+void TestAffineDataCopy::runOnOperation() {
   // Gather all AffineForOps by loop depth.
   std::vector<SmallVector<AffineForOp, 2>> depthToLoops;
-  gatherLoops(getFunction(), depthToLoops);
+  gatherLoops(getOperation(), depthToLoops);
   assert(!depthToLoops.empty() && "Loop nest not found");
 
   // Only support tests with a single loop nest and a single innermost loop
   // for now.
   unsigned innermostLoopIdx = depthToLoops.size() - 1;
   if (depthToLoops[0].size() != 1 || depthToLoops[innermostLoopIdx].size() != 1)
     return;
 

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

 #include "mlir/Transforms/LoopUtils.h"
 
 using namespace mlir;
 
 #define DEBUG_TYPE "test-affine-parametric-tile"
 
 namespace {
 struct TestAffineLoopParametricTiling
-    : public PassWrapper<TestAffineLoopParametricTiling, FunctionPass> {
+    : public PassWrapper<TestAffineLoopParametricTiling,
+                         OperationPass<FuncOp>> {
   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;
+  void runOnOperation() override;
 };
 } // 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) {
   assert(!band.empty() && "no loops in input band");
for (BlockArgument blockArgument :
     if (blockArgument.getArgNumber() < nestDepth) {
       assert(blockArgument.getType().isIndex() &&
              "expected tiling parameters to be of index type.");
       tilingParameters.push_back(blockArgument);
     }
   }
 }
 
-void TestAffineLoopParametricTiling::runOnFunction() {
+void TestAffineLoopParametricTiling::runOnOperation() {
   // Bands of loops to tile.
   std::vector<SmallVector<AffineForOp, 6>> bands;
-  getTileableBands(getFunction(), &bands);
+  getTileableBands(getOperation(), &bands);
 
   // Tile each band.
   for (MutableArrayRef<AffineForOp> band : bands) {
     // Capture the tiling parameters from the arguments to the function
     // enclosing this loop nest.
     SmallVector<AffineForOp, 6> tiledNest;
     SmallVector<Value, 6> tilingParameters;
     // Check if tiling parameters are present.

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

 #define PASS_NAME "test-affine-loop-unswitch"
 
 using namespace mlir;
 
 namespace {
 
 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestAffineLoopUnswitching
-    : public PassWrapper<TestAffineLoopUnswitching, FunctionPass> {
+    : public PassWrapper<TestAffineLoopUnswitching, OperationPass<FuncOp>> {
   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) = default;
 
-  void runOnFunction() override;
+  void runOnOperation() override;
 
   /// The maximum number of iterations to run this for.
   constexpr static unsigned kMaxIterations = 5;
 };
 
 } // namespace
 
-void TestAffineLoopUnswitching::runOnFunction() {
+void TestAffineLoopUnswitching::runOnOperation() {
   // Each hoisting invalidates a lot of IR around. Just stop the walk after the
   // first if/else hoisting, and repeat until no more hoisting can be done, or
   // the maximum number of iterations have been run.
-  auto func = getFunction();
+  auto func = getOperation();
   unsigned i = 0;
   do {
     auto walkFn = [](AffineIfOp op) {
       return succeeded(hoistAffineIfOp(op)) ? WalkResult::interrupt()
                                             : WalkResult::advance();
     };
     if (func.walk(walkFn).wasInterrupted())
       break;
   } while (++i < kMaxIterations);
 }
 
 namespace mlir {
 void registerTestAffineLoopUnswitchingPass() {
   PassRegistration<TestAffineLoopUnswitching>();
 }
 } // namespace mlir

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

 using namespace mlir;
 
 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> {
+    : public PassWrapper<TestLoopPermutation, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine loop permutation utility";
   }
   TestLoopPermutation() = default;
   TestLoopPermutation(const TestLoopPermutation &pass) : PassWrapper(pass){};
 
-  void runOnFunction() override;
+  void runOnOperation() override;
 
 private:
   /// Permutation specifying loop i is mapped to permList[i] in
   /// transformed nest (with i going from outermost to innermost).
   ListOption<unsigned> permList{*this, "permutation-map",
                                 llvm::cl::desc("Specify the loop permutation"),
                                 llvm::cl::OneOrMore, llvm::cl::CommaSeparated};
 };
 
 } // namespace
 
-void TestLoopPermutation::runOnFunction() {
+void TestLoopPermutation::runOnOperation() {
 
   SmallVector<unsigned, 4> permMap(permList.begin(), permList.end());
 
   SmallVector<AffineForOp, 2> forOps;
-  getFunction().walk([&](AffineForOp forOp) { forOps.push_back(forOp); });
+  getOperation().walk([&](AffineForOp forOp) { forOps.push_back(forOp); });
 
   for (auto forOp : forOps) {
     SmallVector<AffineForOp, 6> nest;
     // Get the maximal perfect nest.
     getPerfectlyNestedLoops(nest, forOp);
     // Permute if the nest's size is consistent with the specified
     // permutation.
     if (nest.size() >= 2 && nest.size() == permMap.size()) {

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

static llvm::cl::opt<bool> clTestVecAffineLoopNest(
     "vectorize-affine-loop-nest",
     llvm::cl::desc(
         "Enable testing for the 'vectorizeAffineLoopNest' utility by "
         "vectorizing the outermost loops found"),
     llvm::cl::cat(clOptionsCategory));
 
 namespace {
 struct VectorizerTestPass
-    : public PassWrapper<VectorizerTestPass, FunctionPass> {
+    : public PassWrapper<VectorizerTestPass, OperationPass<FuncOp>> {
   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 runOnOperation() 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);
 
   /// Test for 'vectorizeAffineLoopNest' utility.
   void testVecAffineLoopNest();
 };
 
 } // namespace
 
 void VectorizerTestPass::testVectorShapeRatio(llvm::raw_ostream &outs) {
-  auto f = getFunction();
+  auto f = getOperation();
   using matcher::Op;
   SmallVector<int64_t, 8> shape(clTestVectorShapeRatio.begin(),
                                 clTestVectorShapeRatio.end());
   auto subVectorType =
       VectorType::get(shape, FloatType::getF32(f.getContext()));
   // Only filter operations that operate on a strict super-vector and have one
   // return. This makes testing easier.
   auto filter = [&](Operation &op) {
static NestedPattern patternTestSlicingOps() {
   auto filter = [](Operation &op) {
     // Just use a custom op name for this test, it makes life easier.
     return op.getName().getStringRef() == "slicing-test-op";
   };
   return Op(filter);
 }
 
 void VectorizerTestPass::testBackwardSlicing(llvm::raw_ostream &outs) {
-  auto f = getFunction();
+  auto f = getOperation();
   outs << "\n" << f.getName();
 
   SmallVector<NestedMatch, 8> matches;
   patternTestSlicingOps().match(f, &matches);
   for (auto m : matches) {
     SetVector<Operation *> backwardSlice;
     getBackwardSlice(m.getMatchedOperation(), &backwardSlice);
     outs << "\nmatched: " << *m.getMatchedOperation()
          << " backward static slice: ";
     for (auto *op : backwardSlice)
       outs << "\n" << *op;
   }
 }
 
 void VectorizerTestPass::testForwardSlicing(llvm::raw_ostream &outs) {
-  auto f = getFunction();
+  auto f = getOperation();
   outs << "\n" << f.getName();
 
   SmallVector<NestedMatch, 8> matches;
   patternTestSlicingOps().match(f, &matches);
   for (auto m : matches) {
     SetVector<Operation *> forwardSlice;
     getForwardSlice(m.getMatchedOperation(), &forwardSlice);
     outs << "\nmatched: " << *m.getMatchedOperation()
          << " forward static slice: ";
     for (auto *op : forwardSlice)
       outs << "\n" << *op;
   }
 }
 
 void VectorizerTestPass::testSlicing(llvm::raw_ostream &outs) {
-  auto f = getFunction();
+  auto f = getOperation();
   outs << "\n" << f.getName();
 
   SmallVector<NestedMatch, 8> matches;
   patternTestSlicingOps().match(f, &matches);
   for (auto m : matches) {
     SetVector<Operation *> staticSlice = getSlice(m.getMatchedOperation());
     outs << "\nmatched: " << *m.getMatchedOperation() << " static slice: ";
     for (auto *op : staticSlice)
       outs << "\n" << *op;
   }
 }
 
 static bool customOpWithAffineMapAttribute(Operation &op) {
   return op.getName().getStringRef() ==
          VectorizerTestPass::kTestAffineMapOpName;
 }
 
 void VectorizerTestPass::testComposeMaps(llvm::raw_ostream &outs) {
-  auto f = getFunction();
+  auto f = getOperation();
 
   using matcher::Op;
   auto pattern = Op(customOpWithAffineMapAttribute);
   SmallVector<NestedMatch, 8> matches;
   pattern.match(f, &matches);
   SmallVector<AffineMap, 4> maps;
   maps.reserve(matches.size());
   for (auto m : llvm::reverse(matches)) {
     auto *opInst = m.getMatchedOperation();
     auto map = opInst->getAttr(VectorizerTestPass::kTestAffineMapAttrName)
                    .cast<AffineMapAttr>()
                    .getValue();
     maps.push_back(map);
   }
   AffineMap res;
   for (auto m : maps) {
     res = res ? res.compose(m) : m;
   }
   simplifyAffineMap(res).print(outs << "\nComposed map: ");
 }
 
 /// Test for 'vectorizeAffineLoopNest' utility.
 void VectorizerTestPass::testVecAffineLoopNest() {
   std::vector<SmallVector<AffineForOp, 2>> loops;
-  gatherLoops(getFunction(), loops);
+  gatherLoops(getOperation(), loops);
 
   // Expected only one loop nest.
   if (loops.empty() || loops[0].size() != 1)
     return;
 
   // We vectorize the outermost loop found with VF=4.
   AffineForOp outermostLoop = loops[0][0];
   VectorizationStrategy strategy;
   strategy.vectorSizes.push_back(4 /*vectorization factor*/);
   strategy.loopToVectorDim[outermostLoop] = 0;
   std::vector<SmallVector<AffineForOp, 2>> loopsToVectorize;
   loopsToVectorize.push_back({outermostLoop});
   (void)vectorizeAffineLoopNest(loopsToVectorize, strategy);
 }
 
-void VectorizerTestPass::runOnFunction() {
+void VectorizerTestPass::runOnOperation() {
   // Only support single block functions at this point.
-  FuncOp f = getFunction();
+  FuncOp f = getOperation();
   if (!llvm::hasSingleElement(f))
     return;
 
   std::string str;
   llvm::raw_string_ostream outs(str);
 
   { // Tests that expect a NestedPatternContext to be allocated externally.
     NestedPatternContext mlContext;

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

 using namespace mlir;
 
 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> {
+    : public PassWrapper<TestDataLayoutQuery, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-data-layout-query"; }
   StringRef getDescription() const final { return "Test data layout queries"; }
-  void runOnFunction() override {
-    FuncOp func = getFunction();
+  void runOnOperation() override {
+    FuncOp func = getOperation();
     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"))
         return;
 

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

 using namespace mlir;
 using namespace mlir::linalg;
 using namespace mlir::linalg::comprehensive_bufferize;
 
 namespace {
 /// A helper struct for FunctionBufferize and ModuleBufferize. Both passes are
 /// mostly identical.
 struct TestComprehensiveFunctionBufferize
-    : public PassWrapper<TestComprehensiveFunctionBufferize, FunctionPass> {
+    : public PassWrapper<TestComprehensiveFunctionBufferize,
+                         OperationPass<FuncOp>> {
   StringRef getArgument() const final {
     return "test-comprehensive-function-bufferize";
   }
 
   StringRef getDescription() const final {
     return "Test Comprehensive Bufferize of FuncOps (body only).";
   }
 
void getDependentDialects(DialectRegistry &registry) const override {
     bufferization_ext::registerBufferizableOpInterfaceExternalModels(registry);
     linalg_ext::registerBufferizableOpInterfaceExternalModels(registry);
     scf_ext::registerBufferizableOpInterfaceExternalModels(registry);
     std_ext::registerBufferizableOpInterfaceExternalModels(registry);
     tensor_ext::registerBufferizableOpInterfaceExternalModels(registry);
     vector_ext::registerBufferizableOpInterfaceExternalModels(registry);
   }
 
-  void runOnFunction() override;
+  void runOnOperation() override;
 
   Option<bool> allowReturnMemref{
       *this, "allow-return-memref",
       llvm::cl::desc("Allow returning/yielding memrefs from functions/blocks"),
       llvm::cl::init(false)};
   Option<bool> allowUnknownOps{
       *this, "allow-unknown-ops",
       llvm::cl::desc(
ListOption<std::string> dialectFilter{
       llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated};
   Option<bool> createDeallocs{
       *this, "create-deallocs",
       llvm::cl::desc("Specify if buffers should be deallocated"),
       llvm::cl::init(true)};
 };
 } // namespace
 
-void TestComprehensiveFunctionBufferize::runOnFunction() {
+void TestComprehensiveFunctionBufferize::runOnOperation() {
   auto options = std::make_unique<BufferizationOptions>();
 
   if (!allowReturnMemref)
     options->addPostAnalysisStep<scf_ext::AssertDestinationPassingStyle>();
 
   options->allowReturnMemref = allowReturnMemref;
   options->allowUnknownOps = allowUnknownOps;
   options->testAnalysisOnly = testAnalysisOnly;
   options->analysisFuzzerSeed = analysisFuzzerSeed;
   options->createDeallocs = createDeallocs;
 
   if (dialectFilter.hasValue()) {
     options->dialectFilter.emplace();
     for (const std::string &dialectNamespace : dialectFilter)
       options->dialectFilter->insert(dialectNamespace);
   }
 
-  Operation *op = getFunction().getOperation();
+  Operation *op = getOperation().getOperation();
   if (failed(runComprehensiveBufferize(op, std::move(options))))
     return;
 
   if (testAnalysisOnly)
     return;
 
   OpPassManager cleanupPipeline("builtin.func");
   cleanupPipeline.addPass(createCanonicalizerPass());

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> {
+    : public PassWrapper<TestLinalgCodegenStrategy, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-linalg-codegen-strategy"; }
   StringRef getDescription() const final {
     return "Test Linalg Codegen Strategy.";
   }
   TestLinalgCodegenStrategy() = default;
   TestLinalgCodegenStrategy(const TestLinalgCodegenStrategy &pass)
       : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     // clang-format off
     registry.insert<AffineDialect,
                     gpu::GPUDialect,
                     linalg::LinalgDialect,
                     memref::MemRefDialect,
                     scf::SCFDialect,
                     StandardOpsDialect,
                     vector::VectorDialect>();
     // clang-format on
   }
 
   template <typename LinalgNamedOp>
   void applyStrategyToNamedLinalgOp();
 
-  void runOnFunction() override;
+  void runOnOperation() override;
 
   void runStrategy(const LinalgTilingAndFusionOptions &tilingAndFusionOptions,
                    const LinalgTilingOptions &tilingOptions,
                    const LinalgTilingOptions &registerTilingOptions,
                    LinalgPaddingOptions paddingOptions,
                    vector::VectorContractLowering vectorContractLowering,
                    vector::VectorTransferSplit vectorTransferSplit);
 
strategy
                       .setVectorTransferSplit(vectorTransferSplit))
               .setVectorTransferToSCFOptions(
                   VectorTransferToSCFOptions().enableFullUnroll(
                       unrollVectorTransfers))
               .enableTransferPartialRewrite()
               .enableContractionLowering()
               .enableTransferToSCFConversion());
   // Created a nested OpPassManager and run.
-  FuncOp funcOp = getFunction();
+  FuncOp funcOp = getOperation();
   OpPassManager dynamicPM("builtin.func");
   strategy.configurePassPipeline(dynamicPM, funcOp.getContext(), runEnablePass);
   if (failed(runPipeline(dynamicPM, funcOp)))
     return signalPassFailure();
 }
 } // namespace
 
 // For now, just assume it is the zero of type.
 // In the future, it should be the zero of type + op.
 static Value getNeutralOfLinalgOp(OpBuilder &b, OpOperand &op) {
   auto t = getElementTypeOrSelf(op.get());
   return b.create<arith::ConstantOp>(op.getOwner()->getLoc(), t,
                                      b.getZeroAttr(t));
 }
 
 /// Apply transformations specified as patterns.
-void TestLinalgCodegenStrategy::runOnFunction() {
-  if (!anchorFuncOpName.empty() && anchorFuncOpName != getFunction().getName())
+void TestLinalgCodegenStrategy::runOnOperation() {
+  if (!anchorFuncOpName.empty() && anchorFuncOpName != getOperation().getName())
     return;
 
   LinalgTilingAndFusionOptions tilingAndFusionOptions;
   tilingAndFusionOptions.tileSizes = {tileSizes.begin(), tileSizes.end()};
   tilingAndFusionOptions.tileInterchange = {tileInterchange.begin(),
                                             tileInterchange.end()};
 
   LinalgTilingOptions tilingOptions;

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

opts.procInfoMap.insert(
       std::make_pair("block_x", getGpuBlockInfo<gpu::Dimension::x>));
   opts.procInfoMap.insert(
       std::make_pair("block_y", getGpuBlockInfo<gpu::Dimension::y>));
   return opts;
 }
 
 namespace {
 struct TestLinalgDistribution
-    : public PassWrapper<TestLinalgDistribution, FunctionPass> {
+    : public PassWrapper<TestLinalgDistribution, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-linalg-distribution"; }
   StringRef getDescription() const final { return "Test Linalg distribution."; }
   TestLinalgDistribution() = default;
   TestLinalgDistribution(const TestLinalgDistribution &pass) = default;
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, gpu::GPUDialect>();
   }
 
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 } // namespace
 
-void TestLinalgDistribution::runOnFunction() {
-  auto funcOp = getFunction();
+void TestLinalgDistribution::runOnOperation() {
+  auto funcOp = getOperation();
   OwningRewritePatternList distributeTiledLoopsPatterns(&getContext());
   populateLinalgDistributeTiledLoopPattern(
       distributeTiledLoopsPatterns, getDistributionOptions(),
       LinalgTransformationFilter(
           ArrayRef<StringAttr>{},
           {StringAttr::get(funcOp.getContext(), "distributed")})
           .addFilter([](Operation *op) {
             return success(!op->getParentOfType<linalg::TiledLoopOp>());

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

static bool setFusedOpOperandLimit(const OpResult &producer,
   addOperands(consumer.getOwner(), fusedOpOperands);
   fusedOpOperands.remove(producer);
   addOperands(producer.getOwner(), fusedOpOperands);
   return fusedOpOperands.size() <= limit;
 }
 
 namespace {
 struct TestLinalgElementwiseFusion
-    : public PassWrapper<TestLinalgElementwiseFusion, FunctionPass> {
+    : public PassWrapper<TestLinalgElementwiseFusion, OperationPass<FuncOp>> {
   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 {
+  void runOnOperation() override {
     MLIRContext *context = &this->getContext();
-    FuncOp funcOp = this->getFunction();
+    FuncOp funcOp = this->getOperation();
     RewritePatternSet fusionPatterns(context);
 
     linalg::populateElementwiseOpsFusionPatterns(
         fusionPatterns,
         linalg::LinalgElementwiseFusionOptions()
             .setControlElementwiseOpsFusionFn(setFusedOpOperandLimit<4>));
 
     (void)applyPatternsAndFoldGreedily(funcOp.getBody(),
                                        std::move(fusionPatterns));
   }
 };
 
 struct TestLinalgControlFuseByExpansion
-    : public PassWrapper<TestLinalgControlFuseByExpansion, FunctionPass> {
+    : public PassWrapper<TestLinalgControlFuseByExpansion,
+                         OperationPass<FuncOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<AffineDialect, linalg::LinalgDialect, tensor::TensorDialect>();
   }
   StringRef getArgument() const final {
     return "test-linalg-control-fusion-by-expansion";
   }
   StringRef getDescription() const final {
     return "Test controlling of fusion of elementwise ops with reshape by "
            "expansion";
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext *context = &this->getContext();
-    FuncOp funcOp = this->getFunction();
+    FuncOp funcOp = this->getOperation();
     RewritePatternSet fusionPatterns(context);
 
     linalg::ControlElementwiseOpsFusionFn controlReshapeFusionFn =
         [](const OpResult &producer, OpOperand &consumer) {
           if (auto collapseOp =
                   producer.getDefiningOp<tensor::CollapseShapeOp>()) {
             if (!collapseOp.src().getDefiningOp<linalg::LinalgOp>()) {
               return false;
void runOnOperation() override {
     linalg::populateFoldReshapeOpsByExpansionPatterns(fusionPatterns,
                                                       controlReshapeFusionFn);
     (void)applyPatternsAndFoldGreedily(funcOp.getBody(),
                                        std::move(fusionPatterns));
   }
 };
 
 struct TestPushExpandingReshape
-    : public PassWrapper<TestPushExpandingReshape, FunctionPass> {
+    : public PassWrapper<TestPushExpandingReshape, OperationPass<FuncOp>> {
   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 {
+  void runOnOperation() override {
     MLIRContext *context = &this->getContext();
-    FuncOp funcOp = this->getFunction();
+    FuncOp funcOp = this->getOperation();
     RewritePatternSet patterns(context);
     linalg::populatePushReshapeOpsPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(funcOp.getBody(), std::move(patterns));
   }
 };
 } // namespace
 
 namespace test {

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

patterns.add<LinalgTileAndFusePattern<GenericOp>>(
       LinalgTransformationFilter(
           ArrayRef<StringAttr>(),
           StringAttr::get(context, "after_transpose_fusion_original")));
 }
 
 namespace {
 template <LinalgTilingLoopType LoopType>
 struct TestLinalgFusionTransforms
-    : public PassWrapper<TestLinalgFusionTransforms<LoopType>, FunctionPass> {
+    : public PassWrapper<TestLinalgFusionTransforms<LoopType>,
+                         OperationPass<FuncOp>> {
   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 {
+  void runOnOperation() override {
     MLIRContext *context = &this->getContext();
-    FuncOp funcOp = this->getFunction();
+    FuncOp funcOp = this->getOperation();
     RewritePatternSet fusionPatterns(context);
     Aliases alias;
     LinalgDependenceGraph dependenceGraph =
         LinalgDependenceGraph::buildDependenceGraph(alias, funcOp);
     fillFusionPatterns<LoopType>(context, dependenceGraph, fusionPatterns);
     (void)applyPatternsAndFoldGreedily(funcOp, std::move(fusionPatterns));
   }
 };
static LogicalResult fuseLinalgOpsGreedily(FuncOp f) {
   for (auto *e : eraseSet)
     e->erase();
 
   return changed ? success() : failure();
 }
 
 namespace {
 struct TestLinalgGreedyFusion
-    : public PassWrapper<TestLinalgGreedyFusion, FunctionPass> {
+    : public PassWrapper<TestLinalgGreedyFusion, OperationPass<FuncOp>> {
   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 {
+  void runOnOperation() override {
     MLIRContext *context = &getContext();
     RewritePatternSet patterns =
         linalg::getLinalgTilingCanonicalizationPatterns(context);
     patterns.add<ExtractSliceOfPadTensorSwapPattern>(context);
     scf::populateSCFForLoopCanonicalizationPatterns(patterns);
     FrozenRewritePatternSet frozenPatterns(std::move(patterns));
     do {
-      (void)applyPatternsAndFoldGreedily(getFunction(), frozenPatterns);
+      (void)applyPatternsAndFoldGreedily(getOperation(), frozenPatterns);
       PassManager pm(context);
       pm.addPass(createLoopInvariantCodeMotionPass());
       pm.addPass(createCanonicalizerPass());
       pm.addPass(createCSEPass());
-      LogicalResult res = pm.run(getFunction()->getParentOfType<ModuleOp>());
+      LogicalResult res = pm.run(getOperation()->getParentOfType<ModuleOp>());
       if (failed(res))
         this->signalPassFailure();
-    } while (succeeded(fuseLinalgOpsGreedily(getFunction())));
+    } while (succeeded(fuseLinalgOpsGreedily(getOperation())));
   }
 };
 
 /// Pass to test tile and fuse of sequence of operations. Intended only for
 /// testing.
 struct TestLinalgTileAndFuseSequencePass
-    : public PassWrapper<TestLinalgTileAndFuseSequencePass, FunctionPass> {
+    : public PassWrapper<TestLinalgTileAndFuseSequencePass,
+                         OperationPass<FuncOp>> {
   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)
       : PassWrapper(pass){};
 
   ListOption<int64_t> tileSizes{
       *this, "tile-sizes", llvm::cl::desc("Tile sizes to use for ops"),
       llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated};
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect>();
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     FuncOp funcOp = getOperation();
     auto &blocks = funcOp.getBody().getBlocks();
     if (!llvm::hasSingleElement(blocks)) {
       return;
     }
     SmallVector<LinalgOp, 2> linalgOps =
         llvm::to_vector<2>(blocks.front().getOps<LinalgOp>());
     Aliases aliases;

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

 #include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgHoisting
-    : public PassWrapper<TestLinalgHoisting, FunctionPass> {
+    : public PassWrapper<TestLinalgHoisting, OperationPass<FuncOp>> {
   TestLinalgHoisting() = default;
   TestLinalgHoisting(const TestLinalgHoisting &pass) : PassWrapper(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;
+  void runOnOperation() override;
 
   Option<bool> testHoistRedundantTransfers{
       *this, "test-hoist-redundant-transfers",
       llvm::cl::desc("Test hoisting transfer_read/transfer_write pairs"),
       llvm::cl::init(false)};
 };
 } // namespace
 
-void TestLinalgHoisting::runOnFunction() {
+void TestLinalgHoisting::runOnOperation() {
   if (testHoistRedundantTransfers) {
-    hoistRedundantVectorTransfers(getFunction());
-    hoistRedundantVectorTransfersOnTensor(getFunction());
+    hoistRedundantVectorTransfers(getOperation());
+    hoistRedundantVectorTransfersOnTensor(getOperation());
     return;
   }
 }
 
 namespace mlir {
 namespace test {
 void registerTestLinalgHoisting() { PassRegistration<TestLinalgHoisting>(); }
 } // namespace test
 } // namespace mlir

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

 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgTransforms
-    : public PassWrapper<TestLinalgTransforms, FunctionPass> {
+    : public PassWrapper<TestLinalgTransforms, OperationPass<FuncOp>> {
   TestLinalgTransforms() = default;
   TestLinalgTransforms(const TestLinalgTransforms &pass) : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     // clang-format off
     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;
+  void runOnOperation() 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",
       llvm::cl::desc(
           "Test a fused pass that applies patterns from matmul to vectors via "
static void applyTiledLoopPeelingPattern(FuncOp funcOp,
   // Drop the markers.
   funcOp.walk([](TiledLoopOp op) {
     op->removeAttr(kPeeledLoopsLabel);
     op->removeAttr(kPartialIterationLabel);
   });
 }
 
 /// Apply transformations specified as patterns.
-void TestLinalgTransforms::runOnFunction() {
+void TestLinalgTransforms::runOnOperation() {
   auto lambda = [&](void *) {
-    getFunction().walk([](LinalgOp op) {
+    getOperation().walk([](LinalgOp op) {
       op->removeAttr(LinalgTransforms::kLinalgTransformMarker);
     });
   };
   std::unique_ptr<void, decltype(lambda)> cleanupGuard{(void *)1, lambda};
 
   if (testPromotionOptions) {
     RewritePatternSet patterns(&getContext());
     fillPromotionCallBackPatterns(&getContext(), patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
     return;
   }
   if (testTileAndDistributionOptions) {
     RewritePatternSet patterns(&getContext());
     fillTileAndDistributePatterns(&getContext(), patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
     return;
   }
   if (testPatterns)
-    return applyPatterns(getFunction());
+    return applyPatterns(getOperation());
   if (testMatmulToVectorPatterns1dTiling || testMatmulToVectorPatterns2dTiling)
-    return applyMatmulToVectorPatterns(getFunction(),
+    return applyMatmulToVectorPatterns(getOperation(),
                                        testMatmulToVectorPatterns1dTiling,
                                        testMatmulToVectorPatterns2dTiling);
   if (testVectorTransferForwardingPatterns)
-    return applyVectorTransferForwardingPatterns(getFunction());
+    return applyVectorTransferForwardingPatterns(getOperation());
   if (testGenericToVectorPattern)
-    return applyLinalgToVectorPatterns(getFunction());
+    return applyLinalgToVectorPatterns(getOperation());
   if (testTransformPadTensor)
-    return applyPadTensorToGenericPatterns(getFunction());
+    return applyPadTensorToGenericPatterns(getOperation());
   if (testGeneralizePadTensor)
-    return applyGeneralizePadTensorPatterns(getFunction());
+    return applyGeneralizePadTensorPatterns(getOperation());
   if (testSwapSubTensorPadTensor)
-    return applyExtractSliceOfPadTensorSwapPattern(getFunction());
+    return applyExtractSliceOfPadTensorSwapPattern(getOperation());
   if (testTiledLoopPeeling.hasValue())
-    return applyTiledLoopPeelingPattern(getFunction(), testTiledLoopPeeling,
+    return applyTiledLoopPeelingPattern(getOperation(), testTiledLoopPeeling,
                                         skipPartial);
   if (testTilePattern)
-    return applyTilePattern(getFunction(), loopType, tileSizes, peeledLoops,
+    return applyTilePattern(getOperation(), loopType, tileSizes, peeledLoops,
                             /*scalarizeDynamicDims=*/false);
   if (testTileScalarizeDynamicDims)
-    return applyTilePattern(getFunction(), loopType, tileSizes,
+    return applyTilePattern(getOperation(), loopType, tileSizes,
                             /*peeledLoops=*/{}, /*scalarizeDynamicDims=*/true);
 }
 
 namespace mlir {
 namespace test {
 void registerTestLinalgTransforms() {
   PassRegistration<TestLinalgTransforms>();
 }
 } // namespace test
 } // namespace mlir

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

 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 namespace mlir {
 
 namespace {
-struct TestPadFusionPass : public PassWrapper<TestPadFusionPass, FunctionPass> {
+struct TestPadFusionPass
+    : public PassWrapper<TestPadFusionPass, OperationPass<FuncOp>> {
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<AffineDialect, linalg::LinalgDialect, tensor::TensorDialect>();
   }
 
   StringRef getArgument() const final { return "test-linalg-pad-fusion"; }
   StringRef getDescription() const final { return "Test PadOp fusion"; }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext *context = &getContext();
-    FuncOp funcOp = getFunction();
+    FuncOp funcOp = getOperation();
     RewritePatternSet patterns(context);
     linalg::populateFusePadTensorWithProducerLinalgOpPatterns(patterns);
     if (failed(applyPatternsAndFoldGreedily(funcOp.getBody(),
                                             std::move(patterns))))
       return signalPassFailure();
   }
 };
 } // namespace
 
 namespace test {
 void registerTestPadFusion() { PassRegistration<TestPadFusionPass>(); }
 } // namespace test
 
 } // namespace mlir

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

 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 struct TestMathAlgebraicSimplificationPass
-    : public PassWrapper<TestMathAlgebraicSimplificationPass, FunctionPass> {
-  void runOnFunction() override;
+    : public PassWrapper<TestMathAlgebraicSimplificationPass,
+                         OperationPass<FuncOp>> {
+  void runOnOperation() override;
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<vector::VectorDialect, math::MathDialect>();
   }
   StringRef getArgument() const final {
     return "test-math-algebraic-simplification";
   }
   StringRef getDescription() const final {
     return "Test math algebraic simplification";
   }
 };
 } // namespace
 
-void TestMathAlgebraicSimplificationPass::runOnFunction() {
+void TestMathAlgebraicSimplificationPass::runOnOperation() {
   RewritePatternSet patterns(&getContext());
   populateMathAlgebraicSimplificationPatterns(patterns);
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 namespace test {
 void registerTestMathAlgebraicSimplificationPass() {
   PassRegistration<TestMathAlgebraicSimplificationPass>();
 }
 } // namespace test
 } // namespace mlir

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

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

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

 #include "mlir/Dialect/X86Vector/X86VectorDialect.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 struct TestMathPolynomialApproximationPass
-    : public PassWrapper<TestMathPolynomialApproximationPass, FunctionPass> {
+    : public PassWrapper<TestMathPolynomialApproximationPass,
+                         OperationPass<FuncOp>> {
   TestMathPolynomialApproximationPass() = default;
   TestMathPolynomialApproximationPass(
       const TestMathPolynomialApproximationPass &pass)
       : PassWrapper(pass) {}
 
-  void runOnFunction() override;
+  void runOnOperation() override;
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, math::MathDialect,
                     vector::VectorDialect>();
     if (enableAvx2)
       registry.insert<x86vector::X86VectorDialect>();
   }
   StringRef getArgument() const final {
     return "test-math-polynomial-approximation";
   }
   StringRef getDescription() const final {
     return "Test math polynomial approximations";
   }
 
   Option<bool> enableAvx2{
       *this, "enable-avx2",
       llvm::cl::desc("Enable approximations that emit AVX2 intrinsics via the "
                      "X86Vector dialect"),
       llvm::cl::init(false)};
 };
 } // namespace
 
-void TestMathPolynomialApproximationPass::runOnFunction() {
+void TestMathPolynomialApproximationPass::runOnOperation() {
   RewritePatternSet patterns(&getContext());
   MathPolynomialApproximationOptions approxOptions;
   approxOptions.enableAvx2 = enableAvx2;
   populateMathPolynomialApproximationPatterns(patterns, approxOptions);
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 namespace test {
 void registerTestMathPolynomialApproximationPass() {
   PassRegistration<TestMathPolynomialApproximationPass>();
 }
 } // namespace test
 } // namespace mlir

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

 #include "mlir/Transforms/Passes.h"
 
 #include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 
 namespace {
 class TestSCFForUtilsPass
-    : public PassWrapper<TestSCFForUtilsPass, FunctionPass> {
+    : public PassWrapper<TestSCFForUtilsPass, OperationPass<FuncOp>> {
 public:
   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();
+  void runOnOperation() override {
+    FuncOp func = getOperation();
     SmallVector<scf::ForOp, 4> toErase;
 
     func.walk([&](Operation *fakeRead) {
       if (fakeRead->getName().getStringRef() != "fake_read")
         return;
       auto *fakeCompute = fakeRead->getResult(0).use_begin()->getOwner();
       auto *fakeWrite = fakeCompute->getResult(0).use_begin()->getOwner();
       auto loop = fakeRead->getParentOfType<scf::ForOp>();
static const StringLiteral kTestPipeliningLoopMarker =
     "__test_pipelining_loop__";
 static const StringLiteral kTestPipeliningStageMarker =
     "__test_pipelining_stage__";
 /// Marker to express the order in which operations should be after pipelining.
 static const StringLiteral kTestPipeliningOpOrderMarker =
     "__test_pipelining_op_order__";
 
 class TestSCFPipeliningPass
-    : public PassWrapper<TestSCFPipeliningPass, FunctionPass> {
+    : public PassWrapper<TestSCFPipeliningPass, OperationPass<FuncOp>> {
 public:
   StringRef getArgument() const final { return "test-scf-pipelining"; }
   StringRef getDescription() const final { return "test scf.forOp pipelining"; }
   explicit TestSCFPipeliningPass() = default;
 
   static void
   getSchedule(scf::ForOp forOp,
               std::vector<std::pair<Operation *, unsigned>> &schedule) {
forOp.walk([&schedule](Operation *op) {
       }
     });
   }
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, StandardOpsDialect>();
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     mlir::scf::PipeliningOption options;
     options.getScheduleFn = getSchedule;
 
     scf::populateSCFLoopPipeliningPatterns(patterns, options);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
-    getFunction().walk([](Operation *op) {
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
+    getOperation().walk([](Operation *op) {
       // Clean up the markers.
       op->removeAttr(kTestPipeliningStageMarker);
       op->removeAttr(kTestPipeliningOpOrderMarker);
     });
   }
 };
 } // namespace
 

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;
+    : public PassWrapper<PrintOpAvailability, OperationPass<FuncOp>> {
+  void runOnOperation() override;
   StringRef getArgument() const final { return "test-spirv-op-availability"; }
   StringRef getDescription() const final {
     return "Test SPIR-V op availability";
   }
 };
 } // namespace
 
-void PrintOpAvailability::runOnFunction() {
-  auto f = getFunction();
+void PrintOpAvailability::runOnOperation() {
+  auto f = getOperation();
   llvm::outs() << f.getName() << "\n";
 
   Dialect *spvDialect = getContext().getLoadedDialect("spv");
 
   f->walk([&](Operation *op) {
     if (op->getDialect() != spvDialect)
       return WalkResult::advance();
 

 
 //===----------------------------------------------------------------------===//
 // Converting target environment pass
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A pass for testing SPIR-V op availability.
 struct ConvertToTargetEnv
-    : public PassWrapper<ConvertToTargetEnv, FunctionPass> {
+    : public PassWrapper<ConvertToTargetEnv, OperationPass<FuncOp>> {
   StringRef getArgument() const override { return "test-spirv-target-env"; }
   StringRef getDescription() const override {
     return "Test SPIR-V target environment";
   }
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
 struct ConvertToAtomCmpExchangeWeak : public RewritePattern {
   ConvertToAtomCmpExchangeWeak(MLIRContext *context);
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const override;
 };
 

 
 struct ConvertToSubgroupBallot : public RewritePattern {
   ConvertToSubgroupBallot(MLIRContext *context);
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const override;
 };
 } // namespace
 
-void ConvertToTargetEnv::runOnFunction() {
+void ConvertToTargetEnv::runOnOperation() {
   MLIRContext *context = &getContext();
-  FuncOp fn = getFunction();
+  FuncOp fn = getOperation();
 
   auto targetEnv = fn.getOperation()
                        ->getAttr(spirv::getTargetEnvAttrName())
                        .cast<spirv::TargetEnvAttr>();
   if (!targetEnv) {
     fn.emitError("missing 'spv.target_env' attribute");
     return signalPassFailure();
   }

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

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

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

LogicalResult matchAndRewrite(TestCastOp op,
     auto constOp = rewriter.create<arith::ConstantOp>(
         op.getLoc(), rewriter.getBoolAttr(true));
     rewriter.replaceOpWithNewOp<TestCastOp>(op, rewriter.getI32Type(),
                                             Value(constOp));
     return success();
   }
 };
 
-struct TestPatternDriver : public PassWrapper<TestPatternDriver, FunctionPass> {
+struct TestPatternDriver
+    : public PassWrapper<TestPatternDriver, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-patterns"; }
   StringRef getDescription() const final { return "Run test dialect patterns"; }
-  void runOnFunction() override {
+  void runOnOperation() override {
     mlir::RewritePatternSet patterns(&getContext());
     populateWithGenerated(patterns);
 
     // Verify named pattern is generated with expected name.
     patterns.add<FoldingPattern, TestNamedPatternRule,
                  FolderInsertBeforePreviouslyFoldedConstantPattern>(
         &getContext());
 
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // ReturnType Driver.
 //===----------------------------------------------------------------------===//
 
if (failed(shapedOp.reifyReturnTypeShapes(b, op->getOperands(), shapes)) ||
     return;
   for (const auto &it : llvm::enumerate(shapes)) {
     op->emitRemark() << "value " << it.index() << ": "
                      << it.value().getDefiningOp();
   }
 }
 
 struct TestReturnTypeDriver
-    : public PassWrapper<TestReturnTypeDriver, FunctionPass> {
+    : public PassWrapper<TestReturnTypeDriver, OperationPass<FuncOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<tensor::TensorDialect>();
   }
   StringRef getArgument() const final { return "test-return-type"; }
   StringRef getDescription() const final { return "Run return type functions"; }
 
-  void runOnFunction() override {
-    if (getFunction().getName() == "testCreateFunctions") {
+  void runOnOperation() override {
+    if (getOperation().getName() == "testCreateFunctions") {
       std::vector<Operation *> ops;
       // Collect ops to avoid triggering on inserted ops.
-      for (auto &op : getFunction().getBody().front())
+      for (auto &op : getOperation().getBody().front())
         ops.push_back(&op);
       // Generate test patterns for each, but skip terminator.
       for (auto *op : llvm::makeArrayRef(ops).drop_back()) {
         // Test create method of each of the Op classes below. The resultant
         // output would be in reverse order underneath `op` from which
         // the attributes and regions are used.
         invokeCreateWithInferredReturnType<OpWithInferTypeInterfaceOp>(op);
         invokeCreateWithInferredReturnType<
             OpWithShapedTypeInferTypeInterfaceOp>(op);
       };
       return;
     }
-    if (getFunction().getName() == "testReifyFunctions") {
+    if (getOperation().getName() == "testReifyFunctions") {
       std::vector<Operation *> ops;
       // Collect ops to avoid triggering on inserted ops.
-      for (auto &op : getFunction().getBody().front())
+      for (auto &op : getOperation().getBody().front())
         if (isa<OpWithShapedTypeInferTypeInterfaceOp>(op))
           ops.push_back(&op);
       // Generate test patterns for each, but skip terminator.
       for (auto *op : ops)
         reifyReturnShape(op);
     }
   }
 };
 } // namespace
 
 namespace {
 struct TestDerivedAttributeDriver
-    : public PassWrapper<TestDerivedAttributeDriver, FunctionPass> {
+    : public PassWrapper<TestDerivedAttributeDriver, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-derived-attr"; }
   StringRef getDescription() const final {
     return "Run test derived attributes";
   }
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 } // namespace
 
-void TestDerivedAttributeDriver::runOnFunction() {
-  getFunction().walk([](DerivedAttributeOpInterface dOp) {
+void TestDerivedAttributeDriver::runOnOperation() {
+  getOperation().walk([](DerivedAttributeOpInterface dOp) {
     auto dAttr = dOp.materializeDerivedAttributes();
     if (!dAttr)
       return;
     for (auto d : dAttr)
       dOp.emitRemark() << d.getName().getValue() << " = " << d.getValue();
   });
 }
 
matchAndRewrite(TestRemappedValueRegionOp op, OpAdaptor adaptor,
 
     rewriter.eraseOp(terminator);
     rewriter.replaceOp(op, terminatorOperands);
     return success();
   }
 };
 
 struct TestRemappedValue
-    : public mlir::PassWrapper<TestRemappedValue, FunctionPass> {
+    : public mlir::PassWrapper<TestRemappedValue, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-remapped-value"; }
   StringRef getDescription() const final {
     return "Test public remapped value mechanism in ConversionPatternRewriter";
   }
-  void runOnFunction() override {
+  void runOnOperation() override {
     TestRemapValueTypeConverter typeConverter;
 
     mlir::RewritePatternSet patterns(&getContext());
     patterns.add<OneVResOneVOperandOp1Converter>(&getContext());
     patterns.add<TestChangeProducerTypeF32ToF64, TestUpdateConsumerType>(
         &getContext());
     patterns.add<TestRemapValueInRegion>(typeConverter, &getContext());
 
     mlir::ConversionTarget target(getContext());
     target.addLegalOp<ModuleOp, FuncOp, TestReturnOp>();
 
     // Expect the type_producer/type_consumer operations to only operate on f64.
     target.addDynamicallyLegalOp<TestTypeProducerOp>(
         [](TestTypeProducerOp op) { return op.getType().isF64(); });
     target.addDynamicallyLegalOp<TestTypeConsumerOp>([](TestTypeConsumerOp op) {
       return op.getOperand().getType().isF64();
     });
 
     // We make OneVResOneVOperandOp1 legal only when it has more that one
     // operand. This will trigger the conversion that will replace one-operand
     // OneVResOneVOperandOp1 with two-operand OneVResOneVOperandOp1.
     target.addDynamicallyLegalOp<OneVResOneVOperandOp1>(
         [](Operation *op) { return op->getNumOperands() > 1; });
 
-    if (failed(mlir::applyFullConversion(getFunction(), target,
+    if (failed(mlir::applyFullConversion(getOperation(), target,
                                          std::move(patterns)))) {
       signalPassFailure();
     }
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
LogicalResult matchAndRewrite(Operation *op,
     if (!isa<TestDialect>(op->getDialect()))
       return failure();
     rewriter.eraseOp(op);
     return success();
   }
 };
 
 struct TestUnknownRootOpDriver
-    : public mlir::PassWrapper<TestUnknownRootOpDriver, FunctionPass> {
+    : public mlir::PassWrapper<TestUnknownRootOpDriver, OperationPass<FuncOp>> {
   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 {
+  void runOnOperation() override {
     mlir::RewritePatternSet patterns(&getContext());
     patterns.add<RemoveTestDialectOps>(&getContext());
 
     mlir::ConversionTarget target(getContext());
     target.addIllegalDialect<TestDialect>();
-    if (failed(
-            applyPartialConversion(getFunction(), target, std::move(patterns))))
+    if (failed(applyPartialConversion(getOperation(), target,
+                                      std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Test type conversions
 //===----------------------------------------------------------------------===//

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> {
+struct TestTraitFolder
+    : public PassWrapper<TestTraitFolder, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-trait-folder"; }
   StringRef getDescription() const final { return "Run trait folding"; }
-  void runOnFunction() override {
-    (void)applyPatternsAndFoldGreedily(getFunction(),
+  void runOnOperation() override {
+    (void)applyPatternsAndFoldGreedily(getOperation(),
                                        RewritePatternSet(&getContext()));
   }
 };
 } // namespace
 
 namespace mlir {
 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> {
+    : public PassWrapper<TosaTestQuantUtilAPI, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "TOSA Test: Exercise the APIs in QuantUtils.cpp.";
   }
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
-void TosaTestQuantUtilAPI::runOnFunction() {
+void TosaTestQuantUtilAPI::runOnOperation() {
   auto *ctx = &getContext();
   RewritePatternSet patterns(ctx);
-  auto func = getFunction();
+  auto func = getOperation();
 
   patterns.add<ConvertTosaNegateOp>(ctx);
   patterns.add<ConvertTosaConv2DOp>(ctx);
   (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
 }
 
 } // namespace
 
 namespace mlir {
 void registerTosaTestQuantUtilAPIPass() {
   PassRegistration<TosaTestQuantUtilAPI>();
 }
 } // namespace mlir

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

 
 using namespace mlir;
 using namespace mlir::linalg;
 using namespace mlir::vector;
 
 namespace {
 
 struct TestVectorToVectorLowering
-    : public PassWrapper<TestVectorToVectorLowering, FunctionPass> {
+    : public PassWrapper<TestVectorToVectorLowering, OperationPass<FuncOp>> {
   TestVectorToVectorLowering() = default;
   TestVectorToVectorLowering(const TestVectorToVectorLowering &pass)
       : PassWrapper(pass) {}
   StringRef getArgument() const final {
     return "test-vector-to-vector-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering 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)};
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     auto *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     if (unroll) {
       populateVectorUnrollPatterns(
           patterns,
           UnrollVectorOptions().setNativeShapeFn(getShape).setFilterConstraint(
               filter));
     }
     populateVectorToVectorCanonicalizationPatterns(patterns);
     populateBubbleVectorBitCastOpPatterns(patterns);
     populateCastAwayVectorLeadingOneDimPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 
 private:
   // Return the target shape based on op type.
   static Optional<SmallVector<int64_t, 4>> getShape(Operation *op) {
     if (isa<arith::AddFOp, SelectOp, arith::CmpFOp>(op))
       return SmallVector<int64_t, 4>(2, 2);
     if (isa<vector::ContractionOp>(op))
private:
 
   static LogicalResult filter(Operation *op) {
     return success(isa<arith::AddFOp, SelectOp, arith::CmpFOp, ContractionOp,
                        TransferReadOp, TransferWriteOp>(op));
   }
 };
 
 struct TestVectorContractionLowering
-    : public PassWrapper<TestVectorContractionLowering, FunctionPass> {
+    : public PassWrapper<TestVectorContractionLowering, OperationPass<FuncOp>> {
   StringRef getArgument() const final {
     return "test-vector-contraction-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns that lower contract ops in the vector "
            "dialect";
   }
   TestVectorContractionLowering() = default;
Option<bool> lowerToOuterProduct{
       llvm::cl::desc("Lower vector.contract to vector.outerproduct"),
       llvm::cl::init(false)};
   Option<bool> lowerToFilterOuterProduct{
       *this, "vector-filter-outerproduct",
       llvm::cl::desc("Lower vector.contract to vector.outerproduct but not for "
                      "vectors of size 4."),
       llvm::cl::init(false)};
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
 
     // Test on one pattern in isolation.
     if (lowerToOuterProduct) {
       VectorContractLowering lowering = VectorContractLowering::OuterProduct;
       VectorTransformsOptions options{lowering};
       patterns.add<ContractionOpToOuterProductOpLowering>(options,
                                                           &getContext());
-      (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+      (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
       return;
     }
 
     // Test on one pattern in isolation.
     if (lowerToFilterOuterProduct) {
       VectorContractLowering lowering = VectorContractLowering::OuterProduct;
       VectorTransformsOptions options{lowering};
       patterns.add<ContractionOpToOuterProductOpLowering>(
           options, &getContext(), [](vector::ContractionOp op) {
             // Only lowers vector.contract where the lhs as a type vector<MxNx?>
             // where M is not 4.
             if (op.getRhsType().getShape()[0] == 4)
               return failure();
             return success();
           });
-      (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+      (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
       return;
     }
 
     // Test on all contract lowering patterns.
     VectorContractLowering contractLowering = VectorContractLowering::Dot;
     if (lowerToFlatMatrix)
       contractLowering = VectorContractLowering::Matmul;
     VectorMultiReductionLowering vectorMultiReductionLowering =
         VectorMultiReductionLowering::InnerParallel;
     VectorTransformsOptions options{contractLowering,
                                     vectorMultiReductionLowering,
                                     VectorTransposeLowering()};
     populateVectorBroadcastLoweringPatterns(patterns);
     populateVectorContractLoweringPatterns(patterns, options);
     populateVectorMaskOpLoweringPatterns(patterns);
     populateVectorShapeCastLoweringPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransposeLowering
-    : public PassWrapper<TestVectorTransposeLowering, FunctionPass> {
+    : public PassWrapper<TestVectorTransposeLowering, OperationPass<FuncOp>> {
   StringRef getArgument() const final {
     return "test-vector-transpose-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns that lower contract ops in the vector "
            "dialect";
   }
   TestVectorTransposeLowering() = default;
Option<bool> lowerToAvx2{
       *this, "avx2",
       llvm::cl::desc("Lower vector.transpose to avx2-specific patterns"),
       llvm::cl::init(false)};
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<LLVM::LLVMDialect>();
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
 
     // Test on one pattern in isolation.
     // Explicitly disable shape_cast lowering.
     LinalgVectorLoweringOptions options = LinalgVectorLoweringOptions()
                                               .enableVectorTransposeLowering()
                                               .enableShapeCastLowering(false);
     if (lowerToEltwise) {
if (lowerToAvx2) {
           x86vector::avx2::LoweringOptions().setTransposeOptions(
               x86vector::avx2::TransposeLoweringOptions()
                   .lower4x8xf32()
                   .lower8x8xf32()));
     }
 
     OpPassManager dynamicPM("builtin.func");
     dynamicPM.addPass(createLinalgStrategyLowerVectorsPass(options));
-    if (failed(runPipeline(dynamicPM, getFunction())))
+    if (failed(runPipeline(dynamicPM, getOperation())))
       return signalPassFailure();
   }
 };
 
 struct TestVectorUnrollingPatterns
-    : public PassWrapper<TestVectorUnrollingPatterns, FunctionPass> {
+    : public PassWrapper<TestVectorUnrollingPatterns, OperationPass<FuncOp>> {
   StringRef getArgument() const final {
     return "test-vector-unrolling-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to unroll contract ops in the vector "
            "dialect";
   }
   TestVectorUnrollingPatterns() = default;
   TestVectorUnrollingPatterns(const TestVectorUnrollingPatterns &pass)
       : PassWrapper(pass) {}
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     populateVectorUnrollPatterns(
         patterns, UnrollVectorOptions()
                       .setNativeShape(ArrayRef<int64_t>{2, 2})
                       .setFilterConstraint([](Operation *op) {
                         return success(isa<arith::AddFOp, vector::FMAOp>(op));
                       }));
if (unrollBasedOnType) {
       populateVectorUnrollPatterns(
           patterns, UnrollVectorOptions()
                         .setNativeShape(ArrayRef<int64_t>{2, 2, 2})
                         .setFilterConstraint([](Operation *op) {
                           return success(isa<ContractionOp>(op));
                         }));
     }
     populateVectorToVectorCanonicalizationPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 
   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> {
+    : public PassWrapper<TestVectorDistributePatterns, OperationPass<FuncOp>> {
   StringRef getArgument() const final {
     return "test-vector-distribute-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to distribute vector ops in the vector "
            "dialect";
   }
   TestVectorDistributePatterns() = default;
   TestVectorDistributePatterns(const TestVectorDistributePatterns &pass)
       : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<VectorDialect>();
     registry.insert<AffineDialect>();
   }
   ListOption<int32_t> multiplicity{
       *this, "distribution-multiplicity", llvm::cl::MiscFlags::CommaSeparated,
       llvm::cl::desc("Set the multiplicity used for distributing vector")};
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
-    FuncOp func = getFunction();
+    FuncOp func = getOperation();
     func.walk([&](arith::AddFOp op) {
       OpBuilder builder(op);
       if (auto vecType = op.getType().dyn_cast<VectorType>()) {
         SmallVector<int64_t, 2> mul;
         SmallVector<AffineExpr, 2> perm;
         SmallVector<Value, 2> ids;
         unsigned count = 0;
         // Remove the multiplicity of 1 and calculate the affine map based on
func.walk([&](arith::AddFOp op) {
         if (ops.hasValue()) {
           SmallPtrSet<Operation *, 1> extractOp({ops->extract, ops->insert});
           op.getResult().replaceAllUsesExcept(ops->insert.getResult(),
                                               extractOp);
         }
       }
     });
     populatePropagateVectorDistributionPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorToLoopPatterns
-    : public PassWrapper<TestVectorToLoopPatterns, FunctionPass> {
+    : public PassWrapper<TestVectorToLoopPatterns, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-vector-to-forloop"; }
   StringRef getDescription() const final {
     return "Test lowering patterns to break up a vector op into a for loop";
   }
   TestVectorToLoopPatterns() = default;
   TestVectorToLoopPatterns(const TestVectorToLoopPatterns &pass)
       : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<VectorDialect>();
     registry.insert<AffineDialect>();
   }
   Option<int32_t> multiplicity{
       *this, "distribution-multiplicity",
       llvm::cl::desc("Set the multiplicity used for distributing vector"),
       llvm::cl::init(32)};
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
-    FuncOp func = getFunction();
+    FuncOp func = getOperation();
     func.walk([&](arith::AddFOp op) {
       // Check that the operation type can be broken down into a loop.
       VectorType type = op.getType().dyn_cast<VectorType>();
       if (!type || type.getRank() != 1 ||
           type.getNumElements() % multiplicity != 0)
         return mlir::WalkResult::advance();
       auto filterAlloc = [](Operation *op) {
         return !isa<arith::ConstantOp, memref::AllocOp, CallOp>(op);
func.walk([&](arith::AddFOp op) {
           map);
       if (ops.hasValue()) {
         SmallPtrSet<Operation *, 1> extractOp({ops->extract, ops->insert});
         op.getResult().replaceAllUsesExcept(ops->insert.getResult(), extractOp);
       }
       return mlir::WalkResult::interrupt();
     });
     populatePropagateVectorDistributionPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferUnrollingPatterns
-    : public PassWrapper<TestVectorTransferUnrollingPatterns, FunctionPass> {
+    : public PassWrapper<TestVectorTransferUnrollingPatterns,
+                         OperationPass<FuncOp>> {
   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 lowering patterns to unroll transfer ops in the vector "
            "dialect";
   }
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     populateVectorUnrollPatterns(
         patterns,
         UnrollVectorOptions()
             .setNativeShape(ArrayRef<int64_t>{2, 2})
             .setFilterConstraint([](Operation *op) {
               return success(
                   isa<vector::TransferReadOp, vector::TransferWriteOp>(op));
             }));
     populateVectorToVectorCanonicalizationPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferFullPartialSplitPatterns
     : public PassWrapper<TestVectorTransferFullPartialSplitPatterns,
-                         FunctionPass> {
+                         OperationPass<FuncOp>> {
   StringRef getArgument() const final {
     return "test-vector-transfer-full-partial-split";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to split "
            "transfer ops via scf.if + linalg ops";
   }
   TestVectorTransferFullPartialSplitPatterns() = default;
   TestVectorTransferFullPartialSplitPatterns(
       const TestVectorTransferFullPartialSplitPatterns &pass)
       : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect>();
   }
 
   Option<bool> useLinalgOps{
       *this, "use-linalg-copy",
       llvm::cl::desc("Split using a unmasked vector.transfer + linalg.fill + "
                      "linalg.copy operations."),
       llvm::cl::init(false)};
-  void runOnFunction() override {
+  void runOnOperation() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     VectorTransformsOptions options;
     if (useLinalgOps)
       options.setVectorTransferSplit(VectorTransferSplit::LinalgCopy);
     else
       options.setVectorTransferSplit(VectorTransferSplit::VectorTransfer);
     patterns.add<VectorTransferFullPartialRewriter>(ctx, options);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferOpt
-    : public PassWrapper<TestVectorTransferOpt, FunctionPass> {
+    : public PassWrapper<TestVectorTransferOpt, OperationPass<FuncOp>> {
   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()); }
+  void runOnOperation() override { transferOpflowOpt(getOperation()); }
 };
 
 struct TestVectorTransferLoweringPatterns
-    : public PassWrapper<TestVectorTransferLoweringPatterns, FunctionPass> {
+    : public PassWrapper<TestVectorTransferLoweringPatterns,
+                         OperationPass<FuncOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<tensor::TensorDialect, memref::MemRefDialect>();
   }
   StringRef getArgument() const final {
     return "test-vector-transfer-lowering-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to lower transfer ops to other vector ops";
   }
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateVectorTransferLoweringPatterns(patterns);
     populateVectorTransferPermutationMapLoweringPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorMultiReductionLoweringPatterns
     : public PassWrapper<TestVectorMultiReductionLoweringPatterns,
-                         FunctionPass> {
+                         OperationPass<FuncOp>> {
   TestVectorMultiReductionLoweringPatterns() = default;
   TestVectorMultiReductionLoweringPatterns(
       const TestVectorMultiReductionLoweringPatterns &pass)
       : PassWrapper(pass) {}
   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 lowering patterns to lower vector.multi_reduction to other "
            "vector ops";
   }
   Option<bool> useOuterReductions{
       *this, "use-outer-reductions",
       llvm::cl::desc("Move reductions to outer most dimensions"),
       llvm::cl::init(false)};
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateVectorMultiReductionLoweringPatterns(
         patterns, useOuterReductions
                       ? vector::VectorMultiReductionLowering::InnerParallel
                       : vector::VectorMultiReductionLowering::InnerReduction);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferCollapseInnerMostContiguousDims
     : public PassWrapper<TestVectorTransferCollapseInnerMostContiguousDims,
-                         FunctionPass> {
+                         OperationPass<FuncOp>> {
   TestVectorTransferCollapseInnerMostContiguousDims() = default;
   TestVectorTransferCollapseInnerMostContiguousDims(
       const TestVectorTransferCollapseInnerMostContiguousDims &pass) = default;
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect, AffineDialect>();
   }
 
   StringRef getArgument() const final {
     return "test-vector-transfer-collapse-inner-most-dims";
   }
 
   StringRef getDescription() const final {
     return "Test lowering patterns that reducedes the rank of the vector "
            "transfer memory and vector operands.";
   }
 
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateVectorTransferCollapseInnerMostContiguousDimsPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorReduceToContractPatternsPatterns
     : public PassWrapper<TestVectorReduceToContractPatternsPatterns,
-                         FunctionPass> {
+                         OperationPass<FuncOp>> {
   StringRef getArgument() const final {
     return "test-vector-reduction-to-contract-patterns";
   }
   StringRef getDescription() const final {
     return "Test patterns to convert multireduce op to contract and combine "
            "broadcast/transpose to contract";
   }
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateVectorReductionToContractPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferDropUnitDimsPatterns
-    : public PassWrapper<TestVectorTransferDropUnitDimsPatterns, FunctionPass> {
+    : public PassWrapper<TestVectorTransferDropUnitDimsPatterns,
+                         OperationPass<FuncOp>> {
   StringRef getArgument() const final {
     return "test-vector-transfer-drop-unit-dims-patterns";
   }
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateVectorTransferDropUnitDimsPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestFlattenVectorTransferPatterns
-    : public PassWrapper<TestFlattenVectorTransferPatterns, FunctionPass> {
+    : public PassWrapper<TestFlattenVectorTransferPatterns,
+                         OperationPass<FuncOp>> {
   StringRef getArgument() const final {
     return "test-vector-transfer-flatten-patterns";
   }
   StringRef getDescription() const final {
     return "Test patterns to rewrite contiguous row-major N-dimensional "
            "vector.transfer_{read,write} ops into 1D transfers";
   }
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
-  void runOnFunction() override {
+  void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateFlattenVectorTransferPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestVectorLowerings() {

mlir/test/lib/IR/TestDominance.cpp

void printDominance(DominanceT &dominanceInfo,
     });
   }
 
 private:
   Operation *operation;
   DenseMap<Block *, size_t> blockIds;
 };
 
-struct TestDominancePass : public PassWrapper<TestDominancePass, FunctionPass> {
+struct TestDominancePass
+    : public PassWrapper<TestDominancePass, OperationPass<FuncOp>> {
   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());
+  void runOnOperation() override {
+    llvm::errs() << "Testing : " << getOperation().getName() << "\n";
+    DominanceTest dominanceTest(getOperation());
 
     // Print dominance information.
     llvm::errs() << "--- DominanceInfo ---\n";
     dominanceTest.printDominance(getAnalysis<DominanceInfo>(),
                                  /*printCommonDominatorInfo=*/true);
 
     llvm::errs() << "--- PostDominanceInfo ---\n";
     dominanceTest.printDominance(getAnalysis<PostDominanceInfo>(),

mlir/test/lib/IR/TestMatchers.cpp

 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Matchers.h"
 #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;
+struct TestMatchers : public PassWrapper<TestMatchers, OperationPass<FuncOp>> {
+  void runOnOperation() override;
   StringRef getArgument() const final { return "test-matchers"; }
   StringRef getDescription() const final {
     return "Test C++ pattern matchers.";
   }
 };
 } // namespace
 
 // This could be done better but is not worth the variadic template trouble.
void test2(FuncOp f) {
   if (p.match(lastOp))
     llvm::outs()
         << "Pattern add(add(a, constant), a) matched and bound constant to: "
         << floatAttr.getValueAsDouble() << "\n";
   if (p1.match(lastOp))
     llvm::outs() << "Pattern add(add(a, constant), a) matched\n";
 }
 
-void TestMatchers::runOnFunction() {
-  auto f = getFunction();
+void TestMatchers::runOnOperation() {
+  auto f = getOperation();
   llvm::outs() << f.getName() << "\n";
   if (f.getName() == "test1")
     test1(f);
   if (f.getName() == "test2")
     test2(f);
 }
 
 namespace mlir {
 void registerTestMatchers() { PassRegistration<TestMatchers>(); }
 } // namespace mlir

mlir/test/lib/IR/TestTypes.cpp

 #include "TestDialect.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 using namespace test;
 
 namespace {
 struct TestRecursiveTypesPass
-    : public PassWrapper<TestRecursiveTypesPass, FunctionPass> {
+    : public PassWrapper<TestRecursiveTypesPass, OperationPass<FuncOp>> {
   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();
+  void runOnOperation() override {
+    FuncOp func = getOperation();
 
     // 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.
     if (func.getName() == "create") {
       if (failed(createIRWithTypes()))
         signalPassFailure();
       return;
     }
 
     // Unknown key.
     func.emitOpError() << "unexpected function name";
     signalPassFailure();
   }
 };
 } // namespace
 
 LogicalResult TestRecursiveTypesPass::createIRWithTypes() {
   MLIRContext *ctx = &getContext();
-  FuncOp func = getFunction();
+  FuncOp func = getOperation();
   auto type = TestRecursiveType::get(ctx, "some_long_and_unique_name");
   if (failed(type.setBody(type)))
     return func.emitError("expected to be able to set the type body");
 
   // Setting the same body is fine.
   if (failed(type.setBody(type)))
     return func.emitError(
         "expected to be able to set the type body to the same value");

mlir/test/lib/Pass/TestPassManager.cpp

 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 {}
+struct TestFunctionPass
+    : public PassWrapper<TestFunctionPass, OperationPass<FuncOp>> {
+  void runOnOperation() 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> {
+class TestOptionsPass
+    : public PassWrapper<TestOptionsPass, OperationPass<FuncOp>> {
 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 {}
+  void runOnOperation() 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{

mlir/test/lib/Transforms/TestConstantFold.cpp

 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/Utils.h"
 
 using namespace mlir;
 
 namespace {
 /// Simple constant folding pass.
-struct TestConstantFold : public PassWrapper<TestConstantFold, FunctionPass> {
+struct TestConstantFold
+    : public PassWrapper<TestConstantFold, OperationPass<FuncOp>> {
   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;
+  void runOnOperation() override;
 };
 } // namespace
 
 void TestConstantFold::foldOperation(Operation *op, OperationFolder &helper) {
   auto processGeneratedConstants = [this](Operation *op) {
     existingConstants.push_back(op);
   };
 
   // Attempt to fold the specified operation, including handling unused or
   // duplicated constants.
   (void)helper.tryToFold(op, processGeneratedConstants);
 }
 
 // For now, we do a simple top-down pass over a function folding constants.  We
 // don't handle conditional control flow, block arguments, folding conditional
 // branches, or anything else fancy.
-void TestConstantFold::runOnFunction() {
+void TestConstantFold::runOnOperation() {
   existingConstants.clear();
 
   // Collect and fold the operations within the function.
   SmallVector<Operation *, 8> ops;
-  getFunction().walk([&](Operation *op) { ops.push_back(op); });
+  getOperation().walk([&](Operation *op) { ops.push_back(op); });
 
   // Fold the constants in reverse so that the last generated constants from
   // folding are at the beginning. This creates somewhat of a linear ordering to
   // the newly generated constants that matches the operation order and improves
   // the readability of test cases.
   OperationFolder helper(&getContext());
   for (Operation *op : llvm::reverse(ops))
     foldOperation(op, helper);

mlir/test/lib/Transforms/TestInlining.cpp

 #include "mlir/Transforms/InliningUtils.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/StringSet.h"
 
 using namespace mlir;
 using namespace test;
 
 namespace {
-struct Inliner : public PassWrapper<Inliner, FunctionPass> {
+struct Inliner : public PassWrapper<Inliner, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-inline"; }
   StringRef getDescription() const final {
     return "Test inlining region calls";
   }
 
-  void runOnFunction() override {
-    auto function = getFunction();
+  void runOnOperation() override {
+    auto function = getOperation();
 
     // 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.
     InlinerInterface interface(&getContext());
 

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> {
+struct TestLoopFusion
+    : public PassWrapper<TestLoopFusion, OperationPass<FuncOp>> {
   StringRef getArgument() const final { return "test-loop-fusion"; }
   StringRef getDescription() const final {
     return "Tests loop fusion utility functions.";
   }
-  void runOnFunction() override;
+  void runOnOperation() override;
 };
 
 } // 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.
 // Returns false as IR is not transformed.
for (unsigned j = 0; j < numLoops; ++j) {
         if (changed && returnOnChange)
           return true;
       }
     }
   }
   return changed;
 }
 
-void TestLoopFusion::runOnFunction() {
+void TestLoopFusion::runOnOperation() {
   std::vector<SmallVector<AffineForOp, 2>> depthToLoops;
   if (clTestLoopFusionTransformation) {
     // Run loop fusion until a fixed point is reached.
     do {
       depthToLoops.clear();
       // Gather all AffineForOps by loop depth.
-      gatherLoops(getFunction(), depthToLoops);
+      gatherLoops(getOperation(), depthToLoops);
 
       // Try to fuse all combinations of src/dst loop nests in 'depthToLoops'.
     } while (iterateLoops(depthToLoops, testLoopFusionTransformation,
                           /*returnOnChange=*/true));
     return;
   }
 
   // Gather all AffineForOps by loop depth.
-  gatherLoops(getFunction(), depthToLoops);
+  gatherLoops(getOperation(), depthToLoops);
 
   // Run tests on all combinations of src/dst loop nests in 'depthToLoops'.
   if (clTestDependenceCheck)
     iterateLoops(depthToLoops, testDependenceCheck);
   if (clTestSliceComputation)
     iterateLoops(depthToLoops, testSliceComputation);
 }
 
 namespace mlir {
 namespace test {
 void registerTestLoopFusion() { PassRegistration<TestLoopFusion>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopMapping.cpp

 #include "mlir/Transforms/Passes.h"
 
 #include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 
 namespace {
 class TestLoopMappingPass
-    : public PassWrapper<TestLoopMappingPass, FunctionPass> {
+    : public PassWrapper<TestLoopMappingPass, OperationPass<FuncOp>> {
 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() = default;
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, scf::SCFDialect>();
   }
 
-  void runOnFunction() override {
-    FuncOp func = getFunction();
+  void runOnOperation() override {
+    FuncOp func = getOperation();
 
     // SSA values for the transformation are created out of thin air by
     // unregistered "new_processor_id_and_range" operations. This is enough to
     // emulate mapping conditions.
     SmallVector<Value, 8> processorIds, numProcessors;
     func.walk([&processorIds, &numProcessors](Operation *op) {
       if (op->getName().getStringRef() != "new_processor_id_and_range")
         return;

mlir/test/lib/Transforms/TestLoopParametricTiling.cpp

 
 using namespace mlir;
 
 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 PassWrapper<SimpleParametricLoopTilingPass,
+                         OperationPass<FuncOp>> {
 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();
+  void runOnOperation() override {
+    FuncOp func = getOperation();
     func.walk([this](scf::ForOp op) {
       // Ignore nested loops.
       if (op->getParentRegion()->getParentOfType<scf::ForOp>())
         return;
       extractFixedOuterLoops(op, sizes);
     });
   }
 

mlir/test/lib/Transforms/TestLoopUnrolling.cpp

static unsigned getNestingDepth(Operation *op) {
   while ((currOp = currOp->getParentOp())) {
     if (isa<scf::ForOp>(currOp))
       depth++;
   }
   return depth;
 }
 
 class TestLoopUnrollingPass
-    : public PassWrapper<TestLoopUnrollingPass, FunctionPass> {
+    : public PassWrapper<TestLoopUnrollingPass, OperationPass<FuncOp>> {
 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,
                                  bool annotateLoopParam) {
     unrollFactor = unrollFactorParam;
     loopDepth = loopDepthParam;
     annotateLoop = annotateLoopParam;
   }
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, StandardOpsDialect>();
   }
 
-  void runOnFunction() override {
-    FuncOp func = getFunction();
+  void runOnOperation() override {
+    FuncOp func = getOperation();
     SmallVector<scf::ForOp, 4> loops;
     func.walk([&](scf::ForOp forOp) {
       if (getNestingDepth(forOp) == loopDepth)
         loops.push_back(forOp);
     });
     auto annotateFn = [this](unsigned i, Operation *op, OpBuilder b) {
       if (annotateLoop) {
         op->setAttr("unrolled_iteration", b.getUI32IntegerAttr(i));

mlir/unittests/Pass/PassManagerTest.cpp

 
 /// Analysis that operates on a specific operation.
 struct OpSpecificAnalysis {
   OpSpecificAnalysis(FuncOp op) : isSecret(op.getName() == "secret") {}
   const bool isSecret;
 };
 
 /// Simple pass to annotate a FuncOp with the results of analysis.
-/// Note: not using FunctionPass as it skip external functions.
 struct AnnotateFunctionPass
     : public PassWrapper<AnnotateFunctionPass, OperationPass<FuncOp>> {
   void runOnOperation() override {
     FuncOp op = getOperation();
     Builder builder(op->getParentOfType<ModuleOp>());
 
     auto &ga = getAnalysis<GenericAnalysis>();
     auto &sa = getAnalysis<OpSpecificAnalysis>();