Re-apply [NFC] Generalize a couple of passes so they can operate on any FunctionLike op.

[stellaraccident]

Summary

• Generalizes passes linalg-detensorize, linalg-fold-unit-extent-dims, convert-elementwise-to-linalg.
• I feel that more work could be done in the future (i.e. make FunctionLike into a proper OpInterface and extend actions in dialect conversion to be trait based), and this patch would be a good record of why that is useful.
• Note for downstreams:
  • Since these passes are now generic, they do not automatically nest with pass managers set up for that.
  • If running them over nested functions, you must nest explicitly. Upstream has adopted this style but *-opt still has some uses of implicit pipelines via args. See tests for argument changes needed.

• Addressed missed comments from the original and per-suggestion removed the assert on FunctionLike in ElementwiseToLinalg, which also is what was causing the integration test to fail.

This reverts commit aa8815e42e646a98663af4cf036dbb913ad047a7.

[mehdi_amini]

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

130

[stellaraccident]

Remove restriction on DropUnitDims.

[mehdi_amini]

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

562

570

We should be able to run applyPatternsAndFoldGreedily directly on the op here?

[stellaraccident]

Comments.

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

 #define MLIR_DIALECT_LINALG_PASSES_H_
 
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
-std::unique_ptr<OperationPass<FuncOp>> createConvertElementwiseToLinalgPass();
+std::unique_ptr<Pass> createConvertElementwiseToLinalgPass();
 
-std::unique_ptr<OperationPass<FuncOp>> createLinalgFoldUnitExtentDimsPass();
+std::unique_ptr<Pass> createLinalgFoldUnitExtentDimsPass();
 
 std::unique_ptr<Pass> createLinalgElementwiseOpFusionPass();
 std::unique_ptr<Pass> createFoldReshapeOpsByLinearizationPass();
 
 std::unique_ptr<OperationPass<FuncOp>> createLinalgTilingPass(
     ArrayRef<int64_t> tileSizes = {},
     linalg::LinalgTilingLoopType loopType = linalg::LinalgTilingLoopType::Loops,
     ArrayRef<StringRef> distributionTypes = {});

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

 //===-- Passes.td - Linalg 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_LINALG_PASSES
 #define MLIR_DIALECT_LINALG_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def ConvertElementwiseToLinalg : FunctionPass<"convert-elementwise-to-linalg"> {
+def ConvertElementwiseToLinalg : Pass<"convert-elementwise-to-linalg", ""> {
   let summary = "Convert ElementwiseMappable ops to linalg";
   let description = [{
     Convert ops with the `ElementwiseMappable` trait to linalg parallel loops.
 
-    This pass only converts ops that operate on ranked tensors.
+    This pass only converts ops that operate on ranked tensors. It can be
+    run on op which contains linalg ops (most commonly a FunctionLike op).
   }];
   let constructor = "mlir::createConvertElementwiseToLinalgPass()";
   let dependentDialects = ["linalg::LinalgDialect", "memref::MemRefDialect"];
 }
 
 def LinalgComprehensiveModuleBufferize :
     Pass<"linalg-comprehensive-module-bufferize", "ModuleOp"> {
   let summary = "Bufferize (tensor into memref) for a Module.";
Option<"useAlloca", "use-alloca", "bool",
            "Use stack allocations for memrefs (for testing purposes only)">,
     Option<"analysisFuzzerSeed", "analysis-fuzzer-seed", "unsigned",
            /*default=*/"0",
            "Analyze ops in random order with a given seed (fuzzer)">
   ];
   let constructor = "mlir::createLinalgComprehensiveModuleBufferizePass()";
 }
 
-def LinalgFoldUnitExtentDims : FunctionPass<"linalg-fold-unit-extent-dims"> {
+def LinalgFoldUnitExtentDims : Pass<"linalg-fold-unit-extent-dims", ""> {
   let summary = "Remove unit-extent dimension in Linalg ops on tensors";
   let constructor = "mlir::createLinalgFoldUnitExtentDimsPass()";
   let options = [
     Option<"foldOneTripLoopsOnly", "fold-one-trip-loops-only", "bool",
             /*default=*/"false",
            "Only folds the one-trip loops from Linalg ops on tensors "
            "(for testing purposes only)">
   ];

 }
 
 def LinalgGeneralization : FunctionPass<"linalg-generalize-named-ops"> {
   let summary = "Convert named ops into generic ops";
   let constructor = "mlir::createLinalgGeneralizationPass()";
   let dependentDialects = ["linalg::LinalgDialect"];
 }
 
-def LinalgDetensorize : FunctionPass<"linalg-detensorize"> {
+def LinalgDetensorize : Pass<"linalg-detensorize", ""> {
   let summary = "Detensorize linalg ops";
   let constructor = "mlir::createLinalgDetensorizePass()";
   let dependentDialects = [];
 
   let description = [{
-    Detensoring is the process through which a tensor value is convereted to one
+    Detensoring is the process through which a tensor value is converted to one
     or potentially more primitive value(s). During this process, operations with
     such detensored operands are also converted to an equivalent form that works
     on primitives.
 
     The detensoring process is driven by linalg-on-tensor ops. In particular, a
     linalg-on-tensor op is checked to see whether *all* its operands can be
     detensored. If so, those operands are converted to their primitive
     counterparts and the linalg op is replaced by an equivalent op that takes
     those new primitive values as operands. Therefore, detensoring an op can be
     divided into 2 main logical phases:
 
     1. Detect/match an op that can be detensored.
     2. Detensor the operands of the op and replace it with a primitive
        equivalent.
 
     In addition to detensoring individual ops, this pass detensors internal
     control flow inside a function. All blocks except for the entry block are
     detensored by converting their arguments whenever possible.
+
+    This can be run on any op with the FunctionLike trait and must not be
+    run on others. This is because it performs specific legalization of the
+    blocks that make up the body, which it assumes has a FunctionLike trait.
   }];
 }
 
 def LinalgStrategyTileAndFusePass
     : FunctionPass<"linalg-strategy-tile-and-fuse-pass"> {
   let summary = "Configurable pass to apply pattern-based tiling and fusion.";
   let constructor = "mlir::createLinalgStrategyTileAndFusePass()";
   let options = [

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

matchAndRewrite(GenericOp op, OpAdaptor adaptor,
 
     return success();
   }
 };
 
 /// A conversion pattern for detensoring internal (non-entry) blocks within a
 /// function.
 struct FunctionNonEntryBlockConversion : public ConversionPattern {
-  FunctionNonEntryBlockConversion(StringRef functionLikeOpName,
-                                  MLIRContext *ctx, TypeConverter &converter,
+  FunctionNonEntryBlockConversion(MLIRContext *ctx, TypeConverter &converter,
                                   DenseSet<BlockArgument> blockArgsToDetensor)
-      : ConversionPattern(converter, functionLikeOpName, /*benefit=*/1, ctx),
+      : ConversionPattern(converter, MatchTraitOpTypeTag(),
+                          TypeID::get<OpTrait::FunctionLike>(), /*benefit=*/1,
+                          ctx),
         blockArgsToDetensor(blockArgsToDetensor) {}
 
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.startRootUpdate(op);
     Region &region = function_like_impl::getFunctionBody(op);
     SmallVector<TypeConverter::SignatureConversion, 2> conversions;
public:
     ///   %10 = "some.op"(%9)
     ///   br ^bb2(%8 : tensor<i32>)
     /// ...
     ///
     /// if the cost model decides that the linalg.generic op should be
     /// detensored, then:
     /// - opsToDetensor should be = {linalg.generic{add}}.
     /// - blockArgsToDetensor should be = {bb1 -> {0}, bb2 -> {0}}.
-    virtual void compute(FuncOp func, DetensorizeTypeConverter typeConverter,
+    virtual void compute(Operation *func,
+                         DetensorizeTypeConverter typeConverter,
                          DenseSet<Operation *> &opsToDetensor,
                          DenseSet<BlockArgument> &blockArgsToDetensor) = 0;
 
     /// From the blockArgsToDetensor set computed by a CostModel
     /// implementation, this method computes the corresponding branch op
     /// detensoring. The result is a map from a branch op to a subset of indices
     /// of its operands. The indices specify which of the branch op's operands
     /// should be detensored.
struct LinalgDetensorize : public LinalgDetensorizeBase<LinalgDetensorize> {
   /// comes from. If the condition value is (indirectly) computed by a linalg op
   /// that can be detensored, the model then continues walking the use-def chain
   /// in order to understand where the linalg op's operands come from. This
   /// leads to discovering a "detensoring component". A detensoring component is
   /// the set of operations + block arguments that are involved in control-flow
   /// AND can be detensored.
   class ControlFlowDetectionModel : public CostModel {
   public:
-    void compute(FuncOp func, DetensorizeTypeConverter typeConverter,
+    void compute(Operation *func, DetensorizeTypeConverter typeConverter,
                  DenseSet<Operation *> &opsToDetensor,
                  DenseSet<BlockArgument> &blockArgsToDetensor) override {
       SmallVector<Value> workList;
 
-      func.walk([&](CondBranchOp condBr) {
+      func->walk([&](CondBranchOp condBr) {
         for (auto operand : condBr.getOperands()) {
           workList.push_back(operand);
         }
       });
 
-      func.walk([&](BranchOp br) {
+      func->walk([&](BranchOp br) {
         for (auto operand : br.getOperands()) {
           workList.push_back(operand);
         }
       });
 
       DenseSet<Value> visitedValues;
       DenseSet<Operation *> visitedOps;
 
void compute(Operation *func, DetensorizeTypeConverter typeConverter,
         blockArgsToDetensor.erase(blockArg);
       }
     }
   };
 
   /// Detensorize everything that can detensored.
   class AggressiveDetensoringModel : public CostModel {
   public:
-    void compute(FuncOp func, DetensorizeTypeConverter typeConverter,
+    void compute(Operation *func, DetensorizeTypeConverter typeConverter,
                  DenseSet<Operation *> &opsToDetensor,
                  DenseSet<BlockArgument> &blockArgsToDetensor) override {
-      func.walk([&](GenericOp genericOp) {
+      func->walk([&](GenericOp genericOp) {
         if (shouldBeDetensored(genericOp, typeConverter))
           opsToDetensor.insert(genericOp);
       });
 
-      for (Block &block : llvm::drop_begin(func.getBody(), 1))
+      for (Block &block :
+           llvm::drop_begin(function_like_impl::getFunctionBody(func), 1))
         for (BlockArgument blockArgument : block.getArguments())
           blockArgsToDetensor.insert(blockArgument);
     }
   };
 
-  void runOnFunction() override {
+  void runOnOperation() override {
+    assert(getOperation()->hasTrait<OpTrait::FunctionLike>() &&
+           "DetensorizePass can only be run on FunctionLike operations");
     MLIRContext *context = &getContext();
     DetensorizeTypeConverter typeConverter;
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);
     DenseSet<Operation *> opsToDetensor;
     DenseMap<Operation *, DenseSet<int>> detensorableBranchOps;
     DenseSet<BlockArgument> blockArgsToDetensor;
 
     if (aggressiveMode.getValue()) {
       AggressiveDetensoringModel costModel;
-      costModel.compute(getFunction(), typeConverter, opsToDetensor,
+      costModel.compute(getOperation(), typeConverter, opsToDetensor,
                         blockArgsToDetensor);
 
     } else {
       ControlFlowDetectionModel costModel;
-      costModel.compute(getFunction(), typeConverter, opsToDetensor,
+      costModel.compute(getOperation(), typeConverter, opsToDetensor,
                         blockArgsToDetensor);
     }
 
     detensorableBranchOps =
         CostModel::computeBranchOpDetensoring(blockArgsToDetensor);
 
     target.addDynamicallyLegalOp<GenericOp>(
         [&](GenericOp op) { return !opsToDetensor.count(op); });
 
-    target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
+    target.markUnknownOpDynamicallyLegal([&](Operation *op) {
       // A function is legal if all of its non-entry blocks are legal. We
       // don't legalize the entry block (i.e. the function's signature)
       // since detensoring can't happen along external calling convention
       // boundaries, which we conservatively approximate as all function
       // signatures.
-      return llvm::all_of(llvm::drop_begin(op.getBody(), 1), [&](Block &block) {
-        if (llvm::any_of(blockArgsToDetensor, [&](BlockArgument blockArgument) {
+      if (op->hasTrait<OpTrait::FunctionLike>()) {
+        auto &body = function_like_impl::getFunctionBody(op);
+        return llvm::all_of(llvm::drop_begin(body, 1), [&](Block &block) {
+          if (llvm::any_of(
+                  blockArgsToDetensor, [&](BlockArgument blockArgument) {
                     return blockArgument.getOwner() == &block &&
                            !typeConverter.isLegal(blockArgument.getType());
                   })) {
             return false;
           }
           return true;
         });
-    });
+      }
 
-    target.markUnknownOpDynamicallyLegal([&](Operation *op) {
       if (isNotBranchOpInterfaceOrReturnLikeOp(op) ||
           isLegalForReturnOpTypeConversionPattern(op, typeConverter,
                                                   /*returnOpAlwaysLegal*/ true))
         return true;
 
       if (auto branchOp = dyn_cast<BranchOpInterface>(op)) {
         if (!detensorableBranchOps.count(branchOp))
           return true;
 
         for (auto operandIdx : detensorableBranchOps[branchOp])
           if (!typeConverter.isLegal(
                   branchOp->getOperand(operandIdx).getType()))
             return false;
 
         return true;
       }
 
       return false;
     });
 
     patterns.insert<DetensorizeGenericOp>(typeConverter, context);
-    patterns.insert<FunctionNonEntryBlockConversion>(FuncOp::getOperationName(),
-                                                     context, typeConverter,
+    patterns.insert<FunctionNonEntryBlockConversion>(context, typeConverter,
                                                      blockArgsToDetensor);
     // Since non-entry block arguments get detensorized, we also need to
     // update the control flow inside the function to reflect the correct
     // types.
     auto shouldConvertBranchOperand = [&](BranchOpInterface branchOp,
                                           int operandIdx) -> bool {
       return detensorableBranchOps.count(branchOp) &&
              detensorableBranchOps[branchOp].count(operandIdx);
     };
 
     populateBranchOpInterfaceTypeConversionPattern(patterns, typeConverter,
                                                    shouldConvertBranchOperand);
 
-    if (failed(applyFullConversion(getFunction(), target, std::move(patterns))))
+    if (failed(
+            applyFullConversion(getOperation(), target, std::move(patterns))))
       signalPassFailure();
 
     RewritePatternSet canonPatterns(context);
     canonPatterns.add<ExtractFromReshapeFromElements>(context);
-    if (failed(applyPatternsAndFoldGreedily(getFunction(),
+    if (failed(applyPatternsAndFoldGreedily(getOperation(),
                                             std::move(canonPatterns))))
       signalPassFailure();
   }
 
   Option<bool> aggressiveMode{
       *this, "aggressive-mode",
       llvm::cl::desc("Detensorize all ops that qualify for detensoring along "
                      "with branch operands and basic-block arguments.")};
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::createLinalgDetensorizePass() {
   return std::make_unique<LinalgDetensorize>();
 }

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

void mlir::linalg::populateFoldUnitExtentDimsPatterns(
   tensor::CollapseShapeOp::getCanonicalizationPatterns(patterns, context);
   tensor::ExpandShapeOp::getCanonicalizationPatterns(patterns, context);
 }
 
 namespace {
 /// Pass that removes unit-extent dims within generic ops.
 struct LinalgFoldUnitExtentDimsPass
     : public LinalgFoldUnitExtentDimsBase<LinalgFoldUnitExtentDimsPass> {
-  void runOnFunction() override {
-    FuncOp funcOp = getFunction();
-    MLIRContext *context = funcOp.getContext();
+  void runOnOperation() override {
+    Operation *op = getOperation();
+    MLIRContext *context = op->getContext();
     RewritePatternSet patterns(context);
     if (foldOneTripLoopsOnly)
       patterns.add<FoldUnitDimLoops>(context);
     else
       populateFoldUnitExtentDimsPatterns(patterns);
-    (void)applyPatternsAndFoldGreedily(funcOp.getBody(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(op, std::move(patterns));
   }
 };
 } // namespace
 
-std::unique_ptr<OperationPass<FuncOp>>
-mlir::createLinalgFoldUnitExtentDimsPass() {
+std::unique_ptr<Pass> mlir::createLinalgFoldUnitExtentDimsPass() {
   return std::make_unique<LinalgFoldUnitExtentDimsPass>();
 }

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

void mlir::linalg::populateElementwiseToLinalgConversionPatterns(
   patterns.add<ConvertAnyElementwiseMappableOpOnRankedTensors>(
       patterns.getContext());
 }
 
 namespace {
 class ConvertElementwiseToLinalgPass
     : public ConvertElementwiseToLinalgBase<ConvertElementwiseToLinalgPass> {
 
-  void runOnFunction() final {
+  void runOnOperation() final {
     auto func = getOperation();
     auto *context = &getContext();
     ConversionTarget target(*context);
     RewritePatternSet patterns(context);
 
     mlir::linalg::populateElementwiseToLinalgConversionPatterns(patterns);
     target.markUnknownOpDynamicallyLegal([](Operation *op) {
       return !isElementwiseMappableOpOnRankedTensors(op);
     });
 
     if (failed(applyPartialConversion(func, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
-std::unique_ptr<OperationPass<FuncOp>>
-mlir::createConvertElementwiseToLinalgPass() {
+std::unique_ptr<Pass> mlir::createConvertElementwiseToLinalgPass() {
   return std::make_unique<ConvertElementwiseToLinalgPass>();
 }

mlir/test/Dialect/Linalg/convert-elementwise-to-linalg.mlir

-// RUN: mlir-opt -convert-elementwise-to-linalg -split-input-file %s | FileCheck %s
+// RUN: mlir-opt -pass-pipeline="builtin.func(convert-elementwise-to-linalg)" -split-input-file %s | FileCheck %s
 
 // In-depth checking of the linalg.generic op for a very trivial case.
 // CHECK: #[[$MAP:.*]] = affine_map<() -> ()>
 // CHECK-LABEL: func @addf_rank0
 //  CHECK-SAME:   %[[ARG0:[0-9a-zA-Z]*]]: tensor<f32>
 //  CHECK-SAME:   %[[ARG1:[0-9a-zA-Z]*]]: tensor<f32>
 func @addf_rank0(%arg0: tensor<f32>, %arg1: tensor<f32>) -> tensor<f32> {
   //      CHECK: %{{.*}} = linalg.generic

mlir/test/Dialect/Linalg/detensorize_0d.mlir

-// RUN: mlir-opt %s -allow-unregistered-dialect -linalg-detensorize=aggressive-mode | FileCheck %s
+// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline="builtin.func(linalg-detensorize{aggressive-mode})" | FileCheck %s
 
 #map = affine_map<() -> ()>
 
 func @detensor_simple(%arg1: tensor<f32>, %arg2: tensor<f32>) -> tensor<f32> attributes {iree.module.export} {
   %0 = linalg.init_tensor [] : tensor<f32>
   %1 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = []}
     ins(%arg1, %arg2 : tensor<f32>, tensor<f32>)
     outs(%0 : tensor<f32>) {

mlir/test/Dialect/Linalg/detensorize_br_operands.mlir

-// RUN: mlir-opt %s -split-input-file -allow-unregistered-dialect -linalg-detensorize | FileCheck %s
+// RUN: mlir-opt %s -split-input-file -allow-unregistered-dialect -pass-pipeline="builtin.func(linalg-detensorize)" | FileCheck %s
 
 // TODO: Detensoring breaks if %arg0 or %arg1 are passed directly as tensors. Fix that.
 func @if_true_test(%arg0: i1, %arg1: i32) -> tensor<i32> attributes {} {
   %arg0_t = tensor.from_elements %arg0 : tensor<1xi1>
   %arg0_t2 = tensor.collapse_shape %arg0_t [] : tensor<1xi1> into tensor<i1>
 
   %arg1_t = tensor.from_elements %arg1 : tensor<1xi32>
   %arg1_t2 = tensor.collapse_shape %arg1_t [] : tensor<1xi32> into tensor<i32>

mlir/test/Dialect/Linalg/detensorize_if.mlir

-// RUN: mlir-opt %s -split-input-file -allow-unregistered-dialect -linalg-detensorize | FileCheck %s
+// RUN: mlir-opt %s -split-input-file -allow-unregistered-dialect -pass-pipeline="builtin.func(linalg-detensorize)" | FileCheck %s
 
 #map0 = affine_map<() -> ()>
 
 #attrs = {
   indexing_maps = [#map0, #map0, #map0],
   iterator_types = []
 }
 

mlir/test/Dialect/Linalg/detensorize_trivial.mlir

-// RUN: mlir-opt %s -linalg-detensorize=aggressive-mode | FileCheck %s -check-prefix=DET-ALL
-// RUN: mlir-opt %s -linalg-detensorize | FileCheck %s -check-prefix=DET-CF
+// RUN: mlir-opt %s -pass-pipeline="builtin.func(linalg-detensorize{aggressive-mode})" | FileCheck %s -check-prefix=DET-ALL
+// RUN: mlir-opt %s -pass-pipeline="builtin.func(linalg-detensorize)" | FileCheck %s -check-prefix=DET-CF
 
 
 #map0 = affine_map<() -> ()>
 
 #attrs = {
   indexing_maps = [#map0, #map0, #map0],
   iterator_types = []
 }

mlir/test/Dialect/Linalg/detensorize_while.mlir

-// RUN: mlir-opt %s -linalg-detensorize=aggressive-mode | FileCheck %s -check-prefix=DET-ALL
-// RUN: mlir-opt %s -linalg-detensorize | FileCheck %s -check-prefix=DET-CF
+// RUN: mlir-opt %s -pass-pipeline="builtin.func(linalg-detensorize{aggressive-mode})" | FileCheck %s -check-prefix=DET-ALL
+// RUN: mlir-opt %s -pass-pipeline="builtin.func(linalg-detensorize)" | FileCheck %s -check-prefix=DET-CF
 
 #map0 = affine_map<() -> ()>
 
 #attrs = {
   indexing_maps = [#map0, #map0, #map0],
   iterator_types = []
 }
 

mlir/test/Dialect/Linalg/detensorize_while_impure_cf.mlir

-// RUN: mlir-opt %s -linalg-detensorize=aggressive-mode | FileCheck %s -check-prefix=DET-ALL
-// RUN: mlir-opt %s -linalg-detensorize | FileCheck %s -check-prefix=DET-CF
+// RUN: mlir-opt %s -pass-pipeline="builtin.func(linalg-detensorize{aggressive-mode})" | FileCheck %s -check-prefix=DET-ALL
+// RUN: mlir-opt %s -pass-pipeline="builtin.func(linalg-detensorize)" | FileCheck %s -check-prefix=DET-CF
 
 #map0 = affine_map<() -> ()>
 #map1 = affine_map<(i) -> ()>
 #map2 = affine_map<(i) -> (i)>
 
 #attrs = {
   indexing_maps = [#map0, #map0, #map0],
   iterator_types = []

mlir/test/Dialect/Linalg/detensorize_while_pure_cf.mlir

-// RUN: mlir-opt %s -allow-unregistered-dialect -linalg-detensorize | FileCheck %s
+// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline="builtin.func(linalg-detensorize)" | FileCheck %s
 
 #map0 = affine_map<() -> ()>
 
 #attrs = {
   indexing_maps = [#map0, #map0, #map0],
   iterator_types = []
 }
 

mlir/test/Dialect/Linalg/drop-unit-extent-dims.mlir

-// RUN: mlir-opt %s -split-input-file -linalg-fold-unit-extent-dims | FileCheck %s
+// RUN: mlir-opt %s -split-input-file -pass-pipeline="builtin.func(linalg-fold-unit-extent-dims)" | FileCheck %s
 
 #accesses = [
   affine_map<(i, j, k, l, m) -> (i, k, m)>,
   affine_map<(i, j, k, l, m) -> ()>,
   affine_map<(i, j, k, l, m) -> (i, k, j, l, m)>
 ]
 
 #trait = {

mlir/test/Dialect/Linalg/fold-unit-trip-loops.mlir

-// RUN: mlir-opt %s -split-input-file -linalg-fold-unit-extent-dims="fold-one-trip-loops-only" | FileCheck %s
+// RUN: mlir-opt %s -split-input-file -pass-pipeline="builtin.func(linalg-fold-unit-extent-dims{fold-one-trip-loops-only})" | FileCheck %s
 
 #accesses = [
   affine_map<(i, j, k, l, m) -> (i, k, m)>,
   affine_map<(i, j, k, l, m) -> (i, k, j, l, m)>
 ]
 
 #trait = {
   iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"],