[mlir][Linalg] Add named Linalg ops on tensor to buffer support.

[nicolasvasilache]

Summary

This revision introduces support for buffer allocation for any named linalg op.
To avoid template instantiating many ops, a new ConversionPattern is created to capture the LinalgOp interface.

A few interfaces are also updated to be consistent with MLIR style:
OwningRewritePatternList * -> OwningRewritePatternList &
BufferAssignmentTypeConverter * -> BufferAssignmentTypeConverter &

[nicolasvasilache]

Missed a few spots

[nicolasvasilache]

Rebase

[nicolasvasilache]

Fix bad rebase

[silvas]

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

808

Do these have to inherit from BufferAssignmentConversionPattern? I think a regular one should be fine. (you can access the typeConverter with getTypeConverter() from a regular conversion pattern)

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

248

here you can just say getTypeConverter() and then don't have to inherit from BufferAssignmentConversionPattern.

mlir/docs/Tutorials/QuickstartRewrites.md

 set(LLVM_TARGET_DEFINITIONS <name-of-the-td-file>)
 mlir_tablegen(<name-of-the-generated-inc-file> -gen-rewriters)
 add_public_tablegen_target(<name-of-the-cmake-target>)
 ```
 
 Then you can `#include` the generated file in any C++ implementation file you
 like. (You will also need to make sure the library depends on the CMake target
 defined in the above.) The generated file will have a `populateWithGenerated(
-MLIRContext *context, OwningRewritePatternList *patterns)` function that you can
+MLIRContext *context, OwningRewritePatternList &patterns)` function that you can
 use to collect all the generated patterns inside `patterns` and then use
 `patterns` in any pass you would like.
 
 ### C++ rewrite specification
 
 In case patterns are not sufficient there is also the fully C++ way of
 expressing a rewrite:
 

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

 // See Linalg/LinalgTraits.h for implementation details and usage.
 class NOutputs<int n> :
   NativeOpTrait<"linalg::NOutputs<" # !cast<string>(n) # ">::Impl"> {}
 
 def StructuredOpTraits : NativeOpTrait<"linalg::StructuredOpTraits">;
 def NamedStructuredOpTrait : NativeOpTrait<"linalg::NamedStructuredOpTrait">;
 
 // Base Tablegen class for Linalg ops.
-// Linalg ops that correspond to library calls operate on linalg::View as their
+// Linalg ops that correspond to library calls operate on ShapedType as their
 // first operands. These may be optionally followed by non-view operands
 // depending on the specific Linalg op.
 class LinalgStructuredBase_Op<string mnemonic, list<OpTrait> props>
   : Op<Linalg_Dialect, mnemonic,
        !listconcat(props, [LinalgStructuredInterface])> {
 }
 
 class LinalgStructured_Op<string mnemonic, list<OpTrait> props>

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td

StaticInterfaceMethod<
            "ArrayRef<NamedAttribute>":$attributes), [{
         return builder.create<ConcreteOp>(
           loc, resultTypes, operands, attributes);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Clone the current operation with the given location and operands. This
-        is used to abstract away the optional underlying region creation.
+        is used to abstract away the optional underlying region creation. This 
+        does not change the balance between input, output_buffer and 
+        init_tensors operands.
       }],
       /*retTy=*/"Operation *",
       /*methodName=*/"clone",
       (ins "OpBuilder &":$b, "Location":$loc, "TypeRange":$resultTypes,
            "ValueRange":$operands),
       [{
         BlockAndValueMapping map;
         unsigned numRegions = $_op.getOperation()->getNumRegions();
SmallVector<Value, 4> getAssumedNonShapedOperands() {
       for (unsigned i = 0; i < nExtraOperands; ++i) {
         res.push_back(getOperation()->getOperand(numShapedOperands + i));
         assert((res.back().getType().isSignlessIntOrIndexOrFloat()
                 || res.back().getType().isa<VectorType>()) &&
                "expected scalar or vector type");
       }
       return res;
     }
+    //========================================================================//
+    // Helper functions to mutate the `operand_segment_sizes` attribute.
+    // These are useful when cloning and changing operand types.
+    //========================================================================//
+    void setNumInputs(unsigned num) { setOperandSegmentAt(0, num); }
+    void setNumOutputBuffers(unsigned num) { setOperandSegmentAt(1, num); }
+    void setNumInitTensors(unsigned num) { setOperandSegmentAt(2, num); }
+
+    private:
+    void setOperandSegmentAt(unsigned idx, unsigned val) {
+      auto attr = getOperation()->getAttr("operand_segment_sizes")
+        .cast<DenseIntElementsAttr>();
+      unsigned i = 0;
+      auto newAttr = attr.mapValues(IntegerType::get(32, getContext()),
+        [&](const APInt &v) { return (i++ == idx) ? APInt(32, val) : v; });
+      getOperation()->setAttr("operand_segment_sizes", newAttr);
+    }
   }];
 }
 
 #endif // LINALG_IR_STRUCTURED_OPS_INTERFACE

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

 //===- Transforms.h - Linalg transformations as patterns --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef DIALECT_LINALG_TRANSFORMS_TRANSFORMS_H_
 #define DIALECT_LINALG_TRANSFORMS_TRANSFORMS_H_
 
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Transforms/Bufferize.h"
 #include "llvm/ADT/SmallBitVector.h"
 
 namespace mlir {
 
 class BufferAssignmentTypeConverter;
 
 namespace linalg {
 

 /// Populates patterns for vectorization of all ConvN-D ops.
 void populateConvVectorizationPatterns(
     MLIRContext *context, SmallVectorImpl<OwningRewritePatternList> &patterns,
     ArrayRef<int64_t> tileSizes);
 
 /// Populates the given list with patterns to convert Linalg operations on
 /// tensors to buffers.
 void populateConvertLinalgOnTensorsToBuffersPatterns(
-    MLIRContext *context, BufferAssignmentTypeConverter *converter,
-    OwningRewritePatternList *patterns);
+    MLIRContext *context, BufferAssignmentTypeConverter &converter,
+    OwningRewritePatternList &patterns);
 
 /// Performs standalone tiling of a single LinalgOp by `tileSizes`.
 /// and permute the loop nest according to `interchangeVector`
 /// The permutation is expressed as a list of integers that specify
 /// the new ordering of the loop nest. The length of `interchangeVector`
 /// must be equal to the length of `tileSizes`.
 /// An empty vector is interpreted as the identity permutation and the
 /// transformation returns early.
LogicalResult matchAndRewrite(IndexedGenericOp op,
                                 PatternRewriter &rewriter) const override;
 };
 
 /// Populate the given list with patterns that convert from Linalg to Standard.
 void populateLinalgToStandardConversionPatterns(
     OwningRewritePatternList &patterns, MLIRContext *ctx);
 
 //===----------------------------------------------------------------------===//
+// Buffer allocation patterns.
+//===----------------------------------------------------------------------===//
+
+/// Generic BufferAssignmentConversionPattern that matches any Operation* and
+/// dispatches internally. This avoids template instantiating one pattern for
+/// each LinalgOp op.
+class LinalgOpConverter : public BufferAssignmentConversionPattern {
+public:
+  LinalgOpConverter(MLIRContext *context,
+                    BufferAssignmentTypeConverter &converter)
+      : BufferAssignmentConversionPattern(context, converter) {}
+
+  LogicalResult
+  matchAndRewrite(Operation *op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const final;
+};
+
+class TensorConstantOpConverter
+    : public BufferAssignmentOpConversionPattern<ConstantOp> {
+public:
+  using BufferAssignmentOpConversionPattern<
+      ConstantOp>::BufferAssignmentOpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(ConstantOp op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const final;
+};
+
+class TensorCastOpConverter
+    : public BufferAssignmentOpConversionPattern<TensorCastOp> {
+public:
+  using BufferAssignmentOpConversionPattern<
+      TensorCastOp>::BufferAssignmentOpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(TensorCastOp op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const final;
+};
+
+//===----------------------------------------------------------------------===//
 // Support for staged pattern application.
 //===----------------------------------------------------------------------===//
 /// Helper function to allow applying rewrite patterns, interleaved with more
 /// global transformations, in a staged fashion:
 ///   1. the first stage consists of a list of OwningRewritePatternList. Each
 ///   OwningRewritePatternList in this list is applied once, in order.
 ///   2. the second stage consists of a single OwningRewritePattern that is
 ///   applied greedily until convergence.

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

 // canonicalization and dead code elimination.
 //
 // After this pass, no cstr_ operations exist.
 void populateRemoveShapeConstraintsPatterns(OwningRewritePatternList &patterns,
                                             MLIRContext *ctx);
 std::unique_ptr<FunctionPass> createRemoveShapeConstraintsPass();
 
 void populateShapeTypeConversionPatterns(
-    MLIRContext *ctx, BufferAssignmentTypeConverter *converter,
-    OwningRewritePatternList *patterns);
+    MLIRContext *ctx, BufferAssignmentTypeConverter &converter,
+    OwningRewritePatternList &patterns);
 // Collects a set of patterns to replace tensors as inputs and outputs to shape
 // operations with buffers. This only modifies the shape operations.
 std::unique_ptr<FunctionPass> createShapeTensorToMemrefPass();
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
 
 } // end namespace mlir
 
 #endif // MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES_H_

mlir/include/mlir/Transforms/Bufferize.h

 
 /// Helper conversion pattern that encapsulates a BufferAssignmentTypeConverter
 /// instance.
 template <typename SourceOp>
 class BufferAssignmentOpConversionPattern
     : public OpConversionPattern<SourceOp> {
 public:
   explicit BufferAssignmentOpConversionPattern(
-      MLIRContext *context, BufferAssignmentTypeConverter *converter,
+      MLIRContext *context, BufferAssignmentTypeConverter &converter,
       PatternBenefit benefit = 1)
-      : OpConversionPattern<SourceOp>(context, benefit), converter(converter) {
-    assert(converter && "The type converter has not been defined");
-  }
+      : OpConversionPattern<SourceOp>(context, benefit), converter(converter) {}
+
+protected:
+  BufferAssignmentTypeConverter &converter;
+};
+
+/// Helper conversion pattern that encapsulates a BufferAssignmentTypeConverter
+/// instance and that operates on Operation* to be compatible with OpInterfaces.
+/// This allows avoiding to instantiate N patterns for ops that can be subsumed
+/// by a single op interface (e.g. Linalg named ops).
+class BufferAssignmentConversionPattern : public ConversionPattern {
+public:
+  explicit BufferAssignmentConversionPattern(
+      MLIRContext *context, BufferAssignmentTypeConverter &converter,
+      PatternBenefit benefit = 1)
+      : ConversionPattern(benefit, converter, MatchAnyOpTypeTag()),
+        converter(converter) {}
 
 protected:
-  BufferAssignmentTypeConverter *converter;
+  BufferAssignmentTypeConverter &converter;
 };
 
 /// Converts the signature of the function using BufferAssignmentTypeConverter.
 /// Each result type of the function is kept as a function result or appended to
 /// the function arguments list based on ResultConversionKind for the converted
 /// result type.
 class BufferAssignmentFuncOpConverter
     : public BufferAssignmentOpConversionPattern<FuncOp> {
matchAndRewrite(ReturnOpSourceTy returnOp, ArrayRef<Value> operands,
     // Split the operands depending on whether they need a copy operation or
     // they remain as operands of the return operation. If an operand is
     // decomposable and a decompose callback function has been provided by the
     // user, it will be unpacked.
     SmallVector<Value, 2> newOperands, needCopyOperands;
     OpBuilder builder(returnOp);
     for (auto operand : llvm::enumerate(operands)) {
       SmallVector<Value, 2> values;
-      this->converter->tryDecomposeValue(
-          builder, loc, operand.value().getType(), operand.value(), values);
+      this->converter.tryDecomposeValue(builder, loc, operand.value().getType(),
+                                        operand.value(), values);
       Type type = returnOp.getOperand(operand.index()).getType();
       SmallVector<Type, 2> originTypes;
-      this->converter->tryDecomposeType(type, originTypes);
+      this->converter.tryDecomposeType(type, originTypes);
       for (auto value : llvm::enumerate(values)) {
         Type origin = originTypes[value.index()];
         Type converted = value.value().getType();
-        auto kind = this->converter->getResultConversionKind(origin, converted);
+        auto kind = this->converter.getResultConversionKind(origin, converted);
         if (kind == BufferAssignmentTypeConverter::KeepAsFunctionResult)
           newOperands.push_back(value.value());
         else
           // kind = BufferAssignmentTypeConverter::AppendToArgumentsList
           needCopyOperands.push_back(value.value());
       }
     }
 
LogicalResult matchAndRewrite(CallOp, ArrayRef<Value>,
                                 ConversionPatternRewriter &) const override;
 };
 
 /// Populates `patterns` with the conversion patterns of buffer
 /// assignment.
 template <typename ReturnOpSourceTy, typename ReturnOpTargetTy,
           typename CopyOpTy>
 static void populateWithBufferAssignmentOpConversionPatterns(
-    MLIRContext *context, BufferAssignmentTypeConverter *converter,
-    OwningRewritePatternList *patterns) {
+    MLIRContext *context, BufferAssignmentTypeConverter &converter,
+    OwningRewritePatternList &patterns) {
   // clang-format off
-  patterns->insert<
+  patterns.insert<
     BufferAssignmentCallOpConverter,
     BufferAssignmentFuncOpConverter,
     BufferAssignmentReturnOpConverter
       <ReturnOpSourceTy, ReturnOpTargetTy, CopyOpTy>
   >(context, converter);
   // clang-format on
 }
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_BUFFERIZE_H

mlir/integration_test/Dialect/Linalg/CPU/test-tensor-matmul.mlir

+// RUN: mlir-opt %s -convert-linalg-on-tensors-to-buffers -convert-linalg-to-loops -convert-linalg-to-llvm -convert-std-to-llvm | \
+// RUN: mlir-cpu-runner -e main -entry-point-result=void \
+// RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
+// RUN: | FileCheck %s
+
+func @main() {
+  %A = constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32>
+  %B = constant dense<[[1.0, 2.0, 3.0, 4.0],
+                       [5.0, 6.0, 7.0, 8.0],
+                       [9.0, 10.0, 11.0, 12.0]]> : tensor<3x4xf32>
+  %C = constant dense<1000.0> : tensor<2x4xf32>
+
+  %D = linalg.matmul ins(%A, %B: tensor<2x3xf32>, tensor<3x4xf32>)
+                     init(%C: tensor<2x4xf32>) -> tensor<2x4xf32>
+
+  %unranked = tensor_cast %D : tensor<2x4xf32> to tensor<*xf32>
+  call @print_memref_f32(%unranked) : (tensor<*xf32>) -> ()
+
+  //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
+  // CHECK-SAME: rank = 2 offset = 0 sizes = [2, 4] strides = [4, 1] data =
+  // CHECK-NEXT: [1038,   1044,   1050,   1056]
+  // CHECK-NEXT: [1065,   1074,   1083,   1092]
+
+  return
+}
+
+func @print_memref_f32(%ptr : tensor<*xf32>)

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

if (failed(applyPartialConversion(m, target, patterns)))
       signalPassFailure();
   }
 };
 
 } // anonymous namespace
 
 void mlir::populateGpuToNVVMConversionPatterns(
     LLVMTypeConverter &converter, OwningRewritePatternList &patterns) {
-  populateWithGenerated(converter.getDialect()->getContext(), &patterns);
+  populateWithGenerated(converter.getDialect()->getContext(), patterns);
   patterns
       .insert<GPUIndexIntrinsicOpLowering<gpu::ThreadIdOp, NVVM::ThreadIdXOp,
                                           NVVM::ThreadIdYOp, NVVM::ThreadIdZOp>,
               GPUIndexIntrinsicOpLowering<gpu::BlockDimOp, NVVM::BlockDimXOp,
                                           NVVM::BlockDimYOp, NVVM::BlockDimZOp>,
               GPUIndexIntrinsicOpLowering<gpu::BlockIdOp, NVVM::BlockIdXOp,
                                           NVVM::BlockIdYOp, NVVM::BlockIdZOp>,
               GPUIndexIntrinsicOpLowering<gpu::GridDimOp, NVVM::GridDimXOp,

mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp

if (failed(applyPartialConversion(m, target, patterns)))
       signalPassFailure();
   }
 };
 
 } // anonymous namespace
 
 void mlir::populateGpuToROCDLConversionPatterns(
     LLVMTypeConverter &converter, OwningRewritePatternList &patterns) {
-  populateWithGenerated(converter.getDialect()->getContext(), &patterns);
+  populateWithGenerated(converter.getDialect()->getContext(), patterns);
   patterns.insert<
       GPUIndexIntrinsicOpLowering<gpu::ThreadIdOp, ROCDL::ThreadIdXOp,
                                   ROCDL::ThreadIdYOp, ROCDL::ThreadIdZOp>,
       GPUIndexIntrinsicOpLowering<gpu::BlockDimOp, ROCDL::BlockDimXOp,
                                   ROCDL::BlockDimYOp, ROCDL::BlockDimZOp>,
       GPUIndexIntrinsicOpLowering<gpu::BlockIdOp, ROCDL::BlockIdXOp,
                                   ROCDL::BlockIdYOp, ROCDL::BlockIdZOp>,
       GPUIndexIntrinsicOpLowering<gpu::GridDimOp, ROCDL::GridDimXOp,

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.cpp

 
 namespace {
 #include "GPUToSPIRV.cpp.inc"
 }
 
 void mlir::populateGPUToSPIRVPatterns(MLIRContext *context,
                                       SPIRVTypeConverter &typeConverter,
                                       OwningRewritePatternList &patterns) {
-  populateWithGenerated(context, &patterns);
+  populateWithGenerated(context, patterns);
   patterns.insert<
       GPUFuncOpConversion, GPUModuleConversion, GPUReturnOpConversion,
       LaunchConfigConversion<gpu::BlockIdOp, spirv::BuiltIn::WorkgroupId>,
       LaunchConfigConversion<gpu::GridDimOp, spirv::BuiltIn::NumWorkgroups>,
       LaunchConfigConversion<gpu::ThreadIdOp,
                              spirv::BuiltIn::LocalInvocationId>,
       SingleDimLaunchConfigConversion<gpu::SubgroupIdOp,
                                       spirv::BuiltIn::SubgroupId>,
       SingleDimLaunchConfigConversion<gpu::NumSubgroupsOp,
                                       spirv::BuiltIn::NumSubgroups>,
       SingleDimLaunchConfigConversion<gpu::SubgroupSizeOp,
                                       spirv::BuiltIn::SubgroupSize>,
       WorkGroupSizeConversion>(context, typeConverter);
 }

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

 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Bufferize.h"
 
-namespace {
-
 using namespace ::mlir;
 using namespace ::mlir::linalg;
 
-SmallVector<Range, 4>
-computeLoopRanges(Location loc, linalg::GenericOp linalgOp, OpBuilder *b) {
+static SmallVector<Range, 4> computeLoopRanges(Location loc, LinalgOp linalgOp,
+                                               OpBuilder &b) {
   auto indexingMaps = llvm::to_vector<4>(
       linalgOp.indexing_maps().getAsValueRange<AffineMapAttr>());
   auto inputIndexingMaps =
       llvm::makeArrayRef(indexingMaps).take_front(linalgOp.getNumInputs());
 
-  mlir::edsc::ScopedContext scope(*b, loc);
+  mlir::edsc::ScopedContext scope(b, loc);
   return emitLoopRanges(scope.getBuilderRef(), loc,
                         concatAffineMaps(inputIndexingMaps),
-                        getShape(*b, linalgOp));
+                        getShape(b, linalgOp));
 }
 
-Value maybeConvertToIndex(Location loc, Value val, OpBuilder *b) {
+static Value maybeConvertToIndex(Location loc, Value val, OpBuilder &b) {
   if (val.getType().isIndex())
     return val;
-  return b->create<IndexCastOp>(loc, val, b->getIndexType());
+  return b.create<IndexCastOp>(loc, val, b.getIndexType());
 }
 
-LogicalResult allocateBuffersForResults(Location loc,
-                                        linalg::GenericOp linalgOp,
-                                        linalg::GenericOpAdaptor &adaptor,
-                                        SmallVectorImpl<Value> *resultBuffers,
-                                        OpBuilder *b) {
+static LogicalResult
+allocateBuffersForResults(Location loc, LinalgOp linalgOp,
+                          SmallVectorImpl<Value> &resultBuffers, OpBuilder &b) {
   // Lazily compute loopRanges.
   SmallVector<Range, 4> loopRanges;
 
   // Allocate a buffer for every tensor result.
-  for (auto en : llvm::enumerate(linalgOp.getResultTypes())) {
+  for (auto en : llvm::enumerate(linalgOp.getOperation()->getResultTypes())) {
     size_t resultIndex = en.index();
     Type resultType = en.value();
 
     auto tensorType = resultType.dyn_cast<RankedTensorType>();
     if (tensorType == nullptr) {
       linalgOp.emitOpError()
           << "tensor to buffer conversion expects ranked tensor results";
       return failure();
     }
     auto tensorShape = tensorType.getShape();
     auto memrefType = MemRefType::get(tensorShape, tensorType.getElementType());
 
     // Allocate buffers for init tensors that are assumed to fold onto the first
     // results.
     // TODO: update this assumption because the reality is more complex
     // under linalg on tensor based transformations.
     bool foldedInitTensor = resultIndex < linalgOp.getNumInitTensors();
     if (foldedInitTensor) {
       // Dealing with an init tensor requires distinguishing between 1-use
       // and many-use cases which would create aliasing and WAR hazards.
       Value initTensor = linalgOp.getInitTensor(resultIndex);
       Value initBuffer = adaptor.init_tensors()[resultIndex];
       if (initTensor.hasOneUse()) {
-        resultBuffers->push_back(initBuffer);
+        resultBuffers.push_back(initBuffer);
         continue;
       }
       SmallVector<Value, 4> dynOperands;
       for (auto dim : llvm::enumerate(tensorShape)) {
         if (dim.value() == TensorType::kDynamicSize) {
-          dynOperands.push_back(b->create<DimOp>(loc, initTensor, dim.index()));
+          dynOperands.push_back(b.create<DimOp>(loc, initTensor, dim.index()));
         }
       }
-      auto alloc = b->create<AllocOp>(loc, memrefType, dynOperands);
-      b->create<linalg::CopyOp>(loc, initBuffer, alloc);
-      resultBuffers->push_back(alloc);
+      auto alloc = b.create<AllocOp>(loc, memrefType, dynOperands);
+      b.create<linalg::CopyOp>(loc, initBuffer, alloc);
+      resultBuffers.push_back(alloc);
       continue;
     }
 
     // Allocate buffers for statically-shaped results.
     if (memrefType.hasStaticShape()) {
-      resultBuffers->push_back(b->create<AllocOp>(loc, memrefType));
+      resultBuffers.push_back(b.create<AllocOp>(loc, memrefType));
       continue;
     }
 
     // Perform a naive shape inference for the dynamically-shaped results.
     // Extract the required element out of the vector.
     SmallVector<Value, 4> dynOperands;
     auto resultIndexingMap = linalgOp.getOutputIndexingMap(resultIndex);
     for (auto shapeElement : llvm::enumerate(tensorType.getShape())) {
for (auto shapeElement : llvm::enumerate(tensorType.getShape())) {
         Value size = maybeConvertToIndex(loc, loopRanges[loopIndex].size, b);
         dynOperands.push_back(size);
         break;
       }
       default:
         return failure();
       }
     }
-    resultBuffers->push_back(b->create<AllocOp>(loc, memrefType, dynOperands));
+    resultBuffers.push_back(b.create<AllocOp>(loc, memrefType, dynOperands));
   }
   return success();
 }
 
+// Specialization for `linalg::GenericOp`.
 /// A pattern to convert Generic Linalg operations which work on tensors to
 /// use buffers. A buffer is allocated using BufferAssignmentPlacer for
 /// each operation result. BufferPlacement pass should be later used to move
 /// Alloc operations to the correct positions and insert the missing Dealloc
 /// operations in the correct places.
-class GenericOpConverter
-    : public BufferAssignmentOpConversionPattern<linalg::GenericOp> {
-public:
-  using BufferAssignmentOpConversionPattern<
-      linalg::GenericOp>::BufferAssignmentOpConversionPattern;
-
-  LogicalResult
-  matchAndRewrite(linalg::GenericOp linalgOp, ArrayRef<Value> operands,
-                  ConversionPatternRewriter &rewriter) const final {
-    linalg::GenericOpAdaptor adaptor(
-        operands, linalgOp.getOperation()->getAttrDictionary());
-
-    // All inputs need to be turned into buffers first. Until then, bail out.
-    if (llvm::any_of(adaptor.inputs(),
-                     [](Value in) { return !in.getType().isa<MemRefType>(); }))
-      return failure();
-
-    // All init_tensors need to be turned into buffers first. Until then, bail
-    // out.
-    if (llvm::any_of(adaptor.init_tensors(),
-                     [](Value in) { return !in.getType().isa<MemRefType>(); }))
-      return failure();
-
-    Location loc = linalgOp.getLoc();
-    SmallVector<Value, 2> newOutputBuffers(adaptor.output_buffers().begin(),
-                                           adaptor.output_buffers().end());
-
-    if (failed(allocateBuffersForResults(loc, linalgOp, adaptor,
-                                         &newOutputBuffers, &rewriter))) {
-      linalgOp.emitOpError()
-          << "Failed to allocate buffers for tensor results.";
-      return failure();
-    }
-
-    // Generate a new linalg operation that works on buffers.
-    auto newLinalgOp = rewriter.create<linalg::GenericOp>(
-        loc,
-        /*resultTensorTypes=*/llvm::None,
-        /*inputs=*/adaptor.inputs(),
-        /*outputBuffers=*/newOutputBuffers,
-        /*initTensors=*/llvm::None, linalgOp.indexing_maps(),
-        linalgOp.iterator_types(), linalgOp.docAttr(),
-        linalgOp.library_callAttr(), linalgOp.symbol_sourceAttr());
+static void finalizeBufferAllocation(ConversionPatternRewriter &rewriter,
+                                     linalg::GenericOp genericOp,
+                                     ValueRange inputs, ValueRange outputs) {
+  auto newGenericOp = rewriter.create<linalg::GenericOp>(
+      genericOp.getLoc(),
+      /*inputs=*/inputs,
+      /*outputBuffers=*/outputs,
+      /*initTensors=*/llvm::None, genericOp.indexing_maps(),
+      genericOp.iterator_types(), genericOp.docAttr(),
+      genericOp.library_callAttr(), genericOp.symbol_sourceAttr());
 
-    // Create a new block in the region of the new Generic Op.
-    Block *oldBlock = linalgOp.getBody();
-    Region &newRegion = newLinalgOp.region();
-    Block *newBlock = rewriter.createBlock(&newRegion, newRegion.begin(),
-                                           oldBlock->getArgumentTypes());
+  Block *oldBlock = genericOp.getBody();
+  Region &newRegion = newGenericOp.region();
 
-    // Add the result arguments that do not come from init_tensors to the new
-    // block.
-    // TODO: update this assumption because the reality is more complex under
-    // linalg on tensor based transformations.
-    for (Value v :
-         ValueRange(newOutputBuffers).drop_front(adaptor.init_tensors().size()))
-      newBlock->addArgument(v.getType().cast<MemRefType>().getElementType());
+  // Add the result arguments to the new block.
+  for (Value v : ValueRange(outputs).drop_front(genericOp.getNumInitTensors()))
 
-    // Clone the body of the old block to the new block.
-    BlockAndValueMapping mapping;
-    mapping.map(oldBlock->getArguments(), newBlock->getArguments());
 
-    OpBuilder::InsertionGuard guard(rewriter);
-    rewriter.setInsertionPointToEnd(newBlock);
-    for (auto &op : oldBlock->getOperations()) {
-      Operation *clonedOp = rewriter.clone(op, mapping);
-      mapping.map(op.getResults(), clonedOp->getResults());
-    }
 
-    // Replace the results of the old op with the new output buffers.
-    rewriter.replaceOp(linalgOp, newOutputBuffers);
-    return success();
-  }
-};
+  rewriter.replaceOp(genericOp, outputs);
+}
+
+// TODO: Specialization for `linalg::IndexedGenericOp`.
+
+// Specialization for all other `linalg::LinalgOp`.
+static void finalizeBufferAllocation(ConversionPatternRewriter &rewriter,
+                                     linalg::LinalgOp linalgOp,
+                                     ValueRange inputs, ValueRange outputs) {
+  assert(!isa<linalg::GenericOp>(linalgOp.getOperation()));
+  assert(!isa<linalg::IndexedGenericOp>(linalgOp.getOperation()));
+  SmallVector<Value, 8> newOperands = inputs;
+  newOperands.append(outputs.begin(), outputs.end());
+  auto otherOperands = linalgOp.getAssumedNonShapedOperands();
+  newOperands.append(otherOperands.begin(), otherOperands.end());
+  LinalgOp res = cast<LinalgOp>(linalgOp.clone(rewriter, linalgOp.getLoc(),
+                                               /*resultTypes=*/ArrayRef<Type>{},
+                                               newOperands));
+  // Need to mutate the operands_segment_sizes in the resulting op.
+  res.setNumOutputBuffers(outputs.size());
+  res.setNumInitTensors(0);
+  // Replace the results of the old op with the new output buffers.
+  rewriter.replaceOp(linalgOp, outputs);
+}
+
+LogicalResult mlir::linalg::LinalgOpConverter::matchAndRewrite(
+    Operation *op, ArrayRef<Value> operands,
+    ConversionPatternRewriter &rewriter) const {
+  LinalgOp linalgOp = dyn_cast<linalg::LinalgOp>(op);
+  if (!linalgOp)
+    return failure();
+
+  // We abuse the GenericOpAdaptor here.
+  // TODO: Manually create an Adaptor that captures inputs, output_buffers and
+  // init_tensors for all linalg::LinalgOp interface ops.
+  linalg::GenericOpAdaptor adaptor(operands, op->getAttrDictionary());
+
+  // All inputs need to be turned into buffers first. Until then, bail out.
+  if (llvm::any_of(adaptor.inputs(),
+                   [](Value in) { return !in.getType().isa<MemRefType>(); }))
+    return failure();
+
+  // All init_tensors need to be turned into buffers first. Until then, bail
+  // out.
+  if (llvm::any_of(adaptor.init_tensors(),
+                   [](Value in) { return !in.getType().isa<MemRefType>(); }))
+    return failure();
+
+  Location loc = linalgOp.getLoc();
+  SmallVector<Value, 2> newOutputBuffers(adaptor.output_buffers().begin(),
+                                         adaptor.output_buffers().end());
+
+  if (failed(allocateBuffersForResults(loc, linalgOp, adaptor, newOutputBuffers,
+                                       rewriter))) {
+    linalgOp.emitOpError() << "Failed to allocate buffers for tensor results.";
+    return failure();
+  }
+
+  // Delegate to the linalg generic pattern.
+  if (auto genericOp = dyn_cast<linalg::GenericOp>(op)) {
+    finalizeBufferAllocation(rewriter, genericOp, adaptor.inputs(),
+                             newOutputBuffers);
+    return success();
+  }
+
+  finalizeBufferAllocation(rewriter, linalgOp, adaptor.inputs(),
+                           newOutputBuffers);
 
-// Rewrite a tensor `constant` to a vector constant folloed by a vector store
-// and a vector.type_cast.
-class TensorConstantOpConverter
-    : public BufferAssignmentOpConversionPattern<ConstantOp> {
-public:
-  using BufferAssignmentOpConversionPattern<
-      ConstantOp>::BufferAssignmentOpConversionPattern;
-
-  LogicalResult
-  matchAndRewrite(ConstantOp op, ArrayRef<Value> operands,
-                  ConversionPatternRewriter &rewriter) const final {
-    if (!op.getType().isa<RankedTensorType>())
-      return failure();
-    auto attr = op.getValue().cast<DenseElementsAttr>();
+LogicalResult mlir::linalg::TensorConstantOpConverter::matchAndRewrite(
+    ConstantOp op, ArrayRef<Value> operands,
+    ConversionPatternRewriter &rewriter) const {
 
-    Location loc = op.getLoc();
-    MemRefType memrefType =
-        converter->convertType(op.getType()).cast<MemRefType>();
-    VectorType vectorType =
-        VectorType::get(memrefType.getShape(), memrefType.getElementType());
-
-    // vector constant takes attributes that are compatible with tensor
-    // constant.
-    Value cstVec =
-        rewriter.create<ConstantOp>(loc, vectorType, attr.reshape(vectorType));
+      converter.convertType(op.getType()).cast<MemRefType>();
 
-    // Alloc a memref<vector<...>>, store the constant and typecast the vector
-    // away.
-    MemRefType memrefOfVectorType = MemRefType::get({}, vectorType);
-    Value alloc =
-        rewriter.create<AllocOp>(loc, memrefOfVectorType, ValueRange{});
-    rewriter.create<StoreOp>(loc, cstVec, alloc);
-    rewriter.replaceOpWithNewOp<vector::TypeCastOp>(op, memrefType, alloc);
+  Value alloc = rewriter.create<AllocOp>(loc, memrefOfVectorType, ValueRange{});
 
-    return success();
-  }
-};
 
-// Rewrite a `tensor_cast` as a `memref_cast` with no layout, in the 0-memory
-// space.
-class TensorCastOpConverter
-    : public BufferAssignmentOpConversionPattern<TensorCastOp> {
-public:
-  using BufferAssignmentOpConversionPattern<
-      TensorCastOp>::BufferAssignmentOpConversionPattern;
-
-  LogicalResult
-  matchAndRewrite(TensorCastOp op, ArrayRef<Value> operands,
-                  ConversionPatternRewriter &rewriter) const final {
-    if (op.getType().hasRank())
-      return failure();
-    Type t = UnrankedMemRefType::get(op.getType().getElementType(),
-                                     /*memorySpace=*/0);
-    rewriter.replaceOpWithNewOp<MemRefCastOp>(op, t, operands.front());
-    return success();
-  }
-};
+LogicalResult mlir::linalg::TensorCastOpConverter::matchAndRewrite(
+    TensorCastOp op, ArrayRef<Value> operands,
+    ConversionPatternRewriter &rewriter) const {
+
+namespace {
 
 /// Converts Linalg operations that work on tensor-type operands or results to
 /// work on buffers.
 struct ConvertLinalgOnTensorsToBuffers
     : public LinalgOnTensorsToBuffersBase<ConvertLinalgOnTensorsToBuffers> {
   void runOnOperation() override {
     MLIRContext &context = getContext();
     ConversionTarget target(context);
target.addDynamicallyLegalOp<FuncOp>([&](FuncOp funcOp) {
                            [&](Type type) { return type.isa<MemRefType>(); }) &&
              converter.isLegal(&funcOp.getBody());
     });
 
     converter.setResultConversionKind<RankedTensorType, MemRefType>(
         BufferAssignmentTypeConverter::AppendToArgumentsList);
 
     OwningRewritePatternList patterns;
-    populateConvertLinalgOnTensorsToBuffersPatterns(&context, &converter,
-                                                    &patterns);
+    populateConvertLinalgOnTensorsToBuffersPatterns(&context, converter,
+                                                    patterns);
     populateWithBufferAssignmentOpConversionPatterns<
-        mlir::ReturnOp, mlir::ReturnOp, linalg::CopyOp>(&context, &converter,
-                                                        &patterns);
+        mlir::ReturnOp, mlir::ReturnOp, linalg::CopyOp>(&context, converter,
+                                                        patterns);
     if (failed(applyFullConversion(this->getOperation(), target, patterns)))
       this->signalPassFailure();
   }
 };
 } // end anonymous namespace
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createConvertLinalgOnTensorsToBuffersPass() {
   return std::make_unique<ConvertLinalgOnTensorsToBuffers>();
 }
-
 void mlir::linalg::populateConvertLinalgOnTensorsToBuffersPatterns(
-    MLIRContext *context, BufferAssignmentTypeConverter *converter,
-    OwningRewritePatternList *patterns) {
-  patterns->insert<
+
+    MLIRContext *context, BufferAssignmentTypeConverter &converter,
+    OwningRewritePatternList &patterns) {
+  patterns.insert<
       // clang-format off
-      GenericOpConverter,
+      LinalgOpConverter,
       TensorCastOpConverter,
       TensorConstantOpConverter
       // clang-format on
       >(context, converter);
 }

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

public:
 
   LogicalResult
   matchAndRewrite(shape::AssumingOp assumingOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     SmallVector<Type, 2> newResultTypes;
     newResultTypes.reserve(assumingOp.getNumResults());
     for (auto result : assumingOp.getResults()) {
       auto originalType = result.getType();
-      Type convertedType = converter->convertType(originalType);
+      Type convertedType = converter.convertType(originalType);
       newResultTypes.push_back(convertedType);
     }
 
     auto newAssumingOp = rewriter.create<shape::AssumingOp>(
         assumingOp.getLoc(), newResultTypes, assumingOp.witness());
 
     rewriter.replaceOp(assumingOp, newAssumingOp.getResults());
     rewriter.inlineRegionBefore(assumingOp.doRegion(), newAssumingOp.doRegion(),
                                 newAssumingOp.doRegion().end());
 
     return success();
   }
 };
 
 struct ShapeTensorToMemrefPass
     : public ShapeTensorToMemrefBase<ShapeTensorToMemrefPass> {
   void runOnFunction() override {
     MLIRContext &ctx = getContext();
 
     OwningRewritePatternList patterns;
     BufferAssignmentTypeConverter converter;
-    populateShapeTypeConversionPatterns(&ctx, &converter, &patterns);
+    populateShapeTypeConversionPatterns(&ctx, converter, patterns);
 
     ConversionTarget target(getContext());
     auto isMemRefType = [](Type type) { return type.isa<BaseMemRefType>(); };
 
     target.addDynamicallyLegalOp<AssumingOp>([&](shape::AssumingOp op) {
       return std::all_of(op.result_type_begin(), op.result_type_end(),
                          isMemRefType);
     });
 
     if (failed(mlir::applyPartialConversion(getFunction(), target, patterns)))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 /// Populates `patterns` with the conversion patterns of tensor->memref.
 //
 // TODO: Change this to work generally with any type conversions.
 void mlir::populateShapeTypeConversionPatterns(
-    MLIRContext *context, BufferAssignmentTypeConverter *converter,
-    OwningRewritePatternList *patterns) {
-  patterns->insert<TypeConversionAssumingOpConverter>(context, converter);
+    MLIRContext *context, BufferAssignmentTypeConverter &converter,
+    OwningRewritePatternList &patterns) {
+  patterns.insert<TypeConversionAssumingOpConverter>(context, converter);
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeTensorToMemrefPass construction
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<FunctionPass> mlir::createShapeTensorToMemrefPass() {
   return std::make_unique<ShapeTensorToMemrefPass>();
 }

mlir/lib/Transforms/BufferPlacement.cpp

LogicalResult BufferAssignmentFuncOpConverter::matchAndRewrite(
     mlir::FuncOp funcOp, ArrayRef<Value> operands,
     ConversionPatternRewriter &rewriter) const {
   auto funcType = funcOp.getType();
 
   // Convert function arguments using the provided TypeConverter.
   TypeConverter::SignatureConversion conversion(funcType.getNumInputs());
   for (auto argType : llvm::enumerate(funcType.getInputs())) {
     SmallVector<Type, 2> decomposedTypes, convertedTypes;
-    converter->tryDecomposeType(argType.value(), decomposedTypes);
-    converter->convertTypes(decomposedTypes, convertedTypes);
+    converter.tryDecomposeType(argType.value(), decomposedTypes);
+    converter.convertTypes(decomposedTypes, convertedTypes);
     conversion.addInputs(argType.index(), convertedTypes);
   }
 
   // Convert the result types of the function.
   SmallVector<Type, 2> newResultTypes;
   newResultTypes.reserve(funcOp.getNumResults());
   for (Type resultType : funcType.getResults()) {
     SmallVector<Type, 2> originTypes;
-    converter->tryDecomposeType(resultType, originTypes);
+    converter.tryDecomposeType(resultType, originTypes);
     for (auto origin : originTypes) {
-      Type converted = converter->convertType(origin);
-      auto kind = converter->getResultConversionKind(origin, converted);
+      Type converted = converter.convertType(origin);
+      auto kind = converter.getResultConversionKind(origin, converted);
       if (kind == BufferAssignmentTypeConverter::AppendToArgumentsList)
         conversion.addInputs(converted);
       else
         // kind = BufferAssignmentTypeConverter::KeepAsFunctionResult
         newResultTypes.push_back(converted);
     }
   }
 
-  if (failed(rewriter.convertRegionTypes(&funcOp.getBody(), *converter,
+  if (failed(rewriter.convertRegionTypes(&funcOp.getBody(), converter,
                                          &conversion)))
     return failure();
 
   // Update the signature of the function.
   rewriter.updateRootInPlace(funcOp, [&] {
     funcOp.setType(rewriter.getFunctionType(conversion.getConvertedTypes(),
                                             newResultTypes));
   });
LogicalResult BufferAssignmentCallOpConverter::matchAndRewrite(
   // to an externally defined symbol like an external library calls), only
   // convert if some special attribute is set.
   // This will allow more control of interop across ABI boundaries.
 
   // Create the operands list of the new `CallOp`. It unpacks the decomposable
   // values if a decompose callback function has been provided by the user.
   for (auto operand : operands) {
     SmallVector<Value, 2> values;
-    this->converter->tryDecomposeValue(builder, loc, operand.getType(), operand,
-                                       values);
+    this->converter.tryDecomposeValue(builder, loc, operand.getType(), operand,
     newOperands.append(values.begin(), values.end());
   }
 
   // Create the new result types for the new `CallOp` and a mapping from the old
   // result to new value(s).
   SmallVector<Type, 2> newResultTypes;
   SmallVector<CallOpResultMapping, 4> mappings;
   mappings.resize(callOp.getNumResults());
   for (auto result : llvm::enumerate(callOp.getResults())) {
     SmallVector<Type, 2> originTypes;
-    converter->tryDecomposeType(result.value().getType(), originTypes);
+    converter.tryDecomposeType(result.value().getType(), originTypes);
     auto &resultMapping = mappings[result.index()];
     for (Type origin : originTypes) {
-      Type converted = converter->convertType(origin);
-      auto kind = converter->getResultConversionKind(origin, converted);
+      Type converted = converter.convertType(origin);
+      auto kind = converter.getResultConversionKind(origin, converted);
       if (kind == BufferAssignmentTypeConverter::KeepAsFunctionResult) {
         newResultTypes.push_back(converted);
         // The result value is not yet available. Its index is kept and it is
         // replaced with the actual value of the new `CallOp` later.
         resultMapping.addMapping(newResultTypes.size() - 1);
       } else {
         // kind = BufferAssignmentTypeConverter::AppendToArgumentsList
         MemRefType memref = converted.dyn_cast<MemRefType>();
for (unsigned i = 0, e = callOp.getNumResults(); i < e; ++i) {
     if (valuesToPack.empty()) {
       // No replacement is required.
       replacedValues.push_back(nullptr);
     } else if (valuesToPack.size() == 1) {
       replacedValues.push_back(valuesToPack.front());
     } else {
       // Values need to be packed using callback function. The same callback
       // that is used for materializeArgumentConversion is used for packing.
-      Value packed = converter->materializeArgumentConversion(
+      Value packed = converter.materializeArgumentConversion(
           nextBuilder, loc, callOp.getType(i), valuesToPack);
       replacedValues.push_back(packed);
     }
   }
   rewriter.replaceOp(callOp, replacedValues);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // BufferPlacementPass construction
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<Pass> mlir::createBufferPlacementPass() {
   return std::make_unique<BufferPlacementPass>();
 }

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

LogicalResult matchAndRewrite(Operation *op,
     rewriter.replaceOp(op, result);
     return success();
   }
 };
 
 struct TestPatternDriver : public PassWrapper<TestPatternDriver, FunctionPass> {
   void runOnFunction() override {
     mlir::OwningRewritePatternList patterns;
-    populateWithGenerated(&getContext(), &patterns);
+    populateWithGenerated(&getContext(), patterns);
 
     // Verify named pattern is generated with expected name.
     patterns.insert<FoldingPattern, TestNamedPatternRule>(&getContext());
 
     applyPatternsAndFoldGreedily(getFunction(), patterns);
   }
 };
 } // end anonymous namespace
struct TestLegalizePatternDriver
   /// The mode of conversion to use with the driver.
   enum class ConversionMode { Analysis, Full, Partial };
 
   TestLegalizePatternDriver(ConversionMode mode) : mode(mode) {}
 
   void runOnOperation() override {
     TestTypeConverter converter;
     mlir::OwningRewritePatternList patterns;
-    populateWithGenerated(&getContext(), &patterns);
+    populateWithGenerated(&getContext(), patterns);
     patterns.insert<
         TestRegionRewriteBlockMovement, TestRegionRewriteUndo, TestCreateBlock,
         TestCreateIllegalBlock, TestUndoBlockArgReplace, TestUndoBlockErase,
         TestPassthroughInvalidOp, TestSplitReturnType,
         TestChangeProducerTypeI32ToF32, TestChangeProducerTypeF32ToF64,
         TestChangeProducerTypeF32ToInvalid, TestUpdateConsumerType,
         TestNonRootReplacement, TestBoundedRecursiveRewrite,
         TestNestedOpCreationUndoRewrite>(&getContext());

mlir/test/lib/Transforms/TestBufferPlacement.cpp

matchAndRewrite(linalg::GenericOp op, ArrayRef<Value> operands,
 
       // Replace the results of the old op with the new output buffers.
       rewriter.replaceOp(op, newOutputBuffers);
       return success();
     }
   };
 
   void populateTensorLinalgToBufferLinalgConversionPattern(
-      MLIRContext *context, BufferAssignmentTypeConverter *converter,
-      OwningRewritePatternList *patterns) {
+      MLIRContext *context, BufferAssignmentTypeConverter &converter,
+      OwningRewritePatternList &patterns) {
     populateWithBufferAssignmentOpConversionPatterns<
         mlir::ReturnOp, mlir::ReturnOp, linalg::CopyOp>(context, converter,
                                                         patterns);
-    patterns->insert<GenericOpConverter>(context, converter);
+    patterns.insert<GenericOpConverter>(context, converter);
   }
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<TestDialect>();
     registry.insert<linalg::LinalgDialect>();
   }
 
   void runOnOperation() override {
converter.addDecomposeValueConversion([](OpBuilder &builder, Location loc,
         Value res = builder.create<GetTupleElementOp>(
             loc, resultType.getType(i), value, builder.getI32IntegerAttr(i));
         values.push_back(res);
       }
       return success();
     });
 
     OwningRewritePatternList patterns;
-    populateTensorLinalgToBufferLinalgConversionPattern(&context, &converter,
-                                                        &patterns);
+    populateTensorLinalgToBufferLinalgConversionPattern(&context, converter,
+                                                        patterns);
     if (failed(applyFullConversion(this->getOperation(), target, patterns)))
       this->signalPassFailure();
   };
 };
 } // end anonymous namespace
 
 namespace mlir {
 void registerTestBufferPlacementPreparationPass() {

mlir/tools/mlir-tblgen/RewriterGen.cpp

for (Record *p : patterns) {
     PatternEmitter(p, &recordOpMap, os).emit(name);
     LLVM_DEBUG(llvm::dbgs()
                << "=== done generating pattern '" << name << "' ===\n");
     rewriterNames.push_back(std::move(name));
   }
 
   // Emit function to add the generated matchers to the pattern list.
   os << "void LLVM_ATTRIBUTE_UNUSED populateWithGenerated(::mlir::MLIRContext "
-        "*context, ::mlir::OwningRewritePatternList *patterns) {\n";
+        "*context, ::mlir::OwningRewritePatternList &patterns) {\n";
   for (const auto &name : rewriterNames) {
-    os << "  patterns->insert<" << name << ">(context);\n";
+    os << "  patterns.insert<" << name << ">(context);\n";
   }
   os << "}\n";
 }
 
 static mlir::GenRegistration
     genRewriters("gen-rewriters", "Generate pattern rewriters",
                  [](const RecordKeeper &records, raw_ostream &os) {
                    emitRewriters(records, os);
                    return false;
                  });