[mlir][linalg] Retire Linalg ConvOp.

[gysit]

Summary

The convolution op is one of the remaining hard coded Linalg operations that have no region attached. It got obsolete due to the OpDSL convolution operations. Removing it allows us to delete specialized code and tests that are not needed for the OpDSL counterparts that rely on the standard code paths.

Test needed due to specialized implementations are removed. Tiling and fusion tests are replaced by variants using linalg.conv_2d.

[nicolasvasilache]

Great! Thanks much for cleaning this up.

[gysit]

Rebase.

[arnab-oss]

Initially Linalg::ConvOp had padding attribute, but the current set of convolution ops don't have them. Is there anyway I can define convolution with padding with the current Linalg Dialect?
CC - @bondhugula , @gysit , @nicolasvasilache

[gysit]

In D111233#3202222, @arnab-oss wrote:

Initially Linalg::ConvOp had padding attribute, but the current set of convolution ops don't have them. Is there anyway I can define convolution with padding with the current Linalg Dialect?
CC - @bondhugula , @gysit , @nicolasvasilache

I think you cannot have a convolution with padding in one operation. However, you can combine a convolution op with a linalg.pad_tensor operation to emulate the old padding behavior.

[nicolasvasilache]

Correct, padding is a separate first-class op now and there is no support for single-op conv+padding in linalg atm.
Once some of the ongoing refactorings are landed, it may make sense to introduce a frontend op that also allows padding as a convenience.

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.h

 #include "mlir/Interfaces/ViewLikeInterface.h"
 #include "mlir/Support/LLVM.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 namespace mlir {
 namespace linalg {
 
-class ConvOp;
 class LinalgOp;
 
 // TOFO: allow an extra ValueRange to specify an indexing and allow
 // non-hyperrectangular shapes.
 using LoopRangeBuilder =
     std::function<SmallVector<Range, 4>(ImplicitLocOpBuilder)>;
 
 /// Provide a very simple inference procedure to build the loop ranges from the

 ///   name mangles into `linalg_matmul_viewxxf32_viewxxf32_viewxxf32`
 std::string generateLibraryCallName(Operation *op);
 
 /// Returns `num` AffineDimExpr dimensions at positions
 ///   [startIdx, startIdx + num) and increments `startIdx` to `startIdx + num`.
 SmallVector<AffineExpr, 4> makeAffineDimExprs(unsigned num, unsigned &startIdx,
                                               MLIRContext *context);
 
-/// Builds the indexing expressions for a ConvOp/PoolingOp `op`. Returns the
-/// vector of AffineMaps representing:
-///   `stride[i] * outputDims[i] + dilation[i] * windowDims[i] - pad_low[i]`
-template <typename PoolingOp>
-extern SmallVector<AffineExpr, 4>
-weightedPoolingInputIndex(PoolingOp op, ArrayRef<AffineExpr> outputDims,
-                          ArrayRef<AffineExpr> windowDims);
-
 /// Returns `maybeMap.get()` if `maybeMap` is set, otherwise returns the
 /// symbol-less identity map of `rank`.
 AffineMap extractOrIdentityMap(Optional<AffineMap> maybeMap, unsigned rank,
                                MLIRContext *context);
 
 /// Return the vector that is the concatenation of `a` and `b`.
 SmallVector<AffineExpr, 4> concat(ArrayRef<AffineExpr> a,
                                   ArrayRef<AffineExpr> b);

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

let builders = [
     OpBuilder<(ins "Value":$value, "Value":$output)>
   ];
 
   let verifier = [{ return ::verify(*this); }];
 
   let hasFolder = 1;
 }
 
-/// A base class for pooling operation such as conv. The arguments must contain
-/// optional arguments `strides`, `dilations` and `padding` with following type:
-///   OptionalAttr<I64ArrayAttr>:$strides
-///   OptionalAttr<I64ArrayAttr>:$dilations
-///   OptionalAttr<I64ElementsAttr>:$padding
-/// `strides` denotes the step of each window along the dimension.
-class PoolingBase_Op<string mnemonic, list<OpTrait> props>
-  : LinalgStructured_Op<mnemonic, props> {
-  let description = [{
-    Performs an N-D pooling operation similarly to the description in the TF
-    documentation:
-    https://www.tensorflow.org/api_docs/python/tf/nn/pool
-
-    Different from the description, this operation doesn't perform on batch and
-    channel. It only takes tensors of rank `N`.
-
-    ```
-      output[x[0], ..., x[N-1]] =
-        REDUCE_{z[0], ..., z[N-1]}
-          input[
-                x[0] * strides[0] - pad_before[0] + dilation_rate[0]*z[0],
-                ...
-                x[N-1]*strides[N-1] - pad_before[N-1] + dilation_rate[N-1]*z[N-1]
-                ],
-    ```
-
-    The required optional arguments are:
-      - strides: an i64 array specifying the stride (i.e. step) for window
-        loops.
-      - dilations: an i64 array specifying the filter upsampling/input
-        downsampling rate
-      - padding: an i64 array of pairs (low, high) specifying the number of
-        elements to pad along a dimension.
-
-    If strides or dilations attributes are missing then the default value is
-    one for each of the input dimensions. Similarly, padding values are zero
-    for both low and high in each of the dimensions, if not specified.
-  }];
-
-  code commonUtils = structuredOpsDecls # [{
-    int64_t getStride(unsigned i) {
-      assert(i < getNumWindowLoops());
-      if (!strides().hasValue()) return 1;
-      return strides()->getValue()[i]
-        .cast<IntegerAttr>().getValue().getSExtValue();
-    }
-
-    int64_t getDilation(unsigned i) {
-      assert(i < getNumWindowLoops());
-      if (!dilations().hasValue()) return 1;
-      return dilations()->getValue()[i]
-        .cast<IntegerAttr>().getValue().getSExtValue();
-    }
-
-    int64_t getLowPad(unsigned i) {
-      assert(i < getNumWindowLoops());
-      if (!padding().hasValue()) return 0;
-      return padding().getValue().getValue<int64_t>({i, 0});
-    }
-
-    int64_t getHighPad(unsigned i) {
-      assert(i < getNumWindowLoops());
-      if (!padding().hasValue()) return 0;
-      return padding().getValue().getValue<int64_t>({i, 1});
-    }
-
-    static std::function<void(ImplicitLocOpBuilder &b, Block &block)>
-    getRegionBuilder() {
-      return nullptr;
-    }
-  }];
-}
-
-// Only support buffer semantics.
-def ConvOp : PoolingBase_Op<"conv", []> {
-  let description = [{
-    Generic n-D convolution as described in the TF documentation:
-    https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/nn/convolution
-
-    ```
-      output[b, x[0], ..., x[N-1], k] =
-      sum_{z[0], ..., z[N-1], q}
-          filter[z[0], ..., z[N-1], q, k] *
-          padded_input[b,
-                       x[0] * strides[0] + dilation_rate[0] * z[0],
-                       ...,
-                       x[N-1] * strides[N-1] + dilation_rate[N-1] * z[N-1],
-                       q]
-    ```
-  }];
-
-  // Following the TF source of truth above, strides, dilations and padding are
-  // integer attributes of the same rank as the number of window dimensions.
-  // The padding attribute specifies the amount of zero padding to be applied to
-  // the base area, which is a n-d array of (low, high) padding. Each pair has
-  // the low padding as the first element and the high padding as the second
-  // element. Using padding is equivalent to inserting those same zero values
-  // into the input before doing the convolution.
-  let arguments = (ins AnyStridedMemRef:$filter, AnyStridedMemRef:$input,
-                   AnyStridedMemRef:$output,
-                   OptionalAttr<I64ArrayAttr>:$strides,
-                   OptionalAttr<I64ArrayAttr>:$dilations,
-                   OptionalAttr<I64ElementsAttr>:$padding);
-
-  let extraClassDeclaration = commonUtils # [{
-    ValueRange inputs() { return getOperands().slice(0, 2); }
-    ValueRange outputs() { return getOperands().take_back(); }
-
-    // TODO: extend to support more than 1 dimensions and potentially grouping
-    // too.
-    unsigned getNumBatchDimensions() { return 1; }
-
-    unsigned getNumInputFeatureDimensions() { return 1; }
-
-    unsigned getNumOutputFeatureDimensions() { return 1; }
-
-    unsigned getNumSpatialDimensions() {
-      return getRank(getOutputOperand(0)) - getNumBatchDimensions() -
-             getNumOutputFeatureDimensions();
-    }
-
-    ArrayAttr iterator_types() {
-      // Outer parallel loops are always the number of output dimensions; i.e.
-      // [b, xs, q] in the TF notation above.
-      int64_t nPar = getRank(getOutputOperand(0));
-      unsigned nRed = getNumInputFeatureDimensions();
-      // Window loops are a special kind of reduction that is never tiled or
-      // parallelized across; i.e. [zs] in the TF notation above whose number
-      // match `xs` (i.e. 1 window loop per "image" dimension).
-      // This may evolve in the future.
-      // Conditionally check nPar is large enough for cases of ill-formed op:
-      // this avoids overflows before hitting the verifier.
-      assert(nPar > getNumBatchDimensions() + getNumInputFeatureDimensions() &&
-             "expected at least one window dimension (i.e. memref ranks greater "
-             "than 2). See 'func @conv_rank_limit' in "
-             "mlir/test/Dialect/Linalg/invalid.mlir");
-      unsigned nWin =
-        nPar - getNumBatchDimensions() - getNumInputFeatureDimensions();
-      SmallVector<StringRef, 8> iters(nPar, getParallelIteratorTypeName());
-      iters.reserve(nPar + nRed + nWin);
-      iters.append(nRed, getReductionIteratorTypeName());
-      iters.append(nWin, getWindowIteratorTypeName());
-      return Builder(getContext()).getStrArrayAttr(iters);
-    }
-
-    //   F(z0, ..., zN-1, q, k) *
-    //     I(b, x0 + z0 - pad_low_0, ..., xN-1 + zN-1 - pad_low_N-1, q)
-    //   ->  O(b, x0, ..., xN-1, k)
-    // for N equal to `nWindow`. If there is no padding attribute, it will be
-    // ignored.
-    ArrayAttr indexing_maps() {
-      MLIRContext *context = getContext();
-      auto nWin = getNumWindowLoops();
-      assert(nWin > 0 && "expected at least one window dimension (i.e. memref "
-                         "ranks greater than 2)");
-      unsigned idx = 0;
-      // In the following, AffineDimExprs are indexed in loop order:
-      //   [ b, xs, k,           q,                     zs]
-      //    parallels     non-window reductions     windows
-      //
-      // Parallel dims are exactly the dimensions indexing `output`:
-      //     output[b, x[0], ..., x[N-1], k]; i.e.
-      //  * batch dimensions (bs with #bs = 1 for now)
-      //  * "image" dimensions (xs with #xs = #zs = output_rank - #bs - #ks)
-      //  * output filter dimensions (ks with #ks = 1 for now)
-      auto bs = makeAffineDimExprs(getNumBatchDimensions(), idx, context);
-      auto xs = makeAffineDimExprs(nWin, idx, context);
-      auto ks = makeAffineDimExprs(
-        getNumOutputFeatureDimensions(), idx, context);
-      // Non-window reduction dim: sum_{z[0], ..., z[N-1], q}
-      auto qs = makeAffineDimExprs(
-        getNumInputFeatureDimensions(), idx, context);
-      // Window reduction dims: sum_{z[0], ..., z[N-1], q}
-      auto zs = makeAffineDimExprs(nWin, idx, context);
-      // Construct the weighedSum expression.
-      auto ws = weightedPoolingInputIndex(*this, xs, zs);
-      return Builder(getContext()).getAffineMapArrayAttr({
-        // filter[z[0], ..., z[N-1], q, k]
-        AffineMap::get(idx, 0, concat(concat(zs, qs), ks), context),
-        // input[b,
-        //       x[0]*s[0] + d[0]*z[0] - pad_low[0],
-        //       ...
-        //       x[N-1]*s[N-1] + d[N-1]*z[N-1] - pad_low[N-1],
-        //       q]
-        AffineMap::get(idx, 0, concat(concat(bs, ws), qs), context),
-        // output[b, x[0], ..., x[N-1], k]
-        AffineMap::get(idx, 0, concat(concat(bs, xs), ks), context)});
-    }
-  }];
-
-  let verifier = [{ return ::verify(*this); }];
-
-  let hasFolder = 1;
-}
-
 //===----------------------------------------------------------------------===//
 // Generic Linalg ops.
 //===----------------------------------------------------------------------===//
 
 def GenericOp : LinalgStructuredBase_Op<"generic", [
     AttrSizedOperandSegments,
     DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
     SingleBlockImplicitTerminator<"YieldOp">]> {

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

 /// Linalg generalization patterns
 
 /// Populates `patterns` with patterns to convert spec-generated named ops to
 /// linalg.generic ops.
 void populateLinalgNamedOpsGeneralizationPatterns(
     RewritePatternSet &patterns,
     LinalgTransformationFilter filter = LinalgTransformationFilter());
 
-/// Populates `patterns` with patterns to convert linalg.conv ops to
-/// linalg.generic ops.
-void populateLinalgConvGeneralizationPatterns(
-    RewritePatternSet &patterns,
-    LinalgTransformationFilter filter = LinalgTransformationFilter());
-
 /// Linalg distribution patterns
 //
 /// Populates `patterns` with patterns to distribute linalg.tiled_loop.
 void populateLinalgDistributeTiledLoopPattern(
     RewritePatternSet &patterns, const LinalgLoopDistributionOptions &opts,
     const LinalgTransformationFilter &marker);
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

if (linalgOp.getNumLoops() <= op.dim())
     return op.emitOpError("expected dim (")
            << op.dim() << ") to be lower than the number of loops ("
            << linalgOp.getNumLoops() << ") of the enclosing LinalgOp";
   return success();
 }
 
 /////// Operations corresponding to library calls defined with Tablegen ////////
 
-template <typename LinalgPoolingOp>
-static LogicalResult verifyStrideOrDilation(LinalgPoolingOp op,
-                                            ArrayRef<Attribute> attrs,
-                                            bool isStride) {
-  auto strideOrDilation = isStride ? "stride" : "dilation";
-  if (attrs.size() != op.getNumWindowLoops())
-    return op.emitOpError("expects num ")
-           << strideOrDilation
-           << "s equal to number of window dimensions: " << attrs.size()
-           << " vs " << op.getNumWindowLoops();
-  return success();
-}
-
-void ConvOp::getEffects(
-    SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
-        &effects) {
-  effects.emplace_back(MemoryEffects::Read::get(), input(),
-                       SideEffects::DefaultResource::get());
-  effects.emplace_back(MemoryEffects::Read::get(), filter(),
-                       SideEffects::DefaultResource::get());
-  effects.emplace_back(MemoryEffects::Write::get(), output(),
-                       SideEffects::DefaultResource::get());
-}
-
-static LogicalResult verify(ConvOp op) {
-  auto oType = op.output().getType().cast<MemRefType>();
-  auto fType = op.filter().getType().cast<MemRefType>();
-  auto iType = op.input().getType().cast<MemRefType>();
-  if (oType.getElementType() != iType.getElementType() ||
-      oType.getElementType() != fType.getElementType())
-    return op.emitOpError("expects memref elemental types to match");
-  if (oType.getRank() != iType.getRank() || oType.getRank() != fType.getRank())
-    return op.emitOpError("expects memref ranks to match");
-  if (auto strides = op.strides()) {
-    if (failed(verifyStrideOrDilation(op, strides->getValue(),
-                                      /*isStride=*/true)))
-      return failure();
-  }
-  if (auto dilations = op.dilations()) {
-    if (failed(verifyStrideOrDilation(op, dilations->getValue(),
-                                      /*isStride=*/false)))
-      return failure();
-  }
-  return success();
-}
-
 #include "mlir/Dialect/Linalg/IR/LinalgNamedStructuredOps.yamlgen.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/IR/LinalgOps.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
 
mlir::linalg::makeAffineDimExprs(unsigned num, unsigned &startIdx,
                                  MLIRContext *context) {
   SmallVector<AffineExpr, 4> res;
   res.reserve(num);
   for (unsigned i = 0; i < num; ++i)
     res.push_back(getAffineDimExpr(startIdx++, context));
   return res;
 }
 
-template <typename PoolingOp>
-SmallVector<AffineExpr, 4>
-mlir::linalg::weightedPoolingInputIndex(PoolingOp op,
-                                        ArrayRef<AffineExpr> outputDims,
-                                        ArrayRef<AffineExpr> windowDims) {
-  assert(outputDims.size() == windowDims.size());
-  SmallVector<AffineExpr, 4> res;
-  res.reserve(outputDims.size());
-  for (unsigned i = 0, e = outputDims.size(); i < e; ++i) {
-    // TODO: add a level of indirection to linalg.generic.
-    auto expr = op.getStride(i) * outputDims[i] +
-                op.getDilation(i) * windowDims[i] - op.getLowPad(i);
-    res.push_back(expr);
-  }
-  return res;
-}
-
-#define INSTANTIATE_WEIGHTED_POOLING_INPUT_INDEX(OP_TYPE)                      \
-  template SmallVector<AffineExpr, 4>                                          \
-  mlir::linalg::weightedPoolingInputIndex<OP_TYPE>(                            \
-      OP_TYPE op, ArrayRef<AffineExpr> outputDims,                             \
-      ArrayRef<AffineExpr> windowDims);
-
-INSTANTIATE_WEIGHTED_POOLING_INPUT_INDEX(ConvOp)
-
 SmallVector<AffineExpr, 4> mlir::linalg::concat(ArrayRef<AffineExpr> a,
                                                 ArrayRef<AffineExpr> b) {
   auto rangeA = llvm::make_range(a.begin(), a.end());
   auto rangeB = llvm::make_range(b.begin(), b.end());
   auto concatRanges = llvm::concat<const AffineExpr>(rangeA, rangeB);
   return llvm::to_vector<4>(concatRanges);
 }
 

 } // namespace
 
 #define LINALGOP_FOLDERS(XXX)                                                  \
   LogicalResult XXX::fold(ArrayRef<Attribute>,                                 \
                           SmallVectorImpl<OpFoldResult> &) {                   \
     return foldMemRefCast(*this);                                              \
   }
 
-LINALGOP_FOLDERS(ConvOp)
 LINALGOP_FOLDERS(CopyOp)
 LINALGOP_FOLDERS(FillOp)
 LINALGOP_FOLDERS(GenericOp)
 
 // All named ops canonicalizers and folders are auto-generated in the
 // .cpp.inc.
 
 //===----------------------------------------------------------------------===//
 // LinalgDialect
 //===----------------------------------------------------------------------===//
 
 void LinalgDialect::getCanonicalizationPatterns(
     RewritePatternSet &results) const {
   results.add<EraseDeadLinalgOp, FoldTensorCastOp, SimplifyDepthwiseConvOp,
               SimplifyDepthwiseConvQOp>(getContext());
 }

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

bool mlir::linalg::isFusableInto(const LinalgDependenceGraph &graph,
   // Check for any fusion-preventing dependence to any shape read/written that
   // would violate dependences.
   if (!graph.findCoveringDependences(producer, consumer).empty()) {
     LLVM_DEBUG(llvm::dbgs()
                << "\n***Not fusable due to an interleaved dependence:\t"
                << *producer.getOperation());
     return false;
   }
-  if (auto convOp = dyn_cast<linalg::ConvOp>(producer.getOperation())) {
-    // TODO: add a level of indirection to linalg.generic.
-    if (convOp.padding())
-      return false;
-  }
-  if (auto convOp = dyn_cast<linalg::ConvOp>(consumer.getOperation())) {
-    // TODO: add a level of indirection to linalg.generic.
-    if (convOp.padding())
-      return false;
-  }
   return true;
 }
 
 /// For `consumer` with buffer semantics, find the Linalg operation on buffers
 /// that is the last writer of `consumerOpOperand`. For now the fusable
 /// dependence is returned as an instance of the `dependenceGraph`.
 static Optional<LinalgDependenceGraph::LinalgDependenceGraphElem>
 findFusableProducer(OpOperand &consumerOpOperand,

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

return rewriter.create<GenericOp>(
       [&regionBuilder](OpBuilder &bodyBuilder, Location loc, ValueRange) {
         ImplicitLocOpBuilder b(loc, bodyBuilder);
         regionBuilder(b, *bodyBuilder.getBlock());
       });
 }
 
 namespace {
 
-/// Base class for all linalg generalization patterns. A subclass must provide
-/// the following method:
-///   GenericOp createGenericOp(RootOp, PatternRewriter &)
-/// for creating the generic op.
-// TODO: remove this pattern after migrating all manually-written named ops
-// into auto-generated ones.
-template <typename ConcretePattern, typename RootOp>
-struct LinalgGeneralizationPattern : OpRewritePattern<RootOp> {
-  LinalgGeneralizationPattern(MLIRContext *context,
-                              LinalgTransformationFilter marker,
-                              PatternBenefit benefit = 1)
-      : OpRewritePattern<RootOp>(context, benefit), marker(std::move(marker)) {}
-
-  LogicalResult matchAndRewrite(RootOp rootOp,
-                                PatternRewriter &rewriter) const override {
-    auto linalgOp = dyn_cast<LinalgOp>(rootOp.getOperation());
-    if (!linalgOp)
-      return failure();
-    if (failed(marker.checkAndNotify(rewriter, linalgOp)))
-      return failure();
-
-    auto *pattern = static_cast<const ConcretePattern *>(this);
-    GenericOp genericOp = pattern->createGenericOp(rootOp, rewriter);
-    if (!genericOp)
-      return failure();
-
-    rewriter.replaceOp(rootOp, genericOp.getResults());
-    marker.replaceLinalgTransformationFilter(rewriter,
-                                             genericOp.getOperation());
-    return success();
-  }
-
-private:
-  LinalgTransformationFilter marker;
-};
-
-struct GeneralizeConvOp
-    : public LinalgGeneralizationPattern<GeneralizeConvOp, ConvOp> {
-  using LinalgGeneralizationPattern::LinalgGeneralizationPattern;
-
-  GenericOp createGenericOp(ConvOp convOp, OpBuilder &builder) const;
-};
-
 struct LinalgGeneralizationPass
     : public LinalgGeneralizationBase<LinalgGeneralizationPass> {
   void runOnFunction() override;
 };
 
 } // namespace
 
 void LinalgGeneralizationPass::runOnFunction() {
   FuncOp func = getFunction();
   RewritePatternSet patterns(&getContext());
-  populateLinalgConvGeneralizationPatterns(patterns);
   populateLinalgNamedOpsGeneralizationPatterns(patterns);
   (void)applyPatternsAndFoldGreedily(func.getBody(), std::move(patterns));
 }
 
-GenericOp GeneralizeConvOp::createGenericOp(ConvOp convOp,
-                                            OpBuilder &builder) const {
-  SmallVector<AffineMap> indexingMaps = convOp.getIndexingMaps();
-  auto iterators =
-      llvm::to_vector<4>(convOp.iterator_types().getAsValueRange<StringAttr>());
-  SmallVector<Value> inputBuffers = convOp.getInputBufferOperands();
-  SmallVector<Value> outputBuffers = convOp.getOutputBufferOperands();
-  return builder.create<GenericOp>(
-      convOp.getLoc(), /*resultTensorTypes=*/ArrayRef<Type>(), inputBuffers,
-      outputBuffers, indexingMaps, iterators,
-      [](OpBuilder &bodyBuilder, Location bodyLoc, ValueRange bodyArgs) {
-        Value mul =
-            bodyBuilder.create<MulFOp>(bodyLoc, bodyArgs[0], bodyArgs[1]);
-        Value add = bodyBuilder.create<AddFOp>(bodyLoc, mul, bodyArgs[2]);
-        bodyBuilder.create<YieldOp>(bodyLoc, add);
-      });
-}
-
-void mlir::linalg::populateLinalgConvGeneralizationPatterns(
-    RewritePatternSet &patterns, LinalgTransformationFilter marker) {
-  patterns.add<GeneralizeConvOp>(patterns.getContext(), marker);
-}
-
 void mlir::linalg::populateLinalgNamedOpsGeneralizationPatterns(
     RewritePatternSet &patterns, 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/Loops.cpp

for (OpOperand *outputOperand : linalgOp.getOutputBufferOperands()) {
     indexing.push_back(makeCanonicalAffineApplies(
         b, loc, linalgOp.getTiedIndexingMap(outputOperand), allIvsPlusDims));
     outputBuffers.push_back(outputOperand->get());
   }
   inlineRegionAndEmitStore<LoadOpTy, StoreOpTy>(b, loc, linalgOp, indexedValues,
                                                 indexing, outputBuffers);
 }
 
-// Create a padded view into the given `input` tensor using the 'indices'
-// to access the tensor. `skipPadding` lists the dimensions for which no padding
-// is needed e.g. the non-spatial dimensions for convolutions.
-Value getPaddedInput(OpBuilder &b, Location loc, Value input,
-                     ArrayRef<Value> indices, ArrayRef<int> skipPadding,
-                     Value padValue) {
-  Value zeroIndex = b.create<ConstantIndexOp>(loc, 0);
-  SmallVector<Value> conds;
-  SmallVector<Value> clampedImIdx;
-  for (auto iter : llvm::enumerate(indices)) {
-    int idx = iter.index();
-    auto dim = iter.value();
-    if (is_contained(skipPadding, idx)) {
-      clampedImIdx.push_back(dim);
-      continue;
-    }
-
-    Value leftOutOfBound =
-        b.create<CmpIOp>(loc, CmpIPredicate::slt, dim, zeroIndex);
-    if (conds.empty())
-      conds.push_back(leftOutOfBound);
-    else
-      conds.push_back(b.create<OrOp>(loc, conds.back(), leftOutOfBound));
-    Value rightBound = createOrFoldDimOp(b, loc, input, idx);
-    Value rightOutOfBound =
-        b.create<CmpIOp>(loc, CmpIPredicate::sge, dim, rightBound);
-    conds.push_back(b.create<OrOp>(loc, conds.back(), rightOutOfBound));
-
-    // When padding is involved, the indices will only be shifted to negative,
-    // so having a max op is enough.
-    MLIRContext *ctx = input.getContext();
-    AffineExpr m = getAffineDimExpr(/*position=*/0, ctx),
-               zero = getAffineConstantExpr(0, ctx);
-    AffineMap maxMap =
-        AffineMap::inferFromExprList(ArrayRef<ArrayRef<AffineExpr>>{{m, zero}})
-            .front();
-    clampedImIdx.push_back(b.create<AffineMaxOp>(loc, maxMap, ValueRange{dim}));
-  }
-
-  Value readInput = b.create<memref::LoadOp>(loc, input, clampedImIdx);
-  if (conds.empty())
-    return readInput;
-
-  return b.create<SelectOp>(loc, conds.back(), padValue, readInput);
-}
-
-namespace {
-
-/// The padding value for a given Op depends on the semantics of the Op.
-/// The identity value for ConvOp is 0.
-template <typename OpType> Attribute getPadValueAttr(Type type) {
-  llvm_unreachable("Unexpected op type for getPadValueAttr");
-  return {};
-}
-
-template <> Attribute getPadValueAttr<ConvOp>(Type type) {
-  return OpBuilder(type.getContext()).getZeroAttr(type);
-}
-
-} // namespace
-
-/// Returns true is `convOp` has a non-zero padding.
-static bool hasPadding(ConvOp convOp) {
-  for (unsigned i = 0, e = convOp.getNumSpatialDimensions(); i < e; ++i) {
-    if (convOp.getLowPad(i) > 0 || convOp.getHighPad(i) > 0)
-      return true;
-  }
-  return false;
-}
-
-template <typename LoadOpTy, typename StoreOpTy>
-static void emitScalarImplementation(OpBuilder &b, Location loc,
-                                     ArrayRef<Value> allIvs, ConvOp convOp) {
-  assert(convOp.hasBufferSemantics() &&
-         "expected linalg op with buffer semantics");
-  auto mapsRange = convOp.indexing_maps().getAsRange<AffineMapAttr>();
-  auto maps = llvm::to_vector<8>(
-      llvm::map_range(mapsRange, [](AffineMapAttr a) { return a.getValue(); }));
-  SmallVector<Value> fIdx(makeCanonicalAffineApplies(b, loc, maps[0], allIvs));
-  SmallVector<Value> imIdx(makeCanonicalAffineApplies(b, loc, maps[1], allIvs));
-  SmallVector<Value> oIdx(makeCanonicalAffineApplies(b, loc, maps[2], allIvs));
-
-  Value filter = convOp.filter(), output = convOp.output();
-
-  // Emit scalar form. Padded conv involves an affine.max in the memory access
-  // which is not allowed by affine.load. Override to use an MemRefIndexedValue
-  // when there is non-zero padding.
-  if (hasPadding(convOp)) {
-    Type type = convOp.input().getType().cast<MemRefType>().getElementType();
-    Value padValue =
-        b.create<ConstantOp>(loc, type, getPadValueAttr<ConvOp>(type));
-    Value paddedInput =
-        getPaddedInput(b, loc, convOp.input(), imIdx,
-                       /* Only need to pad the window dimensions */
-                       {0, static_cast<int>(imIdx.size()) - 1}, padValue);
-    Value filterVal = b.create<LoadOpTy>(loc, filter, fIdx);
-    Value mulVal = ArithBuilder(b, loc).mul(filterVal, paddedInput);
-    Value outputVal = b.create<LoadOpTy>(loc, output, oIdx);
-    Value addVal = ArithBuilder(b, loc).add(mulVal, outputVal);
-    b.create<StoreOpTy>(loc, addVal, output, oIdx);
-  } else {
-    Value inputVal = b.create<LoadOpTy>(loc, convOp.input(), imIdx);
-    Value filterVal = b.create<LoadOpTy>(loc, filter, fIdx);
-    Value mulVal = ArithBuilder(b, loc).mul(filterVal, inputVal);
-    Value outputVal = b.create<LoadOpTy>(loc, output, oIdx);
-    Value addVal = ArithBuilder(b, loc).add(mulVal, outputVal);
-    b.create<StoreOpTy>(loc, addVal, output, oIdx);
-  }
-}
-
 /// Replace the index operations in the body of the loop nest by the matching
 /// induction variables.
 static void replaceIndexOpsByInductionVariables(LinalgOp linalgOp,
                                                 PatternRewriter &rewriter,
                                                 ArrayRef<Operation *> loopOps) {
   // Extract the induction variables of the loop nest from outer to inner.
   SmallVector<Value> allIvs;
   for (Operation *loopOp : loopOps) {
static Optional<LinalgLoops> linalgOpToLoopsImpl(PatternRewriter &rewriter,
   SmallVector<Value> allIvs;
   GenerateLoopNest<LoopTy>::doit(
       rewriter, linalgOp.getLoc(), loopRanges, linalgOp, iteratorTypes,
       [&](OpBuilder &b, Location loc, ValueRange ivs,
           ValueRange operandValuesToUse) -> scf::ValueVector {
         assert(operandValuesToUse == linalgOp->getOperands() &&
                "expect operands are captured and not passed by loop argument");
         allIvs.append(ivs.begin(), ivs.end());
-        llvm::TypeSwitch<Operation *>(linalgOp)
-            .Case<ConvOp, LinalgOp>([&](auto op) {
-              emitScalarImplementation<LoadOpTy, StoreOpTy>(b, loc, allIvs, op);
-            })
-            .Default([&](Operation *op) { assert(false && "unexpected op"); });
+        emitScalarImplementation<LoadOpTy, StoreOpTy>(b, loc, allIvs, linalgOp);
         return scf::ValueVector{};
       });
   // Number of loop ops might be different from the number of ivs since some
   // loops like affine.parallel and scf.parallel have multiple ivs.
   SetVector<Operation *> loopSet;
   for (Value iv : allIvs) {
     if (!iv)
       return {};

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

promoteSubViews(ImplicitLocOpBuilder &b,
   return promotionInfoMap;
 }
 
 static Optional<LinalgOp>
 promoteSubViews(ImplicitLocOpBuilder &b, LinalgOp op,
                 LinalgOpInstancePromotionOptions options, DataLayout &layout) {
   assert(op.hasBufferSemantics() && "expected linalg op with buffer semantics");
 
-  if (auto convOp = dyn_cast<linalg::ConvOp>(op.getOperation())) {
-    // TODO: add a level of indirection to linalg.generic.
-    if (convOp.padding())
-      return {};
-  }
-
   // 1. Promote the specified views and use them in the new op.
   auto promotedBuffersAndViews = promoteSubViews(b, options, layout);
   if (!promotedBuffersAndViews ||
       promotedBuffersAndViews->size() != options.subViews.size())
     return {};
 
   // 2. Append all other operands as they appear, this enforces that such
   // operands are not views. This is to support cases such as FillOp taking

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

tileLinalgOpImpl(OpBuilder &b, LinalgOp op, ValueRange tileSizes,
                  const LinalgTilingOptions &options) {
   auto nLoops = op.getNumLoops();
   // Initial tile sizes may be too big, only take the first nLoops.
   tileSizes = tileSizes.take_front(nLoops);
 
   if (llvm::all_of(tileSizes, isZero))
     return llvm::None;
 
-  if (auto convOp = dyn_cast<linalg::ConvOp>(op.getOperation())) {
-    // For conv op only support tiling along batch dimension (which is the first
-    // loop).
-    if (convOp.padding() && !llvm::all_of(tileSizes.drop_front(), isZero))
-      return llvm::None;
-  }
-
   // 1. Build the tiled loop ranges.
   auto allShapeSizes = op.createFlatListOfOperandDims(b, op.getLoc());
   AffineMap shapeSizesToLoopsMap = op.getShapesToLoopsMap();
   if (!shapeSizesToLoopsMap)
     return llvm::None;
 
   SmallVector<Range, 4> loopRanges;
   LoopIndexToRangeIndexMap loopIndexToRangeIndex;

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

auto result = rewriter.create<vector::ContractionOp>(
       rewriter.getStrArrayAttr(iteratorTypes));
 
   rewriter.create<memref::StoreOp>(loc, result, output->get(),
                                    ValueRange(zeros));
   rewriter.eraseOp(op);
   return success();
 }
 
-using ConvOpConst = ConvOpVectorization<Conv1DOp, 1>;
-
 /// Inserts tiling, promotion and vectorization pattern for ConvOp
 /// conversion into corresponding pattern lists.
 template <typename ConvOp, unsigned N>
 static void populateVectorizationPatterns(
     RewritePatternSet &tilingPatterns, RewritePatternSet &promotionPatterns,
     RewritePatternSet &vectorizationPatterns, ArrayRef<int64_t> tileSizes) {
   auto *context = tilingPatterns.getContext();
   if (tileSizes.size() < N)

mlir/test/Dialect/Linalg/affine.mlir

 // RUN: mlir-opt %s -convert-linalg-to-affine-loops | FileCheck %s
 
 // Test that we can lower all the way to LLVM without crashing, don't check results here.
 // RUN: mlir-opt %s -convert-linalg-to-affine-loops -convert-linalg-to-llvm -o=/dev/null 2>&1
 
-// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
-
-// CHECK-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)>
-
-// CHECK-DAG: #[[$clampMinMap:.*]] = affine_map<(d0) -> (d0, 0)>
-
 func @matmul(%arg0: memref<?xi8>, %M: index, %N: index, %K: index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %A = memref.view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
   %B = memref.view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
   %C = memref.view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
   linalg.matmul ins(%A, %B: memref<?x?xf32>, memref<?x?xf32>)
                outs(%C: memref<?x?xf32>)
   return
 }
 
-// CHECK-LABEL: func @matmul(%{{.*}}: memref<?xi8>,
-// CHECK-SAME: [[M:arg[0-9]+]]: index
-// CHECK-SAME: [[N:arg[0-9]+]]: index
-// CHECK-SAME: [[K:arg[0-9]+]]: index
-//       CHECK: %[[A:.*]] = memref.view %{{.*}} : memref<?xi8> to memref<?x?xf32>
-//       CHECK: %[[B:.*]] = memref.view %{{.*}} : memref<?xi8> to memref<?x?xf32>
-//       CHECK: %[[C:.*]] = memref.view %{{.*}} : memref<?xi8> to memref<?x?xf32>
-//       CHECK: affine.for
-//       CHECK:   affine.for
-//       CHECK:     affine.for
-//   CHECK-DAG:       %[[a:.*]] = affine.load %[[A]]{{.*}} : memref<?x?xf32>
-//   CHECK-DAG:       %[[b:.*]] = affine.load %[[B]]{{.*}} : memref<?x?xf32>
-//   CHECK-DAG:       %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
-//   CHECK-DAG:       %[[c:.*]] = affine.load %[[C]]{{.*}} : memref<?x?xf32>
-//   CHECK-DAG:       %[[res:.*]] = addf %[[c]], %[[inc]] : f32
-//       CHECK:       affine.store %[[res]], %[[C]]{{.*}} : memref<?x?xf32>
-
-func @conv_view3(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg2: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
-  linalg.conv(%arg0, %arg1, %arg2) {strides = [2]}: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
-  return
-}
-
-// CHECK-LABEL: func @conv_view3(
-//  CHECK: %{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>) {
-//       CHECK:   %[[Z0:.*]] = memref.dim %arg0, %c0 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:   %[[Q:.*]] = memref.dim %arg0, %c1 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:   %[[K:.*]] = memref.dim %arg0, %c2 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:   %[[B:.*]] = memref.dim %arg1, %c0 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:   %[[X0:.*]] = memref.dim %arg2, %c1 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:   affine.for {{.*}}0 to %[[B]] {
-//       CHECK:     affine.for {{.*}}0 to %[[X0]] {
-//       CHECK:       affine.for {{.*}}0 to %[[K]] {
-//       CHECK:         affine.for {{.*}}0 to %[[Q]] {
-//       CHECK:           affine.for {{.*}}0 to %[[Z0]] {
-//       CHECK:            %[[SUM:.*]] = affine.apply #[[$stride2Dilation1]]{{.*}}
-//       No padding needed here; only affine loads.
-//       CHECK-NEXT:       affine.load
-//       CHECK-NEXT:       affine.load
-
-func @conv_padding(%arg0: memref<?x?x?x?xf32>,
-                   %arg1: memref<?x?x?x?xf32>,
-                   %arg2: memref<?x?x?x?xf32>) {
-  linalg.conv(%arg0, %arg1, %arg2) {dilations = [1, 1],
-                                    padding = dense<[[0, 1], [1, 1]]> : tensor<2x2xi64>,
-                                    strides = [1, 1]} :
-    memref<?x?x?x?xf32>, memref<?x?x?x?xf32>, memref<?x?x?x?xf32>
-  return
-}
-// CHECK-LABEL: func @conv_padding
-//       CHECK: %{{.*}}: memref<?x?x?x?xf32>, %{{.*}}: memref<?x?x?x?xf32>, %{{.*}}: memref<?x?x?x?xf32>) {
-//       CHECK:   %[[ZERO:.*]] = constant 0.000000e+00 : f32
-//       CHECK:   %[[Z0:.*]] = memref.dim %arg0, %c0 : memref<?x?x?x?xf32>
-//       CHECK:   %[[Z1:.*]] = memref.dim %arg0, %c1 : memref<?x?x?x?xf32>
-//       CHECK:   %[[Q:.*]] =  memref.dim %arg0, %c2 : memref<?x?x?x?xf32>
-//       CHECK:   %[[K:.*]] =  memref.dim %arg0, %c3 : memref<?x?x?x?xf32>
-//       CHECK:   %[[B:.*]] =  memref.dim %arg1, %c0 : memref<?x?x?x?xf32>
-//       CHECK:   %[[X0:.*]] = memref.dim %arg2, %c1 : memref<?x?x?x?xf32>
-//       CHECK:   %[[X1:.*]] = memref.dim %arg2, %c2 : memref<?x?x?x?xf32>
-//       CHECK:   affine.for {{.*}}0 to %[[B]] {
-//       CHECK:     affine.for {{.*}}0 to %[[X0]] {
-//       CHECK:       affine.for {{.*}}0 to %[[X1]] {
-//       CHECK:         affine.for {{.*}}0 to %[[K]] {
-//       CHECK:           affine.for {{.*}}0 to %[[Q]] {
-//       CHECK:             affine.for {{.*}}0 to %[[Z0]] {
-//       CHECK:               affine.for {{.*}}0 to %[[Z1]] {
-//       CHECK:                 %[[SUM0:.*]] = affine.apply #{{.*}}
-//       CHECK:                 %[[SUM1:.*]] = affine.apply #{{.*}}
-//       CHECK:                 %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[SUM0]])
-//       CHECK:                 %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[SUM1]])
-// Padded conv involves an affine.max in the memory access and this is not
-// allowed by affine.load. Use memref.load in such cases.
-//       CHECK:                 memref.load %{{.*}}[%{{.*}}, %[[IDX]], %[[IDY]], %{{.*}}] : memref<?x?x?x?xf32>
-//       CHECK:                 select {{.*}} : f32
-//       CHECK:                 affine.load
-//       CHECK:                 mulf {{.*}} : f32
-//       CHECK:                 affine.load
-//       CHECK:                 addf {{.*}} : f32
-//       CHECK:                 affine.store
-
 //----------------------------------------------------------------------------//
 // Named ops to loops.
 //----------------------------------------------------------------------------//
 func @named_batch_matmul(%A: memref<?x?x?xf32>, %B: memref<?x?x?xf32>, %C: memref<?x?x?xf32>) {
   linalg.batch_matmul ins(%A, %B: memref<?x?x?xf32>, memref<?x?x?xf32>)
                      outs(%C : memref<?x?x?xf32>)
   return
 }

mlir/test/Dialect/Linalg/fusion-pattern.mlir

 //       CHECK:   scf.parallel
 //       CHECK:     scf.for
 //   CHECK-NOT:     linalg.fill
 //       CHECK:     linalg.matmul
 
 // -----
 
 module {
-  func @basic_conv_fusion(%arg0: memref<?x?x?x?xf32>, %arg1: memref<?x?x?x?xf32>,
-                          %arg2: memref<?x?x?x?xf32>) {
+  func @basic_conv_fusion(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>,
+                          %arg2: memref<?x?xf32>) {
     %cst = constant 0.000000e+00 : f32
-    linalg.fill(%cst, %arg2) : f32, memref<?x?x?x?xf32>
-    linalg.conv(%arg0, %arg1, %arg2) {
-      dilations = [1, 1], strides = [1, 1],
-      __internal_linalg_transform__ = "basic_fusion"} :
-      memref<?x?x?x?xf32>, memref<?x?x?x?xf32>, memref<?x?x?x?xf32>
+    linalg.fill(%cst, %arg2) : f32, memref<?x?xf32>
+    linalg.conv_2d {__internal_linalg_transform__ = "basic_fusion"}
+      ins(%arg1, %arg0 : memref<?x?xf32>, memref<?x?xf32>) outs(%arg2 : memref<?x?xf32>)
     return
   }
 }
 //      CHECK: func @basic_conv_fusion
 //      CHECK:   linalg.fill
 // CHECK-SAME:     __internal_linalg_transform__ = "after_basic_fusion_original"
 //      CHECK:  scf.parallel (%{{.+}}, %{{.+}}, %{{.+}})
 // CHECK-SAME:  {
 //      CHECK:    linalg.fill
 // CHECK-SAME:      __internal_linalg_transform__ = "after_basic_fusion_producer"
-//      CHECK:    linalg.conv
+//      CHECK:    linalg.conv_2d
 // CHECK-SAME:      __internal_linalg_transform__ = "after_basic_fusion"
 //      CHECK:  }
-//      CHECK:  linalg.conv
+//      CHECK:  linalg.conv_2d
 // CHECK-SAME:    __internal_linalg_transform__ = "after_basic_fusion_original"

mlir/test/Dialect/Linalg/fusion.mlir

 // CHECK:         subf
 // CHECK:         linalg.yield
 // CHECK:       linalg.generic
 // CHECK:         exp
 // CHECK:         linalg.yield
 
 // -----
 
-#map0 = affine_map<(d0, d1, d2) -> (d0, d1 - d2)>
-#map1 = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3, s4] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4)>
-#map2 = affine_map<()[s0] -> (s0 + 3)>
 
-func @fill_and_conv(%arg0: memref<?x?x?x?xf32>, %arg1: memref<2x3x1x1xf32>, %arg2: memref<?x?x?x?xf32>) {
-  %cst = constant 0.000000e+00 : f32
-  linalg.fill(%cst, %arg2) : f32, memref<?x?x?x?xf32>
+#map0 = affine_map<(d0)[s0] -> (2, -d0 + s0)>
+#map1 = affine_map<(d0)[s0] -> (3, -d0 + s0)>
+#map2 = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+#map3 = affine_map<(d0)[s0, s1] -> (s0 + 1, -d0 + s0 + s1)>
+#map4 = affine_map<(d0)[s0, s1] -> (s0 + 2, -d0 + s0 + s1)>
 
-  %c4 = constant 4 : index
-  %c1 = constant 1 : index
-  %c0 = constant 0 : index
+func @fill_and_conv(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
+  %cst = constant 0.000000e+00 : f32
   %c2 = constant 2 : index
   %c3 = constant 3 : index
-  %4 = memref.dim %arg1, %c0 : memref<2x3x1x1xf32>
-  %5 = memref.dim %arg1, %c1 : memref<2x3x1x1xf32>
-  %6 = memref.dim %arg0, %c0 : memref<?x?x?x?xf32>
-  %7 = memref.dim %arg0, %c1 : memref<?x?x?x?xf32>
-  %8 = memref.dim %arg0, %c3 : memref<?x?x?x?xf32>
-  %9 = memref.dim %arg2, %c0 : memref<?x?x?x?xf32>
-  %10 = memref.dim %arg2, %c1 : memref<?x?x?x?xf32>
-  %11 = memref.dim %arg2, %c2 : memref<?x?x?x?xf32>
-  %12 = memref.dim %arg2, %c3 : memref<?x?x?x?xf32>
-  %13 = linalg.range %c0 : %6 : %c2 : !linalg.range
-  %14 = linalg.range %c0 : %10 : %c3 : !linalg.range
-  scf.for %arg3 = %c0 to %6 step %c2 {
-    scf.for %arg4 = %c0 to %10 step %c3 {
-      %15 = affine.min #map0(%c2, %c1, %arg3)
-      %16 = affine.apply #map2()[%7]
-      %17 = affine.min #map0(%16, %c4, %arg4)
-      %18 = memref.dim %arg0, %c2 : memref<?x?x?x?xf32>
-      %19 = memref.dim %arg0, %c3 : memref<?x?x?x?xf32>
-      %20 = memref.subview %arg0[%arg3, %arg4, %c0, %c0] [%15, %17, %18, %19] [%c1, %c1, %c1, %c1] : memref<?x?x?x?xf32> to memref<?x?x?x?xf32, #map1>
-      %21 = affine.min #map0(%c2, %c1, %arg3)
-      %22 = affine.min #map0(%c3, %c4, %arg4)
-      %23 = memref.dim %arg2, %c2 : memref<?x?x?x?xf32>
-      %24 = memref.dim %arg2, %c3 : memref<?x?x?x?xf32>
-      %25 = memref.subview %arg2[%arg3, %arg4, %c0, %c0] [%21, %22, %23, %24] [%c1, %c1, %c1, %c1] : memref<?x?x?x?xf32> to memref<?x?x?x?xf32, #map1>
-      linalg.conv(%arg1, %20, %25) {dilations = [1, 1], strides = [1, 1]} : memref<2x3x1x1xf32>, memref<?x?x?x?xf32, #map1>, memref<?x?x?x?xf32, #map1>
+  %c0 = constant 0 : index
+  %c1 = constant 1 : index
+  linalg.fill(%cst, %arg0) : f32, memref<?x?xf32>
+  %2 = memref.dim %arg1, %c0 : memref<?x?xf32>
+  %3 = memref.dim %arg1, %c1 : memref<?x?xf32>
+  %4 = memref.dim %arg2, %c0 : memref<?x?xf32>
+  %5 = memref.dim %arg2, %c1 : memref<?x?xf32>
+  scf.for %arg3 = %c0 to %4 step %c2 {
+    scf.for %arg4 = %c0 to %5 step %c3 {
+      %6 = affine.min #map3(%arg3)[%2, %4]
+      %7 = affine.min #map4(%arg4)[%3, %5]
+      %8 = memref.subview %arg0[%arg3, %arg4] [%6, %7] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #map2>
+      %9 = affine.min #map0(%arg3)[%4]
+      %10 = affine.min #map1(%arg4)[%5]
+      %11 = memref.subview %arg2[%arg3, %arg4] [%9, %10] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #map2>
+      linalg.conv_2d ins(%8, %arg1 : memref<?x?xf32, #map2>, memref<?x?xf32>) outs(%11 : memref<?x?xf32, #map2>)
     }
   }
   return
 }
 // CHECK-LABEL: func @fill_and_conv
 // CHECK: scf.for
 // CHECK:   scf.for
 // CHECK:     linalg.fill
-// CHECK:     linalg.conv
+// CHECK:     linalg.conv_2d
 
 // -----
 
 // Test that different allocation-like ops are recognized and properly handled.
 func @accept_different_alloc_ops(%dim: index, %s0 : index, %s1: index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index

mlir/test/Dialect/Linalg/generalize-named-ops.mlir

 // RUN: mlir-opt %s -split-input-file -linalg-generalize-named-ops | FileCheck %s
 
-func @generalize_conv(%input : memref<1x449x562x3xf32>, %filter: memref<3x3x3x32xf32>, %output: memref<1x112x112x32xf32>) {
-  linalg.conv(%filter, %input, %output) {dilations = [2, 3], strides = [4, 5]} : memref<3x3x3x32xf32>, memref<1x449x562x3xf32>, memref<1x112x112x32xf32>
-  return
-}
-
-// CHECK: #[[FILTER_MAP:.+]] = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5, d6, d4, d3)>
-// CHECK:  #[[INPUT_MAP:.+]] = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1 * 4 + d5 * 2, d2 * 5 + d6 * 3, d4)>
-// CHECK: #[[OUTPUT_MAP:.+]] = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)>
-
-// CHECK: func @generalize_conv
-// CHECK-SAME:  %[[INPUT:.+]]: memref<1x449x562x3xf32>
-// CHECK-SAME: %[[FILTER:.+]]: memref<3x3x3x32xf32>
-// CHECK-SAME: %[[OUTPUT:.+]]: memref<1x112x112x32xf32>
-
-// CHECK: linalg.generic
-// CHECK-SAME: indexing_maps = [#[[FILTER_MAP]], #[[INPUT_MAP]], #[[OUTPUT_MAP]]]
-// CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "window", "window"]
-// CHECK-SAME:  ins(%[[FILTER]], %[[INPUT]]
-// CHECK-SAME: outs(%[[OUTPUT]]
-
-// CHECK: ^{{.*}}(%[[FILTER_ARG:.+]]: f32, %[[INPUT_ARG:.+]]: f32, %[[OUTPUT_ARG:.+]]: f32)
-// CHECK:   %[[MUL:.+]] = mulf %[[FILTER_ARG]], %[[INPUT_ARG]]
-// CHECK:   %[[ADD:.+]] = addf %[[MUL]], %[[OUTPUT_ARG]]
-// CHECK:   linalg.yield %[[ADD]]
-
-// -----
-
 func @generalize_matmul_buffer(%A : memref<16x8xf32>, %B: memref<8x32xf32>, %C: memref<16x32xf32>) {
   linalg.matmul ins(%A, %B: memref<16x8xf32>, memref<8x32xf32>)
                outs(%C: memref<16x32xf32>)
   return
 }
 
 
 // CHECK: #[[A_MAP:.+]] = affine_map<(d0, d1, d2) -> (d0, d2)>

mlir/test/Dialect/Linalg/loops.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops | FileCheck %s
 // RUN: mlir-opt %s -convert-linalg-to-parallel-loops | FileCheck --check-prefix=CHECKPARALLEL %s
 
 // Test that we can lower all the way to LLVM without crashing, don't check results here.
 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-linalg-to-llvm -o=/dev/null 2>&1
 
 // CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
 // CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
 // CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
-// CHECK-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
-// CHECK-DAG: #[[$clampMinMap:.*]] = affine_map<(d0) -> (d0, 0)>
-
 // CHECK-DAG: #[[$stride1Dilation1:.*]] = affine_map<(d0, d1) -> (d0  + d1)>
-// CHECK-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)>
-// CHECK-DAG: #[[$stride2Dilation4:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1 * 4)>
-// CHECK-DAG: #[[$stride3Dilation5:.*]] = affine_map<(d0, d1) -> (d0 * 3 + d1 * 5)>
 
 // CHECKPARALLEL-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
 // CHECKPARALLEL-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
 // CHECKPARALLEL-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
-// CHECKPARALLEL-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
-// CHECKPARALLEL-DAG: #[[$clampMinMap:.*]] = affine_map<(d0) -> (d0, 0)>
-
 // CHECKPARALLEL-DAG: #[[$stride1Dilation1:.*]] = affine_map<(d0, d1) -> (d0  + d1)>
-// CHECKPARALLEL-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)>
-// CHECKPARALLEL-DAG: #[[$stride2Dilation4:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1 * 4)>
-// CHECKPARALLEL-DAG: #[[$stride3Dilation5:.*]] = affine_map<(d0, d1) -> (d0 * 3 + d1 * 5)>
 
 func @matmul(%arg0: memref<?xi8>, %M: index, %N: index, %K: index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %A = memref.view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
   %B = memref.view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
   %C = memref.view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
   linalg.matmul ins(%A, %B: memref<?x?xf32>, memref<?x?xf32>)

 //       CHECK:         store %[[L]], {{.*}} : memref<?x?x?xf32, #[[$strided3D]]>
 
 // CHECKPARALLEL-LABEL: func @copy_view3
 //       CHECKPARALLEL: (%{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>) {
 //       CHECKPARALLEL:   scf.parallel (%{{.*}}, %{{.*}}, %{{.*}}) = (%{{.*}}, %{{.*}}, %{{.*}}) to (%{{.*}}, %{{.*}}, %{{.*}}) step (%{{.*}}, %{{.*}}, %{{.*}}) {
 //       CHECKPARALLEL:     %[[L:.*]] = memref.load {{.*}} : memref<?x?x?xf32, #[[$strided3D]]>
 //       CHECKPARALLEL:     store %[[L]], {{.*}} : memref<?x?x?xf32, #[[$strided3D]]>
 
-func @conv_view3(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg2: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
-  linalg.conv(%arg0, %arg1, %arg2) {strides = [2]}: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
-  return
-}
-// CHECK-LABEL: func @conv_view3(
-//       CHECK: %{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>) {
-//       CHECK:   %[[Z0:.*]] = memref.dim %arg0, %c0 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:   %[[Q:.*]] = memref.dim %arg0, %c1 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:   %[[K:.*]] = memref.dim %arg0, %c2 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:   %[[B:.*]] = memref.dim %arg1, %c0 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:   %[[X0:.*]] = memref.dim %arg2, %c1 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:   scf.for {{.*}} to %[[B]]
-//       CHECK:     scf.for {{.*}} to %[[X0]]
-//       CHECK:       scf.for {{.*}} to %[[K]]
-//       CHECK:         scf.for {{.*}} to %[[Q]]
-//       CHECK:           scf.for {{.*}} to %[[Z0]]
-//       CHECK:             %[[SUM:.*]] = affine.apply #[[$stride2Dilation1]]
-//       CHECK:             memref.load %{{.*}}[%{{.*}}, %[[SUM]], %{{.*}}] : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:             memref.load {{.*}} : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:             mulf
-//       CHECK:             memref.load {{.*}} : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECK:             addf
-//       CHECK:             store %{{.*}}, {{.*}} : memref<?x?x?xf32, #[[$strided3D]]>
-
-// CHECKPARALLEL-LABEL: func @conv_view3(
-//       CHECKPARALLEL: %{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[$strided3D]]>) {
-//       CHECKPARALLEL:   %[[Z0:.*]] = memref.dim %arg0, %c0 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECKPARALLEL:   %[[Q:.*]] = memref.dim %arg0, %c1 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECKPARALLEL:   %[[K:.*]] = memref.dim %arg0, %c2 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECKPARALLEL:   %[[B:.*]] = memref.dim %arg1, %c0 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECKPARALLEL:   %[[X0:.*]] = memref.dim %arg2, %c1 : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECKPARALLEL:   scf.parallel (%{{.*}}, %{{.*}}, %{{.*}}) = (%{{.*}}, %{{.*}}, %{{.*}}) to (%[[B]], %[[X0]], %[[K]]) step (%{{.*}}, %{{.*}}, %{{.*}}) {
-//       CHECKPARALLEL:     scf.for {{.*}} to %[[Q]]
-//       CHECKPARALLEL:       scf.for {{.*}} to %[[Z0]]
-//       CHECKPARALLEL:         %[[SUM:.*]] = affine.apply #[[$stride2Dilation1]]
-//       CHECKPARALLEL:         memref.load %{{.*}}[%{{.*}}, %[[SUM]], %{{.*}}] : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECKPARALLEL:         memref.load {{.*}} : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECKPARALLEL:         mulf
-//       CHECKPARALLEL:         memref.load {{.*}} : memref<?x?x?xf32, #[[$strided3D]]>
-//       CHECKPARALLEL:         addf
-//       CHECKPARALLEL:         store %{{.*}}, {{.*}} : memref<?x?x?xf32, #[[$strided3D]]>
-
-func @conv_view4(%arg0: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, %arg1: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, %arg2: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>) {
-  linalg.conv(%arg0, %arg1, %arg2) {dilations = [4, 5], strides = [2, 3]} : memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>
-  return
-}
-// CHECK-LABEL: func @conv_view4(
-//       CHECK: %{{.*}}: memref<?x?x?x?xf32, #[[$strided4D]]>, %{{.*}}: memref<?x?x?x?xf32, #[[$strided4D]]>, %{{.*}}: memref<?x?x?x?xf32, #[[$strided4D]]>) {
-//       CHECK:   %[[Z0:.*]] = memref.dim %arg0, %c0 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECK:   %[[Z1:.*]] = memref.dim %arg0, %c1 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECK:   %[[Q:.*]] = memref.dim %arg0, %c2 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECK:   %[[K:.*]] = memref.dim %arg0, %c3 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECK:   %[[B:.*]] = memref.dim %arg1, %c0 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECK:   %[[X0:.*]] = memref.dim %arg2, %c1 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECK:   %[[X1:.*]] = memref.dim %arg2, %c2 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECK:   scf.for {{.*}} to %[[B]]
-//       CHECK:     scf.for {{.*}} to %[[X0]]
-//       CHECK:       scf.for {{.*}} to %[[X1]]
-//       CHECK:         scf.for {{.*}} to %[[K]]
-//       CHECK:           scf.for {{.*}} to %[[Q]]
-//       CHECK:             scf.for {{.*}} to %[[Z0]]
-//       CHECK:               scf.for {{.*}} to %[[Z1]]
-//       CHECK:                 %[[SUM0:.*]] = affine.apply #[[$stride2Dilation4]]
-//       CHECK:                 %[[SUM1:.*]] = affine.apply #[[$stride3Dilation5]]
-//       CHECK:                 memref.load %{{.*}}[%{{.*}}, %[[SUM0]], %[[SUM1]], %{{.*}}] : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECK:                 memref.load {{.*}} : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECK:                 mulf
-//       CHECK:                 memref.load {{.*}} : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECK:                 addf
-//       CHECK:                 store %{{.*}}, {{.*}} : memref<?x?x?x?xf32, #[[$strided4D]]>
-
-// CHECKPARALLEL-LABEL: func @conv_view4(
-//       CHECKPARALLEL: %{{.*}}: memref<?x?x?x?xf32, #[[$strided4D]]>, %{{.*}}: memref<?x?x?x?xf32, #[[$strided4D]]>, %{{.*}}: memref<?x?x?x?xf32, #[[$strided4D]]>) {
-//       CHECKPARALLEL:   %[[Z0:.*]] = memref.dim %arg0, %c0 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECKPARALLEL:   %[[Z1:.*]] = memref.dim %arg0, %c1 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECKPARALLEL:   %[[Q:.*]] = memref.dim %arg0, %c2 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECKPARALLEL:   %[[K:.*]] = memref.dim %arg0, %c3 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECKPARALLEL:   %[[B:.*]] = memref.dim %arg1, %c0 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECKPARALLEL:   %[[X0:.*]] = memref.dim %arg2, %c1 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECKPARALLEL:   %[[X1:.*]] = memref.dim %arg2, %c2 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECKPARALLEL:   scf.parallel (%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) = (%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) to (%[[B]], %[[X0]], %[[X1]], %[[K]]) step (%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) {
-//       CHECKPARALLEL:     scf.for {{.*}} to %[[Q]]
-//       CHECKPARALLEL:       scf.for {{.*}} to %[[Z0]]
-//       CHECKPARALLEL:         scf.for {{.*}} to %[[Z1]]
-//       CHECKPARALLEL:           %[[SUM0:.*]] = affine.apply #[[$stride2Dilation4]]
-//       CHECKPARALLEL:           %[[SUM1:.*]] = affine.apply #[[$stride3Dilation5]]
-//       CHECKPARALLEL:           memref.load %{{.*}}[%{{.*}}, %[[SUM0]], %[[SUM1]], %{{.*}}] : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECKPARALLEL:           memref.load {{.*}} : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECKPARALLEL:           mulf
-//       CHECKPARALLEL:           memref.load {{.*}} : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       CHECKPARALLEL:           addf
-//       CHECKPARALLEL:           store %{{.*}}, {{.*}} : memref<?x?x?x?xf32, #[[$strided4D]]>
-
-func @conv_padding(%arg0: memref<?x?x?x?xf32>,
-                   %arg1: memref<?x?x?x?xf32>,
-                   %arg2: memref<?x?x?x?xf32>) {
-  linalg.conv(%arg0, %arg1, %arg2) {dilations = [1, 1],
-                                    padding = dense<[[0, 1], [1, 1]]> : tensor<2x2xi64>,
-                                    strides = [1, 1]} :
-    memref<?x?x?x?xf32>, memref<?x?x?x?xf32>, memref<?x?x?x?xf32>
-  return
-}
-// CHECK-LABEL: func @conv_padding
-//       CHECK: %{{.*}}: memref<?x?x?x?xf32>, %{{.*}}: memref<?x?x?x?xf32>, %{{.*}}: memref<?x?x?x?xf32>) {
-//       CHECK:   %[[ZERO:.*]] = constant 0.000000e+00 : f32
-//       CHECK:   %[[Z0:.*]] = memref.dim %arg0, %c0 : memref<?x?x?x?xf32>
-//       CHECK:   %[[Z1:.*]] = memref.dim %arg0, %c1 : memref<?x?x?x?xf32>
-//       CHECK:   %[[Q:.*]] =  memref.dim %arg0, %c2 : memref<?x?x?x?xf32>
-//       CHECK:   %[[K:.*]] =  memref.dim %arg0, %c3 : memref<?x?x?x?xf32>
-//       CHECK:   %[[B:.*]] =  memref.dim %arg1, %c0 : memref<?x?x?x?xf32>
-//       CHECK:   %[[X0:.*]] = memref.dim %arg2, %c1 : memref<?x?x?x?xf32>
-//       CHECK:   %[[X1:.*]] = memref.dim %arg2, %c2 : memref<?x?x?x?xf32>
-//       CHECK:   scf.for {{.*}} to %[[B]]
-//       CHECK:     scf.for {{.*}} to %[[X0]]
-//       CHECK:       scf.for {{.*}} to %[[X1]]
-//       CHECK:         scf.for {{.*}} to %[[K]]
-//       CHECK:           scf.for {{.*}} to %[[Q]]
-//       CHECK:             scf.for {{.*}} to %[[Z0]]
-//       CHECK:               scf.for {{.*}} to %[[Z1]]
-//       CHECK:                 %[[SUM0:.*]] = affine.apply #{{.*}}
-//       CHECK:                 %[[SUM1:.*]] = affine.apply #{{.*}}
-//       CHECK:                 %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[SUM0]])
-//       CHECK:                 %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[SUM1]])
-//       CHECK:                 memref.load %{{.*}}[%{{.*}}, %[[IDX]], %[[IDY]], %{{.*}}] : memref<?x?x?x?xf32>
-//       CHECK:                 select %{{.*}},
-//       CHECK:                 memref.load {{.*}} : memref<?x?x?x?xf32>
-//       CHECK:                 mulf
-//       CHECK:                 memref.load {{.*}} : memref<?x?x?x?xf32>
-//       CHECK:                 addf
-//       CHECK:                 store %{{.*}}, {{.*}} : memref<?x?x?x?xf32>
-
-// CHECKPARALLEL-LABEL: func @conv_padding
-//       CHECKPARALLEL: %{{.*}}: memref<?x?x?x?xf32>, %{{.*}}: memref<?x?x?x?xf32>, %{{.*}}: memref<?x?x?x?xf32>) {
-//       CHECKPARALLEL:   %[[ZERO:.*]] = constant 0.000000e+00 : f32
-//       CHECKPARALLEL:   %[[Z0:.*]] = memref.dim %arg0, %c0 : memref<?x?x?x?xf32>
-//       CHECKPARALLEL:   %[[Z1:.*]] = memref.dim %arg0, %c1 : memref<?x?x?x?xf32>
-//       CHECKPARALLEL:   %[[Q:.*]] =  memref.dim %arg0, %c2 : memref<?x?x?x?xf32>
-//       CHECKPARALLEL:   %[[K:.*]] =  memref.dim %arg0, %c3 : memref<?x?x?x?xf32>
-//       CHECKPARALLEL:   %[[B:.*]] =  memref.dim %arg1, %c0 : memref<?x?x?x?xf32>
-//       CHECKPARALLEL:   %[[X0:.*]] = memref.dim %arg2, %c1 : memref<?x?x?x?xf32>
-//       CHECKPARALLEL:   %[[X1:.*]] = memref.dim %arg2, %c2 : memref<?x?x?x?xf32>
-//       CHECKPARALLEL:   scf.parallel (%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) = (%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) to (%[[B]], %[[X0]], %[[X1]], %[[K]]) step (%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) {
-//       CHECKPARALLEL:     scf.for {{.*}} to %[[Q]]
-//       CHECKPARALLEL:       scf.for {{.*}} to %[[Z0]]
-//       CHECKPARALLEL:         scf.for {{.*}} to %[[Z1]]
-//       CHECKPARALLEL:           %[[SUM0:.*]] = affine.apply #{{.*}}
-//       CHECKPARALLEL:           %[[SUM1:.*]] = affine.apply #{{.*}}
-//       CHECKPARALLEL:           %[[IDX:.*]] = affine.max #[[$clampMinMap]](%[[SUM0]])
-//       CHECKPARALLEL:           %[[IDY:.*]] = affine.max #[[$clampMinMap]](%[[SUM1]])
-//       CHECKPARALLEL:           memref.load %{{.*}}[%{{.*}}, %[[IDX]], %[[IDY]], %{{.*}}] : memref<?x?x?x?xf32>
-//       CHECKPARALLEL:           select %{{.*}},
-//       CHECKPARALLEL:           memref.load {{.*}} : memref<?x?x?x?xf32>
-//       CHECKPARALLEL:           mulf
-//       CHECKPARALLEL:           memref.load {{.*}} : memref<?x?x?x?xf32>
-//       CHECKPARALLEL:           addf
-//       CHECKPARALLEL:           store %{{.*}}, {{.*}} : memref<?x?x?x?xf32>
-
 #accesses = [
   affine_map<(i, j, k) -> (i, j)>,
   affine_map<(i, j, k) -> (i, j, k)>,
   affine_map<(i, j, k) -> (i, k, j)>
 ]
 #trait2 = {
   args_in = 1,
   args_out = 2,

mlir/test/Dialect/Linalg/roundtrip.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 // RUN: mlir-opt %s --mlir-print-op-generic | mlir-opt | FileCheck %s
 
 // TODO: Re-enable LLVM lowering test.
 //
 // Test that we can lower all the way to LLVM without crashing, don't check results here.
 // DISABLED: mlir-opt %s --convert-linalg-to-llvm -o=/dev/null 2>&1
 
 // CHECK-DAG: #[[$id_2d:.*]] = affine_map<(d0, d1, d2) -> (d0, d2)>
 // CHECK-DAG: #[[$id_1d:.*]] = affine_map<(d0, d1, d2) -> (d1)>
 // CHECK-DAG: #[[$permute_0:.*]] = affine_map<(d0, d1, d2) -> (d0, d2, d1)>
 // CHECK-DAG: #[[$permute_1:.*]] = affine_map<(d0, d1, d2) -> (d2, d1, d0)>
 // CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
 // CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
 // CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
 // CHECK-DAG: #[[$strided3DT:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d1 * s2 + d0)>
-// CHECK-DAG: #[[$strided6D:.*]] = affine_map<(d0, d1, d2, d3, d4, d5)[s0, s1, s2, s3, s4, s5] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4 + d4 * s5 + d5)>
 
 func @pad_dynamic(%arg0: tensor<1x2x2x?xf32>, %low: index, %high: index,
                   %pad_value: f32) -> tensor<6x?x?x?xf32> {
   %0 = linalg.pad_tensor %arg0 low[2, %low, 3, 3] high[3, 3, %high, 2] {
     ^bb0(%arg1: index, %arg2: index, %arg3: index, %arg4: index):
       linalg.yield %pad_value : f32
     } : tensor<1x2x2x?xf32> to tensor<6x?x?x?xf32>
   return %0 : tensor<6x?x?x?xf32>

 //       CHECK:   linalg.copy(%{{.*}}, %{{.*}}) {
 //  CHECK-SAME:     inputPermutation = #[[$permute_0]],
 //  CHECK-SAME:     outputPermutation = #[[$permute_1]]} :
 //  CHECK-SAME:     memref<?x?x?xf32, #[[$strided3D]]>,
 //  CHECK-SAME:     memref<?x?x?xf32, #[[$strided3D]]>
 
 // -----
 
-
-func @conv_view3(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>,
-                 %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>,
-                 %arg2: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
-  linalg.conv(%arg0, %arg1, %arg2) : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>,
-                                     memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>,
-                                     memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
-  return
-}
-// CHECK-LABEL: func @conv_view3(
-//       CHECK:   linalg.conv(%{{.*}}, %{{.*}}, %{{.*}}) :
-//  CHECK-SAME:     memref<?x?x?xf32, #[[$strided3D]]>,
-//  CHECK-SAME:     memref<?x?x?xf32, #[[$strided3D]]>,
-//  CHECK-SAME:     memref<?x?x?xf32, #[[$strided3D]]>
-
-// -----
-
-
-func @conv_view6(%arg0: memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>,
-                 %arg1: memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>,
-                 %arg2: memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>) {
-  linalg.conv(%arg0, %arg1, %arg2) {dilations = [4, 4, 5, 5], strides = [2, 2, 3, 3]} :
-    memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>,
-    memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>,
-    memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>
-  return
-}
-// CHECK-LABEL: func @conv_view6(
-//       CHECK:   linalg.conv(%{{.*}}, %{{.*}}, %{{.*}}) {
-//  CHECK-SAME:     dilations = [4, 4, 5, 5], strides = [2, 2, 3, 3]} :
-//  CHECK-SAME:     memref<?x?x?x?x?x?xf32, #[[$strided6D]]>,
-//  CHECK-SAME:     memref<?x?x?x?x?x?xf32, #[[$strided6D]]>,
-//  CHECK-SAME:     memref<?x?x?x?x?x?xf32, #[[$strided6D]]>
-
-// -----
-
-func @conv_padding(%arg0: memref<?x?x?x?xf32>,
-                   %arg1: memref<?x?x?x?xf32>,
-                   %arg2: memref<?x?x?x?xf32>) {
-  linalg.conv(%arg0, %arg1, %arg2) {dilations = [1, 1],
-                                    padding = dense<[[0, 1], [1, 1]]> : tensor<2x2xi64>,
-                                    strides = [1, 1]} :
-    memref<?x?x?x?xf32>, memref<?x?x?x?xf32>, memref<?x?x?x?xf32>
-  return
-}
-
-// CHECK-LABEL: func @conv_padding(
-//       CHECK:   linalg.conv(%{{.*}}, %{{.*}}, %{{.*}}) {
-//  CHECK-SAME:     dilations = [1, 1],
-//  CHECK-SAME:     padding = dense<[
-//  CHECK-SAME:                      [0, 1], [1, 1]]> : tensor<2x2xi64>,
-//  CHECK-SAME:     strides = [1, 1]} :
-//  CHECK-SAME:     memref<?x?x?x?xf32>,
-//  CHECK-SAME:     memref<?x?x?x?xf32>,
-//  CHECK-SAME:     memref<?x?x?x?xf32>
-
-// -----
-
 #accesses_0 = [
   affine_map<(i, j, k) -> (j, i)>,
   affine_map<(i, j, k) -> ()>,
   affine_map<(i, j, k) -> (i, k, i + j)>
 ]
 
 #trait_0 = {
   indexing_maps = #accesses_0,

mlir/test/Dialect/Linalg/tile-conv-padding.mlir

-// RUN: mlir-opt %s -linalg-tile="tile-sizes=2,3,0,0,4" | FileCheck %s -check-prefix=TILE-23004
-// RUN: mlir-opt %s -linalg-tile="tile-sizes=2" | FileCheck %s -check-prefix=TILE-20000
-
-// TILE-23004-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
-// TILE-20000-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
-// TILE-20000-DAG: #[[$minmap:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)>
-
-func @conv_padding(%arg0: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, %arg1: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, %arg2: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>) {
-  linalg.conv(%arg0, %arg1, %arg2) {dilations = [10, 20], padding = dense<[[1, 1], [0, 1]]> : tensor<2x2xi64>, strides = [30, 40]} : memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>
-  return
-}
-// TILE-23004-LABEL: func @conv_padding(
-//  TILE-23004-SAME:   %[[ARG0:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32, #[[$strided4D]]>
-//  TILE-23004-SAME:   %[[ARG1:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32, #[[$strided4D]]>
-//  TILE-23004-SAME:   %[[ARG2:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32, #[[$strided4D]]>)
-//       TILE-23004:         linalg.conv(%[[ARG0]], %[[ARG1]], %[[ARG2]])
-
-// TILE-20000-LABEL: func @conv_padding(
-//  TILE-20000-SAME: %[[ARG0:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32, #[[$strided4D]]>
-//  TILE-20000-SAME: %[[ARG1:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32, #[[$strided4D]]>
-//  TILE-20000-SAME: %[[ARG2:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32, #[[$strided4D]]>)
-//   TILE-20000-DAG:   %[[C0:.*]] = constant 0 : index
-//   TILE-20000-DAG:   %[[C2:.*]] = constant 2 : index
-//       TILE-20000:   %[[B:.*]] = memref.dim %[[ARG1]], %c0
-//       TILE-20000:   scf.for %[[ivI:.*]] = %[[C0]] to %[[B]] step %[[C2]] {
-//       TILE-20000:     %[[EXTENT:.*]] = affine.min #[[$minmap]](%[[ivI]])[%[[B]]]
-//       TILE-20000:     %[[DIM11:.*]] = memref.dim %[[ARG1]], %c1
-//       TILE-20000:     %[[DIM12:.*]] = memref.dim %[[ARG1]], %c2
-//       TILE-20000:     %[[DIM13:.*]] = memref.dim %[[ARG1]], %c3
-//       TILE-20000:     %[[SUBVIEW1:.*]] = memref.subview %[[ARG1]][%[[ivI]], 0, 0, 0] [%[[EXTENT]], %[[DIM11]], %[[DIM12]], %[[DIM13]]]
-//       TILE-20000:     %[[EXTENT:.*]] = affine.min #[[$minmap]](%[[ivI]])[%[[B]]]
-//       TILE-20000:     %[[DIM21:.*]] = memref.dim %[[ARG2]], %c1
-//       TILE-20000:     %[[DIM22:.*]] = memref.dim %[[ARG2]], %c2
-//       TILE-20000:     %[[DIM23:.*]] = memref.dim %[[ARG2]], %c3
-//       TILE-20000:     %[[SUBVIEW2:.*]] = memref.subview %[[ARG2]][%[[ivI]], 0, 0, 0] [%[[EXTENT]], %[[DIM21]], %[[DIM22]], %[[DIM23]]]
-//       TILE-20000:     linalg.conv(%[[ARG0]], %[[SUBVIEW1]], %[[SUBVIEW2]])

mlir/test/Dialect/Linalg/tile-conv.mlir

-// RUN: mlir-opt %s -linalg-tile="tile-sizes=2,3,0,0,4" | FileCheck %s -check-prefix=TILE-23004
+// RUN: mlir-opt %s -linalg-tile="tile-sizes=2,3" | FileCheck %s
 
-// TILE-23004-DAG: #[[$D0x30pS0x10:.*]] = affine_map<(d0) -> (d0 * 30)>
-// TILE-23004-DAG: #[[$S0x10p90D0x30pS1:.*]] = affine_map<(d0)[s0, s1] -> (s0 * 10 + 51, d0 * -30 + s0 * 10 + s1 * 30 - 39)>
-// TILE-23004-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
-// TILE-23004-DAG: #[[$bound_map_2:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)>
-// TILE-23004-DAG: #[[$bound_map_3:.*]] = affine_map<(d0)[s0] -> (3, -d0 + s0)>
-// TILE-23004-DAG: #[[$bound_map_4:.*]] = affine_map<(d0)[s0] -> (4, -d0 + s0)>
+//  CHECK-DAG: #[[MAP0:.*]] = affine_map<(d0)[s0, s1] -> (s0 + 1, -d0 + s0 + s1 - 1)>
+//  CHECK-DAG: #[[MAP1:.*]] = affine_map<(d0)[s0, s1] -> (s0 + 2, -d0 + s0 + s1 - 1)>
+//  CHECK-DAG: #[[MAP2:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)>
+//  CHECK-DAG: #[[MAP3:.*]] = affine_map<(d0)[s0] -> (3, -d0 + s0)>
 
-func @conv(%arg0: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, %arg1: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, %arg2: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>) {
-  linalg.conv(%arg0, %arg1, %arg2) {dilations = [10, 20], strides = [30, 40]} : memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>
+func @conv(%arg0 : memref<?x?xf32>, %arg1 : memref<?x?xf32>, %arg2 : memref<?x?xf32>) {
+  linalg.conv_2d ins(%arg0, %arg1 : memref<?x?xf32>, memref<?x?xf32>) outs(%arg2 : memref<?x?xf32>)
   return
 }
-//       TILE-23004: func @conv(
-//  TILE-23004-SAME:   %[[ARG0:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32, #[[$strided4D]]>
-//  TILE-23004-SAME:   %[[ARG1:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32, #[[$strided4D]]>
-//  TILE-23004-SAME:   %[[ARG2:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32, #[[$strided4D]]>)
-//   TILE-23004-DAG:   %[[C0:.*]] = constant 0 : index
-//   TILE-23004-DAG:   %[[C2:.*]] = constant 2 : index
-//   TILE-23004-DAG:   %[[C3:.*]] = constant 3 : index
-//   TILE-23004-DAG:   %[[C4:.*]] = constant 4 : index
-//       TILE-23004:   %[[Z0:.*]] = memref.dim %[[ARG0]], %c0 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       TILE-23004:   %[[Q:.*]] = memref.dim %[[ARG0]], %c2 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       TILE-23004:   %[[B:.*]] = memref.dim %[[ARG1]], %c0 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       TILE-23004:   %[[X0:.*]] = memref.dim %[[ARG2]], %c1 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       TILE-23004:   scf.for %[[ivI:.*]] = %{{.*}} to %[[B]] step %{{.*}} {
-//       TILE-23004:     scf.for %[[ivJ:.*]] = %{{.*}} to %[[X0]] step %{{.*}} {
-//       TILE-23004:       scf.for %[[ivK:.*]] = %{{.*}} to %[[Q]] step %{{.*}} {
-//       TILE-23004:         %[[Z0_1:.*]] = memref.dim %[[ARG0]], %c0 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       TILE-23004:         %[[Z1:.*]] = memref.dim %[[ARG0]], %c1 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       TILE-23004:         %[[szK:.*]] = affine.min #[[$bound_map_4]](%[[ivK]])[%[[Q]]]
-//       TILE-23004:         %[[K:.*]] = memref.dim %[[ARG0]], %c3 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       TILE-23004:         %[[FilterView:.*]] = memref.subview %{{.*}}[0, 0, %[[ivK]], 0] [%[[Z0_1]], %[[Z1]], %[[szK]], %[[K]]] [1, 1, 1, 1] : memref<?x?x?x?xf32, #[[$strided4D]]> to memref<?x?x?x?xf32, #[[$strided4D]]>
-//
-//       TILE-23004:         %[[J1:.*]] = affine.apply #[[$D0x30pS0x10]](%[[ivJ]])
-//       TILE-23004:         %[[I1pStep:.*]] = affine.min #[[$S0x10p90D0x30pS1]](%[[ivJ]])[%[[Z0]], %[[X0]]]
-//       TILE-23004:         %[[SZ2:.*]] = memref.dim %[[ARG1]], %c2 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       TILE-23004:         %[[sz3:.*]] = affine.min #[[$bound_map_4]](%[[ivK]])[%[[Q]]]
-//       TILE-23004:         %[[InputView:.*]] = memref.subview %{{.*}}[%[[ivI]], %[[J1]], 0, %[[ivK]]] [%{{.*}}, %{{.*}}, %[[SZ2]], %[[sz3]]] [1, 1, 1, 1] : memref<?x?x?x?xf32, #[[$strided4D]]> to memref<?x?x?x?xf32, #[[$strided4D]]>
-//
-//       TILE-23004:         %[[X0:.*]] = memref.dim %[[ARG2]], %c2 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       TILE-23004:         %[[X1:.*]] = memref.dim %[[ARG2]], %c3 : memref<?x?x?x?xf32, #[[$strided4D]]>
-//       TILE-23004:         %[[OutputView:.*]] = memref.subview %{{.*}}[%[[ivI]], %[[ivJ]], 0, 0] [%{{.*}}, %{{.*}}, %[[X0]], %[[X1]]] [1, 1, 1, 1] : memref<?x?x?x?xf32, #[[$strided4D]]> to memref<?x?x?x?xf32, #[[$strided4D]]>
-//
-//       TILE-23004:         linalg.conv(%[[FilterView]], %[[InputView]], %[[OutputView]]) {dilations = [10, 20], strides = [30, 40]} : memref<?x?x?x?xf32, #[[$strided4D]]>, memref<?x?x?x?xf32, #[[$strided4D]]>, memref<?x?x?x?xf32, #[[$strided4D]]>
+
+//       CHECK: func @conv
+//  CHECK-SAME:   %[[ARG0:[a-zA-Z0-9_]*]]: memref<?x?xf32>
+//  CHECK-SAME:   %[[ARG1:[a-zA-Z0-9_]*]]: memref<?x?xf32>
+//  CHECK-SAME:   %[[ARG2:[a-zA-Z0-9_]*]]: memref<?x?xf32>
+//   CHECK-DAG:   %[[C0:.*]] = constant 0 : index
+//   CHECK-DAG:   %[[C1:.*]] = constant 1 : index
+//   CHECK-DAG:   %[[C2:.*]] = constant 2 : index
+//   CHECK-DAG:   %[[C3:.*]] = constant 3 : index
+//   CHECK-DAG:   %[[T0:.*]] = memref.dim %[[ARG1]], %[[C0]]
+//   CHECK-DAG:   %[[T1:.*]] = memref.dim %[[ARG1]], %[[C1]]
+//   CHECK-DAG:   %[[T2:.*]] = memref.dim %[[ARG2]], %[[C0]]
+//   CHECK-DAG:   %[[T3:.*]] = memref.dim %[[ARG2]], %[[C1]]
+//       CHECK:   scf.for %[[ARG3:.*]] = %[[C0]] to %[[T2]] step %[[C2]]
+//       CHECK:     scf.for %[[ARG4:.*]] = %[[C0]] to %[[T3]] step %[[C3]]
+//       CHECK:       %[[T4:.*]] = affine.min #[[MAP0]](%[[ARG3]])[%[[T0]], %[[T2]]]
+//       CHECK:       %[[T5:.*]] = affine.min #[[MAP1]](%[[ARG4]])[%[[T1]], %[[T3]]]
+//       CHECK:       %[[SV1:.*]] = memref.subview %[[ARG0]][%[[ARG3]], %[[ARG4]]] [%[[T4]], %[[T5]]]
+//       CHECK:       %[[T6:.*]] = affine.min #[[MAP2]](%[[ARG3]])[%[[T2]]
+//       CHECK:       %[[T7:.*]] = affine.min #[[MAP3]](%[[ARG4]])[%[[T3]]]
+//       CHECK:       %[[SV2:.*]] = memref.subview %[[ARG2]][%[[ARG3]], %[[ARG4]]] [%[[T6]], %[[T7]]]
+//       CHECK:       linalg.conv_2d
+//  CHECK-SAME:         ins(%[[SV1]], %[[ARG1]]
+//  CHECK-SAME:         outs(%[[SV2]]

mlir/test/Dialect/Linalg/tile-simple-conv.mlir

-// RUN: mlir-opt %s -linalg-tile="tile-sizes=2,3,4" | FileCheck %s
-
-//  CHECK-DAG: #[[MAP0:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)>
-//  CHECK-DAG: #[[MAP1:.*]] = affine_map<(d0)[s0, s1] -> (s0 + 2, -d0 + s0 + s1 - 1)>
-//  CHECK-DAG: #[[MAP2:.*]] = affine_map<(d0)[s0, s1] -> (s0 + 3, -d0 + s0 + s1 - 1)>
-//  CHECK-DAG: #[[MAP4:.*]] = affine_map<(d0)[s0] -> (3, -d0 + s0)>
-//  CHECK-DAG: #[[MAP5:.*]] = affine_map<(d0)[s0] -> (4, -d0 + s0)>
-
-func @conv(%arg0 : memref<?x?x?x?xf32>, %arg1 : memref<?x?x?x?xf32>, %arg2 : memref<?x?x?x?xf32>) {
-  linalg.conv(%arg0, %arg1, %arg2) : memref<?x?x?x?xf32>, memref<?x?x?x?xf32>, memref<?x?x?x?xf32>
-  return
-}
-
-//       CHECK: func @conv
-//  CHECK-SAME:   %[[ARG0:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32>
-//  CHECK-SAME:   %[[ARG1:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32>
-//  CHECK-SAME:   %[[ARG2:[a-zA-Z0-9_]*]]: memref<?x?x?x?xf32>
-//   CHECK-DAG:   %[[C0:.*]] = constant 0 : index
-//   CHECK-DAG:   %[[C1:.*]] = constant 1 : index
-//   CHECK-DAG:   %[[C2:.*]] = constant 2 : index
-//   CHECK-DAG:   %[[C3:.*]] = constant 3 : index
-//   CHECK-DAG:   %[[C4:.*]] = constant 4 : index
-//       CHECK:   %[[T0:.*]] = memref.dim %[[ARG0]], %[[C0]]
-//       CHECK:   %[[T1:.*]] = memref.dim %[[ARG0]], %[[C1]]
-//       CHECK:   %[[T2:.*]] = memref.dim %[[ARG1]], %[[C0]]
-//       CHECK:   %[[T3:.*]] = memref.dim %[[ARG2]], %[[C1]]
-//       CHECK:   %[[T4:.*]] = memref.dim %[[ARG2]], %[[C2]]
-//       CHECK:   scf.for %[[ARG3:.*]] = %[[C0]] to %[[T2]] step %[[C2]]
-//       CHECK:     scf.for %[[ARG4:.*]] = %[[C0]] to %[[T3]] step %[[C3]]
-//       CHECK:       scf.for %[[ARG5:.*]] = %[[C0]] to %[[T4]] step %[[C4]]
-//       CHECK:         %[[T6:.*]] = affine.min #[[MAP0]](%[[ARG3]])[%[[T2]]]
-//       CHECK:         %[[T8:.*]] = affine.min #[[MAP1]](%[[ARG4]])[%[[T0]], %[[T3]]]
-//       CHECK:         %[[T10:.*]] = affine.min #[[MAP2]](%[[ARG5]])[%[[T1]], %[[T4]]]
-//       CHECK:         %[[T11:.*]] = memref.dim %[[ARG1]], %[[C3]]
-//       CHECK:         %[[SV1:.*]] = memref.subview %[[ARG1]][%[[ARG3]], %[[ARG4]], %[[ARG5]], 0]
-//  CHECK-SAME:                                        [%[[T6]], %[[T8]], %[[T10]], %[[T11]]]
-//       CHECK:         %[[T14:.*]] = affine.min #[[MAP0]](%[[ARG3]])[%[[T2]]
-//       CHECK:         %[[T16:.*]] = affine.min #[[MAP4]](%[[ARG4]])[%[[T3]]]
-//       CHECK:         %[[T18:.*]] = affine.min #[[MAP5]](%[[ARG5]])[%[[T4]]
-//       CHECK:         %[[T19:.*]] = memref.dim %[[ARG2]], %[[C3]]
-//       CHECK:         %[[SV2:.*]] = memref.subview %[[ARG2]][%[[ARG3]], %[[ARG4]], %[[ARG5]], 0]
-//  CHECK-SAME:                                        [%[[T14]], %[[T16]], %[[T18]], %[[T19]]]
-//       CHECK:         linalg.conv(%[[ARG0]], %[[SV1]], %[[SV2]])

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

 using namespace mlir;
 using namespace mlir::linalg;
 
 template <LinalgTilingLoopType LoopType>
 static void fillFusionPatterns(MLIRContext *context,
                                const LinalgDependenceGraph &dependenceGraph,
                                RewritePatternSet &patterns) {
   patterns.add<LinalgTileAndFusePattern<MatmulOp>,
-               LinalgTileAndFusePattern<ConvOp>>(
+               LinalgTileAndFusePattern<Conv2DOp>>(
       context, dependenceGraph,
       LinalgTilingOptions().setTileSizes({32, 64, 16}).setLoopType(LoopType),
       LinalgFusionOptions().setIndicesToFuse({2}),
       LinalgTransformationFilter(
           Identifier::get("basic_fusion", context),
           Identifier::get("after_basic_fusion", context)),
       LinalgTransformationFilter(
           ArrayRef<Identifier>(),