[mlir] NFC - Expose an OffsetSizeAndStrideOpInterface

[nicolasvasilache]

Summary

This revision will make it easier to create new ops base on the strided memref abstraction outside of the std dialect.

[rriddle]

Can you add proper documentation in the description+commit on what this interface is, how it is intended to be used, and what the invariants are?

mlir/include/mlir/Interfaces/ViewLikeInterface.td

35

Please provide a much more detailed description here. It isn't clear what this is supposed to mean or how it should be used.

218

The formatting on most of these is off, please fix it.

[rriddle]

mlir/include/mlir/Interfaces/ViewLikeInterface.h

22

SubViewOp/SubTensorOp don't make sense to mention here.

[nicolasvasilache]

mlir/include/mlir/Interfaces/ViewLikeInterface.td

35

Note: I am hoping to also provide reusable verification/parsing/printing.
Any concern with exposing those through interfaces?

[nicolasvasilache]

Address comments.

[nicolasvasilache]

Address comments.

[rriddle]

mlir/include/mlir/Interfaces/ViewLikeInterface.td

35

Verification is common, there is a verify field on OpInterface where you can specify that and it will be placed on the generated interface trait class. For parsers/printers those are fine to provide as utilities, just not really on the interface class itself. I'd expose those in a impl namespace in ViewLikeInterfaces.h. I think we already do this with some other parsers/printers somewhere else in the code base. I'd only put things on the interface that are supposed to generalize well across all of the use cases, parsers/printers generally don't.

[pifon2a]

super-nice!

[nicolasvasilache]

Integrate a little deeper.

[nicolasvasilache]

mlir/include/mlir/Interfaces/ViewLikeInterface.td

35

Thanks! Parser and printer coming as followups.

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

 #include "mlir/Dialect/StandardOps/IR/OpsEnums.h.inc"
 
 namespace mlir {
 class AffineMap;
 class Builder;
 class FuncOp;
 class OpBuilder;
 
-/// Auxiliary range data structure to unpack the offset, size and stride
-/// operands of the SubViewOp / SubTensorOp into a list of triples.
-/// Such a list of triple is sometimes more convenient to manipulate.
-struct Range {
-  Value offset;
-  Value size;
-  Value stride;
-};
-
 raw_ostream &operator<<(raw_ostream &os, Range &range);
 
+/// Return the list of Range (i.e. offset, size, stride). Each Range
+/// entry contains either the dynamic value or a ConstantIndexOp constructed
+/// with `b` at location `loc`.
+SmallVector<Range, 8> getOrCreateRanges(OffsetSizeAndStrideOpInterface op,
+                                        OpBuilder &b, Location loc);
+
 #define GET_OP_CLASSES
 #include "mlir/Dialect/StandardOps/IR/Ops.h.inc"
 
 #include "mlir/Dialect/StandardOps/IR/OpsDialect.h.inc"
 
 /// This is a refinement of the "constant" op for the case where it is
 /// returning a float value of FloatType.
 ///

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 }
 
 // Base class for ops with static/dynamic offset, sizes and strides
 // attributes/arguments.
 class BaseOpWithOffsetSizesAndStrides<string mnemonic, list<OpTrait> traits = []> :
     Std_Op<mnemonic,
            !listconcat(traits, [NoSideEffect, AttrSizedOperandSegments])> {
   code extraBaseClassDeclaration = [{
-    /// Returns the number of dynamic offset operands.
-    int64_t getNumOffsets() { return llvm::size(offsets()); }
-
-    /// Returns the number of dynamic size operands.
-    int64_t getNumSizes() { return llvm::size(sizes()); }
-
-    /// Returns the number of dynamic stride operands.
-    int64_t getNumStrides() { return llvm::size(strides()); }
-
     /// Returns the dynamic sizes for this subview operation if specified.
     operand_range getDynamicSizes() { return sizes(); }
 
-    /// Returns in `staticStrides` the static value of the stride
-    /// operands. Returns failure() if the static value of the stride
-    /// operands could not be retrieved.
-    LogicalResult getStaticStrides(SmallVectorImpl<int64_t> &staticStrides) {
-      if (!strides().empty())
-        return failure();
-      staticStrides.reserve(static_strides().size());
-      for (auto s : static_strides().getAsValueRange<IntegerAttr>())
-        staticStrides.push_back(s.getZExtValue());
-      return success();
-    }
-
     /// Return the list of Range (i.e. offset, size, stride). Each
     /// Range entry contains either the dynamic value or a ConstantIndexOp
     /// constructed with `b` at location `loc`.
-    SmallVector<Range, 8> getOrCreateRanges(OpBuilder &b, Location loc);
-
-    /// Return the offsets as Values. Each Value is either the dynamic
-    /// value specified in the op or a ConstantIndexOp constructed
-    /// with `b` at location `loc`
-    SmallVector<Value, 4> getOrCreateOffsets(OpBuilder &b, Location loc) {
-      unsigned dynamicIdx = 1;
-      return llvm::to_vector<4>(llvm::map_range(
-        static_offsets().cast<ArrayAttr>(), [&](Attribute a) -> Value {
-          int64_t staticOffset = a.cast<IntegerAttr>().getInt();
-          if (ShapedType::isDynamicStrideOrOffset(staticOffset))
-            return getOperand(dynamicIdx++);
-          else
-            return b.create<ConstantOp>(
-              loc, b.getIndexType(), b.getIndexAttr(staticOffset));
-        }));
-    }
-
-    /// Return the sizes as Values. Each Value is either the dynamic
-    /// value specified in the op or a ConstantIndexOp constructed
-    /// with `b` at location `loc`
-    SmallVector<Value, 4> getOrCreateSizes(OpBuilder &b, Location loc) {
-      unsigned dynamicIdx = 1 + offsets().size();
-      return llvm::to_vector<4>(llvm::map_range(
-        static_sizes().cast<ArrayAttr>(), [&](Attribute a) -> Value {
-          int64_t staticSize = a.cast<IntegerAttr>().getInt();
-          if (ShapedType::isDynamic(staticSize))
-            return getOperand(dynamicIdx++);
-          else
-            return b.create<ConstantOp>(
-              loc, b.getIndexType(), b.getIndexAttr(staticSize));
-        }));
-    }
-
-    /// Return the strides as Values. Each Value is either the dynamic
-    /// value specified in the op or a ConstantIndexOp constructed with
-    /// `b` at location `loc`
-    SmallVector<Value, 4> getOrCreateStrides(OpBuilder &b, Location loc) {
-      unsigned dynamicIdx = 1 + offsets().size() + sizes().size();
-      return llvm::to_vector<4>(llvm::map_range(
-        static_strides().cast<ArrayAttr>(), [&](Attribute a) -> Value {
-          int64_t staticStride = a.cast<IntegerAttr>().getInt();
-          if (ShapedType::isDynamicStrideOrOffset(staticStride))
-            return getOperand(dynamicIdx++);
-          else
-            return b.create<ConstantOp>(
-              loc, b.getIndexType(), b.getIndexAttr(staticStride));
-        }));
+    SmallVector<Range, 8> getOrCreateRanges(OpBuilder &b, Location loc) {
+      return mlir::getOrCreateRanges(*this, b, loc);
     }
 
-    /// Return the rank of the source ShapedType.
-    unsigned getSourceRank() {
-      return source().getType().cast<ShapedType>().getRank();
-    }
-
-    /// Return the rank of the result ShapedType.
-    unsigned getResultRank() { return getType().getRank(); }
-
-    /// Return true if the offset `idx` is a static constant.
-    bool isDynamicOffset(unsigned idx) {
-      APInt v = *(static_offsets().getAsValueRange<IntegerAttr>().begin() + idx);
-      return ShapedType::isDynamicStrideOrOffset(v.getSExtValue());
-    }
-    /// Return true if the size `idx` is a static constant.
-    bool isDynamicSize(unsigned idx) {
-      APInt v = *(static_sizes().getAsValueRange<IntegerAttr>().begin() + idx);
-      return ShapedType::isDynamic(v.getSExtValue());
-    }
-
-    /// Return true if the stride `idx` is a static constant.
-    bool isDynamicStride(unsigned idx) {
-      APInt v = *(static_strides().getAsValueRange<IntegerAttr>().begin() + idx);
-      return ShapedType::isDynamicStrideOrOffset(v.getSExtValue());
-    }
-
-    /// Assert the offset `idx` is a static constant and return its value.
-    int64_t getStaticOffset(unsigned idx) {
-      assert(!isDynamicOffset(idx) && "expected static offset");
-      APInt v = *(static_offsets().getAsValueRange<IntegerAttr>().begin() + idx);
-      return v.getSExtValue();
-    }
-    /// Assert the size `idx` is a static constant and return its value.
-    int64_t getStaticSize(unsigned idx) {
-      assert(!isDynamicSize(idx) && "expected static size");
-      APInt v = *(static_sizes().getAsValueRange<IntegerAttr>().begin() + idx);
-      return v.getSExtValue();
-    }
-    /// Assert the stride `idx` is a static constant and return its value.
-    int64_t getStaticStride(unsigned idx) {
-      assert(!isDynamicStride(idx) && "expected static stride");
-      APInt v = *(static_strides().getAsValueRange<IntegerAttr>().begin() + idx);
-      return v.getSExtValue();
-    }
-
-    unsigned getNumDynamicEntriesUpToIdx(ArrayAttr attr,
-        llvm::function_ref<bool(int64_t)> isDynamic, unsigned idx) {
-      return std::count_if(
-        attr.getValue().begin(), attr.getValue().begin() + idx,
-        [&](Attribute attr) {
-          return isDynamic(attr.cast<IntegerAttr>().getInt());
-        });
-    }
-    /// Assert the offset `idx` is dynamic and return the position of the
-    /// corresponding operand.
-    unsigned getIndexOfDynamicOffset(unsigned idx) {
-      assert(isDynamicOffset(idx) && "expected static offset");
-      auto numDynamic =
-          getNumDynamicEntriesUpToIdx(static_offsets().cast<ArrayAttr>(),
-                                      ShapedType::isDynamicStrideOrOffset, idx);
-      return 1 + numDynamic;
-    }
-    /// Assert the size `idx` is dynamic and return the position of the
-    /// corresponding operand.
-    unsigned getIndexOfDynamicSize(unsigned idx) {
-      assert(isDynamicSize(idx) && "expected static size");
-      auto numDynamic = getNumDynamicEntriesUpToIdx(
-          static_sizes().cast<ArrayAttr>(), ShapedType::isDynamic, idx);
-      return 1 + offsets().size() + numDynamic;
-    }
-    /// Assert the stride `idx` is dynamic and return the position of the
-    /// corresponding operand.
-    unsigned getIndexOfDynamicStride(unsigned idx) {
-      assert(isDynamicStride(idx) && "expected static stride");
-      auto numDynamic =
-          getNumDynamicEntriesUpToIdx(static_strides().cast<ArrayAttr>(),
-                                      ShapedType::isDynamicStrideOrOffset, idx);
-      return 1 + offsets().size() + sizes().size() + numDynamic;
-    }
-
-    /// Assert the offset `idx` is dynamic and return its value.
-    Value getDynamicOffset(unsigned idx) {
-      return getOperand(getIndexOfDynamicOffset(idx));
-    }
-    /// Assert the size `idx` is dynamic and return its value.
-    Value getDynamicSize(unsigned idx) {
-      return getOperand(getIndexOfDynamicSize(idx));
-    }
-    /// Assert the stride `idx` is dynamic and return its value.
-    Value getDynamicStride(unsigned idx) {
-      return getOperand(getIndexOfDynamicStride(idx));
-    }
-
-    static StringRef getStaticOffsetsAttrName() {
-      return "static_offsets";
-    }
-    static StringRef getStaticSizesAttrName() {
-      return "static_sizes";
-    }
-    static StringRef getStaticStridesAttrName() {
-      return "static_strides";
-    }
     static ArrayRef<StringRef> getSpecialAttrNames() {
       static SmallVector<StringRef, 4> names{
-        getStaticOffsetsAttrName(),
-        getStaticSizesAttrName(),
-        getStaticStridesAttrName(),
+        OffsetSizeAndStrideOpInterface::getStaticOffsetsAttrName(),
+        OffsetSizeAndStrideOpInterface::getStaticSizesAttrName(),
+        OffsetSizeAndStrideOpInterface::getStaticStridesAttrName(),
         getOperandSegmentSizeAttr()};
       return names;
    }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // AbsFOp

 
 
 //===----------------------------------------------------------------------===//
 // MemRefReinterpretCastOp
 //===----------------------------------------------------------------------===//
 
 def MemRefReinterpretCastOp:
     BaseOpWithOffsetSizesAndStrides<"memref_reinterpret_cast", [
-      NoSideEffect, ViewLikeOpInterface
+      NoSideEffect, ViewLikeOpInterface, OffsetSizeAndStrideOpInterface
     ]> {
   let summary = "memref reinterpret cast operation";
   let description = [{
     Modify offset, sizes and strides of an unranked/ranked memref.
 
     Example:
     ```mlir
     memref_reinterpret_cast %ranked to
OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
       "Value":$offset, "ValueRange":$sizes, "ValueRange":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     // The result of the op is always a ranked memref.
     MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
     Value getViewSource() { return source(); }
+
+    /// Return the rank of the source ShapedType.
+    unsigned getResultRank() {
+      return getResult().getType().cast<ShapedType>().getRank();
+    }
+
+    /// Return the expected rank of each of the`static_offsets`, `static_sizes`
+    /// and `static_strides` attributes.
+    std::array<unsigned, 3> getArrayAttrRanks() {
+      unsigned resultRank = getResult().getType().cast<ShapedType>().getRank();
+      return {1, resultRank, resultRank};
+    }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // MemRefReshapeOp
 //===----------------------------------------------------------------------===//
 
 def MemRefReshapeOp: Std_Op<"memref_reshape", [
def SubIOp : IntArithmeticOp<"subi"> {
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SubViewOp
 //===----------------------------------------------------------------------===//
 
 def SubViewOp : BaseOpWithOffsetSizesAndStrides<
-    "subview", [DeclareOpInterfaceMethods<ViewLikeOpInterface>] >  {
+    "subview", [DeclareOpInterfaceMethods<ViewLikeOpInterface>, OffsetSizeAndStrideOpInterface] >  {
   let summary = "memref subview operation";
   let description = [{
     The "subview" operation converts a memref type to another memref type
     which represents a reduced-size view of the original memref as specified by
     the operation's offsets, sizes and strides arguments.
 
     The SubView operation supports the following arguments:
 
let extraClassDeclaration = extraBaseClassDeclaration # [{
 
     /// A subview result type can be fully inferred from the source type and the
     /// static representation of offsets, sizes and strides. Special sentinels
     /// encode the dynamic case.
     static Type inferResultType(MemRefType sourceMemRefType,
                                 ArrayRef<int64_t> staticOffsets,
                                 ArrayRef<int64_t> staticSizes,
                                 ArrayRef<int64_t> staticStrides);
+
+    /// Return the expected rank of each of the`static_offsets`, `static_sizes`
+    /// and `static_strides` attributes.
+    std::array<unsigned, 3> getArrayAttrRanks() {
+      unsigned rank = getSourceType().getRank();
+      return {rank, rank, rank};
+    }
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SubTensorOp
 //===----------------------------------------------------------------------===//
 
-def SubTensorOp : BaseOpWithOffsetSizesAndStrides<"subtensor"> {
+def SubTensorOp : BaseOpWithOffsetSizesAndStrides<"subtensor", [OffsetSizeAndStrideOpInterface]> {
   let summary = "subtensor operation";
   let description = [{
     The "subtensor" operation extract a tensor from another tensor as
     specified by the operation's offsets, sizes and strides arguments.
 
     The subtensor operation supports the following arguments:
 
     * tensor: the "base" tensor from which to extract a subtensor.
let extraClassDeclaration = extraBaseClassDeclaration # [{
 
     /// A subview result type can be fully inferred from the source type and the
     /// static representation of offsets, sizes and strides. Special sentinels
     /// encode the dynamic case.
     static Type inferResultType(RankedTensorType sourceRankedTensorType,
                                 ArrayRef<int64_t> staticOffsets,
                                 ArrayRef<int64_t> staticSizes,
                                 ArrayRef<int64_t> staticStrides);
+
+    /// Return the expected rank of each of the`static_offsets`, `static_sizes`
+    /// and `static_strides` attributes.
+    std::array<unsigned, 3> getArrayAttrRanks() {
+      unsigned rank = getSourceType().getRank();
+      return {rank, rank, rank};
+    }
   }];
 
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SubTensorInsertOp
 //===----------------------------------------------------------------------===//
 
-def SubTensorInsertOp : BaseOpWithOffsetSizesAndStrides<"subtensor_insert"> {
+def SubTensorInsertOp : BaseOpWithOffsetSizesAndStrides<"subtensor_insert", [OffsetSizeAndStrideOpInterface]> {
   let summary = "subtensor_insert operation";
   let description = [{
     The "subtensor_insert" operation insert a tensor `source` into another
     tensor `dest` as specified by the operation's offsets, sizes and strides
     arguments.
 
     It returns a copy of `dest` with the proper subtensor updated with the value
     of `source`.
let extraClassDeclaration = extraBaseClassDeclaration # [{
     RankedTensorType getSourceType() {
       return source().getType().cast<RankedTensorType>();
     }
 
     /// The result of a subtensor is always a tensor.
     RankedTensorType getType() {
       return getResult().getType().cast<RankedTensorType>();
     }
+
+    /// Return the expected rank of each of the`static_offsets`, `static_sizes`
+    /// and `static_strides` attributes.
+    std::array<unsigned, 3> getArrayAttrRanks() {
+      unsigned rank = getSourceType().getRank();
+      return {rank, rank, rank};
+    }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // TanhOp
 //===----------------------------------------------------------------------===//
 
 def TanhOp : FloatUnaryOp<"tanh"> {

mlir/include/mlir/Interfaces/ViewLikeInterface.h

 //===- ViewLikeInterface.h - View-like operations interface ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the operation interface for view-like operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_INTERFACES_VIEWLIKEINTERFACE_H_
 #define MLIR_INTERFACES_VIEWLIKEINTERFACE_H_
 
+#include "mlir/IR/Builders.h"
 #include "mlir/IR/OpDefinition.h"
+#include "mlir/IR/StandardTypes.h"
+
+namespace mlir {
+/// Auxiliary range data structure to unpack the offset, size and stride
+/// operands into a list of triples. Such a list can be more convenient to
+/// manipulate.
+struct Range {
+  Value offset;
+  Value size;
+  Value stride;
+};
+
+class OffsetSizeAndStrideOpInterface;
+LogicalResult verify(OffsetSizeAndStrideOpInterface op);
+} // namespace mlir
 
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/ViewLikeInterface.h.inc"
 
 #endif // MLIR_INTERFACES_VIEWLIKEINTERFACE_H_

mlir/include/mlir/Interfaces/ViewLikeInterface.td

def ViewLikeOpInterface : OpInterface<"ViewLikeOpInterface"> {
 
   let methods = [
     InterfaceMethod<
       "Returns the source buffer from which the view is created.",
       "Value", "getViewSource">
   ];
 }
 
+def OffsetSizeAndStrideOpInterface : OpInterface<"OffsetSizeAndStrideOpInterface"> {
+  let description = [{
+    Common interface for ops that allow specifying mixed dynamic and static
+    offsets, sizes and strides variadic operands.
+    Ops that implement this interface need to expose the following methods:
+      1. `getArrayAttrRanks` to specify the length of static integer
+          attributes.
+      2. `offsets`, `sizes` and `strides` variadic operands.
+      3. `static_offsets`, resp. `static_sizes` and `static_strides` integer
+          array attributes.
+
+    The invariants of this interface are:
+      1. `static_offsets`, `static_sizes` and `static_strides` have length
+          exactly `getArrayAttrRanks()`[0] (resp. [1], [2]).
+      2. `offsets`, `sizes` and `strides` have each length at most
+         `getArrayAttrRanks()`[0] (resp. [1], [2]).
+      3. if an entry of `static_offsets` (resp. `static_sizes`,
+         `static_strides`) is equal to a special sentinel value, namely
+         `ShapedType::kDynamicStrideOrOffset` (resp. `ShapedType::kDynamicSize`,
+         `ShapedType::kDynamicStrideOrOffset`), then the corresponding entry is
+         a dynamic offset (resp. size, stride).
+      4. a variadic `offset` (resp. `sizes`, `strides`) operand  must be present
+         for each dynamic offset (resp. size, stride).
+
+    This interface is useful to factor out common behavior and provide support
+    for carrying or injecting static behavior through the use of the static
+    attributes.
+  }];
+
+  let cppNamespace = "::mlir";
+
+  let methods = [
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the expected rank of each of the`static_offsets`, `static_sizes`
+        and `static_strides` attributes.
+      }],
+      /*retTy=*/"std::array<unsigned, 3>",
+      /*methodName=*/"getArrayAttrRanks",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.offsets();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the dynamic offset operands.
+      }],
+      /*retTy=*/"OperandRange",
+      /*methodName=*/"offsets",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.offsets();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the dynamic size operands.
+      }],
+      /*retTy=*/"OperandRange",
+      /*methodName=*/"sizes",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.sizes();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the dynamic stride operands.
+      }],
+      /*retTy=*/"OperandRange",
+      /*methodName=*/"strides",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.strides();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the static offset attributes.
+      }],
+      /*retTy=*/"ArrayAttr",
+      /*methodName=*/"static_offsets",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.static_offsets();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the static size attributes.
+      }],
+      /*retTy=*/"ArrayAttr",
+      /*methodName=*/"static_sizes",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.static_sizes();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the dynamic stride attributes.
+      }],
+      /*retTy=*/"ArrayAttr",
+      /*methodName=*/"static_strides",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.static_strides();
+      }]
+    >,
+
+    InterfaceMethod<
+      /*desc=*/[{
+        Return true if the offset `idx` is dynamic.
+      }],
+      /*retTy=*/"bool",
+      /*methodName=*/"isDynamicOffset",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        APInt v = *(static_offsets()
+          .template getAsValueRange<IntegerAttr>().begin() + idx);
+        return ShapedType::isDynamicStrideOrOffset(v.getSExtValue());
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return true if the size `idx` is dynamic.
+      }],
+      /*retTy=*/"bool",
+      /*methodName=*/"isDynamicSize",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        APInt v = *(static_sizes()
+          .template getAsValueRange<IntegerAttr>().begin() + idx);
+        return ShapedType::isDynamic(v.getSExtValue());
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+       Return true if the stride `idx` is dynamic.
+      }],
+      /*retTy=*/"bool",
+      /*methodName=*/"isDynamicStride",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        APInt v = *(static_strides()
+          .template getAsValueRange<IntegerAttr>().begin() + idx);
+        return ShapedType::isDynamicStrideOrOffset(v.getSExtValue());
+      }]
+    >,
+
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the offset `idx` is a static constant and return its value.
+      }],
+      /*retTy=*/"int64_t",
+      /*methodName=*/"getStaticOffset",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        assert(!$_op.isDynamicOffset(idx) && "expected static offset");
+        APInt v = *(static_offsets().
+          template getAsValueRange<IntegerAttr>().begin() + idx);
+        return v.getSExtValue();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the size `idx` is a static constant and return its value.
+      }],
+      /*retTy=*/"int64_t",
+      /*methodName=*/"getStaticSize",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        assert(!$_op.isDynamicSize(idx) && "expected static size");
+        APInt v = *(static_sizes().
+          template getAsValueRange<IntegerAttr>().begin() + idx);
+        return v.getSExtValue();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the stride `idx` is a static constant and return its value.
+      }],
+      /*retTy=*/"int64_t",
+      /*methodName=*/"getStaticStride",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        assert(!$_op.isDynamicStride(idx) && "expected static stride");
+        APInt v = *(static_strides().
+          template getAsValueRange<IntegerAttr>().begin() + idx);
+        return v.getSExtValue();
+      }]
+    >,
+
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the offset `idx` is dynamic and return the position of the
+        corresponding operand.
+      }],
+      /*retTy=*/"unsigned",
+      /*methodName=*/"getIndexOfDynamicOffset",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        assert($_op.isDynamicOffset(idx) && "expected dynamic offset");
+        auto numDynamic = getNumDynamicEntriesUpToIdx(
+          static_offsets().template cast<ArrayAttr>(),
+          ShapedType::isDynamicStrideOrOffset, 
+          idx);
+        return 1 + numDynamic;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the size `idx` is dynamic and return the position of the
+        corresponding operand.
+      }],
+      /*retTy=*/"unsigned",
+      /*methodName=*/"getIndexOfDynamicSize",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        assert($_op.isDynamicSize(idx) && "expected dynamic size");
+        auto numDynamic = getNumDynamicEntriesUpToIdx(
+          static_sizes().template cast<ArrayAttr>(), ShapedType::isDynamic, idx);
+        return 1 + offsets().size() + numDynamic;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the stride `idx` is dynamic and return the position of the
+        corresponding operand.
+      }],
+      /*retTy=*/"unsigned",
+      /*methodName=*/"getIndexOfDynamicStride",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        assert($_op.isDynamicStride(idx) && "expected dynamic stride");
+        auto numDynamic = getNumDynamicEntriesUpToIdx(
+          static_strides().template cast<ArrayAttr>(),
+          ShapedType::isDynamicStrideOrOffset, 
+          idx);
+        return 1 + offsets().size() + sizes().size() + numDynamic;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Helper method to compute the number of dynamic entries of `attr`, up to
+        `idx` using `isDynamic` to determine whether an entry is dynamic.
+      }],
+      /*retTy=*/"unsigned",
+      /*methodName=*/"getNumDynamicEntriesUpToIdx",
+      /*args=*/(ins "ArrayAttr":$attr,
+                    "llvm::function_ref<bool(int64_t)>":$isDynamic,
+                    "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return std::count_if(
+          attr.getValue().begin(), attr.getValue().begin() + idx,
+          [&](Attribute attr) {
+            return isDynamic(attr.cast<IntegerAttr>().getInt());
+          });
+      }]
+    >,
+
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the offset `idx` is dynamic and return its value.
+      }],
+      /*retTy=*/"Value",
+      /*methodName=*/"getDynamicOffset",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.getOperand(getIndexOfDynamicOffset(idx));
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the size `idx` is dynamic and return its value.
+      }],
+      /*retTy=*/"Value",
+      /*methodName=*/"getDynamicSize",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.getOperand(getIndexOfDynamicSize(idx));
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the stride `idx` is dynamic and return its value.
+      }],
+      /*retTy=*/"Value",
+      /*methodName=*/"getDynamicStride",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.getOperand(getIndexOfDynamicStride(idx));
+      }]
+    >,
+  ];
+
+  let extraClassDeclaration = [{
+    static StringRef getStaticOffsetsAttrName() {
+      return "static_offsets";
+    }
+    static StringRef getStaticSizesAttrName() {
+      return "static_sizes";
+    }
+    static StringRef getStaticStridesAttrName() {
+      return "static_strides";
+    }
+  }];
+
+  let verify = [{
+    return mlir::verify(cast<OffsetSizeAndStrideOpInterface>($_op));
+  }];
+}
+
 #endif // MLIR_INTERFACES_VIEWLIKEINTERFACE

mlir/lib/Conversion/StandardToSPIRV/LegalizeStandardForSPIRV.cpp

 ///          memref<12x42xf32>
 static LogicalResult
 resolveSourceIndices(Location loc, PatternRewriter &rewriter,
                      SubViewOp subViewOp, ValueRange indices,
                      SmallVectorImpl<Value> &sourceIndices) {
   // TODO: Aborting when the offsets are static. There might be a way to fold
   // the subview op with load even if the offsets have been canonicalized
   // away.
-  SmallVector<Value, 4> opOffsets = subViewOp.getOrCreateOffsets(rewriter, loc);
-  SmallVector<Value, 4> opStrides = subViewOp.getOrCreateStrides(rewriter, loc);
-  assert(opOffsets.size() == indices.size() &&
-         "expected as many indices as rank of subview op result type");
-  assert(opStrides.size() == indices.size() &&
+  SmallVector<Range, 4> opRanges = subViewOp.getOrCreateRanges(rewriter, loc);
+  auto opOffsets = llvm::map_range(opRanges, [](Range r) { return r.offset; });
+  auto opStrides = llvm::map_range(opRanges, [](Range r) { return r.stride; });
+  assert(opRanges.size() == indices.size() &&
          "expected as many indices as rank of subview op result type");
 
   // New indices for the load are the current indices * subview_stride +
   // subview_offset.
   sourceIndices.resize(indices.size());
   for (auto index : llvm::enumerate(indices)) {
-    auto offset = opOffsets[index.index()];
-    auto stride = opStrides[index.index()];
+    auto offset = *(opOffsets.begin() + index.index());
+    auto stride = *(opStrides.begin() + index.index());
     auto mul = rewriter.create<MulIOp>(loc, index.value(), stride);
     sourceIndices[index.index()] =
         rewriter.create<AddIOp>(loc, offset, mul).getResult();
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

parseListOfOperandsOrIntegers(OpAsmParser &parser, OperationState &result,
   }
 
   auto arrayAttr = parser.getBuilder().getI64ArrayAttr(attrVals);
   result.addAttribute(attrName, arrayAttr);
   return success();
 }
 
 /// Verify that a particular offset/size/stride static attribute is well-formed.
-template <typename OpType>
 static LogicalResult verifyOpWithOffsetSizesAndStridesPart(
-    OpType op, StringRef name, unsigned expectedNumElements, StringRef attrName,
-    ArrayAttr attr, llvm::function_ref<bool(int64_t)> isDynamic,
-    ValueRange values) {
+    OffsetSizeAndStrideOpInterface op, StringRef name,
+    unsigned expectedNumElements, StringRef attrName, ArrayAttr attr,
+    llvm::function_ref<bool(int64_t)> isDynamic, ValueRange values) {
   /// Check static and dynamic offsets/sizes/strides breakdown.
   if (attr.size() != expectedNumElements)
     return op.emitError("expected ")
            << expectedNumElements << " " << name << " values";
   unsigned expectedNumDynamicEntries =
       llvm::count_if(attr.getValue(), [&](Attribute attr) {
         return isDynamic(attr.cast<IntegerAttr>().getInt());
       });
   if (values.size() != expectedNumDynamicEntries)
     return op.emitError("expected ")
            << expectedNumDynamicEntries << " dynamic " << name << " values";
   return success();
 }
 
 /// Extract int64_t values from the assumed ArrayAttr of IntegerAttr.
 static SmallVector<int64_t, 4> extractFromI64ArrayAttr(Attribute attr) {
   return llvm::to_vector<4>(
       llvm::map_range(attr.cast<ArrayAttr>(), [](Attribute a) -> int64_t {
         return a.cast<IntegerAttr>().getInt();
       }));
 }
 
-/// Verify static attributes offsets/sizes/strides.
-template <typename OpType>
-static LogicalResult verifyOpWithOffsetSizesAndStrides(OpType op) {
-  unsigned srcRank = op.getSourceRank();
-  if (failed(verifyOpWithOffsetSizesAndStridesPart(
-          op, "offset", srcRank, op.getStaticOffsetsAttrName(),
-          op.static_offsets(), ShapedType::isDynamicStrideOrOffset,
-          op.offsets())))
-    return failure();
-  if (failed(verifyOpWithOffsetSizesAndStridesPart(
-          op, "size", srcRank, op.getStaticSizesAttrName(), op.static_sizes(),
-          ShapedType::isDynamic, op.sizes())))
-    return failure();
-  if (failed(verifyOpWithOffsetSizesAndStridesPart(
-          op, "stride", srcRank, op.getStaticStridesAttrName(),
-          op.static_strides(), ShapedType::isDynamicStrideOrOffset,
-          op.strides())))
-    return failure();
-  return success();
-}
-
 //===----------------------------------------------------------------------===//
 // AllocOp / AllocaOp
 //===----------------------------------------------------------------------===//
 
 template <typename AllocLikeOp>
 static LogicalResult verifyAllocLikeOp(AllocLikeOp op) {
   static_assert(llvm::is_one_of<AllocLikeOp, AllocOp, AllocaOp>::value,
                 "applies to only alloc or alloca");
static void print(OpAsmPrinter &p, MemRefReinterpretCastOp op) {
   p << ", sizes: ";
   printListOfOperandsOrIntegers(p, op.sizes(), op.static_sizes(),
                                 ShapedType::isDynamic);
   p << ", strides: ";
   printListOfOperandsOrIntegers(p, op.strides(), op.static_strides(),
                                 ShapedType::isDynamicStrideOrOffset);
   p.printOptionalAttrDict(
       op.getAttrs(),
-      /*elidedAttrs=*/{MemRefReinterpretCastOp::getOperandSegmentSizeAttr(),
-                       MemRefReinterpretCastOp::getStaticOffsetsAttrName(),
-                       MemRefReinterpretCastOp::getStaticSizesAttrName(),
-                       MemRefReinterpretCastOp::getStaticStridesAttrName()});
+      /*elidedAttrs=*/MemRefReinterpretCastOp::getSpecialAttrNames());
   p << ": " << op.source().getType() << " to " << op.getType();
 }
 
 /// Parse of the form:
 /// ```
 ///   `name` ssa-name to
 ///       offset: `[` offset `]`
 ///       sizes: `[` size-list `]`
 ///       strides:`[` stride-list `]`
 ///   `:` any-memref-type to strided-memref-type
 /// ```
 static ParseResult parseMemRefReinterpretCastOp(OpAsmParser &parser,
                                                 OperationState &result) {
   // Parse `operand` and `offset`.
   OpAsmParser::OperandType operand;
   if (parser.parseOperand(operand))
     return failure();
 
   // Parse offset.
   SmallVector<OpAsmParser::OperandType, 1> offset;
   if (parser.parseKeyword("to") || parser.parseKeyword("offset") ||
       parser.parseColon() ||
       parseListOfOperandsOrIntegers(
-          parser, result, MemRefReinterpretCastOp::getStaticOffsetsAttrName(),
+          parser, result,
+          OffsetSizeAndStrideOpInterface::getStaticOffsetsAttrName(),
           ShapedType::kDynamicStrideOrOffset, offset) ||
       parser.parseComma())
     return failure();
 
   // Parse `sizes`.
   SmallVector<OpAsmParser::OperandType, 4> sizes;
   if (parser.parseKeyword("sizes") || parser.parseColon() ||
       parseListOfOperandsOrIntegers(
-          parser, result, MemRefReinterpretCastOp::getStaticSizesAttrName(),
+          parser, result,
+          OffsetSizeAndStrideOpInterface::getStaticSizesAttrName(),
           ShapedType::kDynamicSize, sizes) ||
       parser.parseComma())
     return failure();
 
   // Parse `strides`.
   SmallVector<OpAsmParser::OperandType, 4> strides;
   if (parser.parseKeyword("strides") || parser.parseColon() ||
       parseListOfOperandsOrIntegers(
-          parser, result, MemRefReinterpretCastOp::getStaticStridesAttrName(),
+          parser, result,
+          OffsetSizeAndStrideOpInterface::getStaticStridesAttrName(),
           ShapedType::kDynamicStrideOrOffset, strides))
     return failure();
 
   // Handle segment sizes.
   auto b = parser.getBuilder();
   SmallVector<int, 4> segmentSizes = {1, static_cast<int>(offset.size()),
                                       static_cast<int>(sizes.size()),
                                       static_cast<int>(strides.size())};
static LogicalResult verify(MemRefReinterpretCastOp op) {
   auto resultType = op.getType().cast<MemRefType>();
   if (srcType.getMemorySpace() != resultType.getMemorySpace())
     return op.emitError("different memory spaces specified for source type ")
            << srcType << " and result memref type " << resultType;
   if (srcType.getElementType() != resultType.getElementType())
     return op.emitError("different element types specified for source type ")
            << srcType << " and result memref type " << resultType;
 
-  // Verify that dynamic and static offset/sizes/strides arguments/attributes
-  // are consistent.
-  if (failed(verifyOpWithOffsetSizesAndStridesPart(
-          op, "offset", 1, op.getStaticOffsetsAttrName(), op.static_offsets(),
-          ShapedType::isDynamicStrideOrOffset, op.offsets())))
-    return failure();
-  unsigned resultRank = op.getResultRank();
-  if (failed(verifyOpWithOffsetSizesAndStridesPart(
-          op, "size", resultRank, op.getStaticSizesAttrName(),
-          op.static_sizes(), ShapedType::isDynamic, op.sizes())))
-    return failure();
-  if (failed(verifyOpWithOffsetSizesAndStridesPart(
-          op, "stride", resultRank, op.getStaticStridesAttrName(),
-          op.static_strides(), ShapedType::isDynamicStrideOrOffset,
-          op.strides())))
-    return failure();
-
   // Match sizes in result memref type and in static_sizes attribute.
   for (auto &en :
        llvm::enumerate(llvm::zip(resultType.getShape(),
                                  extractFromI64ArrayAttr(op.static_sizes())))) {
     int64_t resultSize = std::get<0>(en.value());
     int64_t expectedSize = std::get<1>(en.value());
     if (resultSize != expectedSize)
       return op.emitError("expected result type with size = ")
static ParseResult parseOpWithOffsetsSizesAndStrides(
   SmallVector<OpAsmParser::OperandType, 4> offsetsInfo, sizesInfo, stridesInfo;
   auto indexType = parser.getBuilder().getIndexType();
   Type srcType, dstType;
   if (parser.parseOperand(srcInfo))
     return failure();
   if (parseExtraOperand && parseExtraOperand(parser, dstInfo))
     return failure();
   if (parseListOfOperandsOrIntegers(
-          parser, result, OpType::getStaticOffsetsAttrName(),
+          parser, result,
+          OffsetSizeAndStrideOpInterface::getStaticOffsetsAttrName(),
           ShapedType::kDynamicStrideOrOffset, offsetsInfo) ||
-      parseListOfOperandsOrIntegers(parser, result,
-                                    OpType::getStaticSizesAttrName(),
-                                    ShapedType::kDynamicSize, sizesInfo) ||
+      parseListOfOperandsOrIntegers(
+          parser, result,
+          OffsetSizeAndStrideOpInterface::getStaticSizesAttrName(),
       parseListOfOperandsOrIntegers(
-          parser, result, OpType::getStaticStridesAttrName(),
+          parser, result,
+          OffsetSizeAndStrideOpInterface::getStaticStridesAttrName(),
           ShapedType::kDynamicStrideOrOffset, stridesInfo))
     return failure();
 
   // Handle segment sizes.
   auto b = parser.getBuilder();
   SmallVector<int, 4> segmentSizes = {1, static_cast<int>(offsetsInfo.size()),
                                       static_cast<int>(sizesInfo.size()),
                                       static_cast<int>(stridesInfo.size())};
static LogicalResult produceSubViewErrorMsg(SubViewVerificationResult result,
   case SubViewVerificationResult::AffineMapMismatch:
     return op.emitError("expected result type to be ")
            << expectedType
            << " or a rank-reduced version. (mismatch of result affine map)";
   }
   llvm_unreachable("unexpected subview verification result");
 }
 
-
 /// Verifier for SubViewOp.
 static LogicalResult verify(SubViewOp op) {
   MemRefType baseType = op.getSourceType();
   MemRefType subViewType = op.getType();
 
   // The base memref and the view memref should be in the same memory space.
   if (baseType.getMemorySpace() != subViewType.getMemorySpace())
     return op.emitError("different memory spaces specified for base memref "
                         "type ")
            << baseType << " and subview memref type " << subViewType;
 
   // Verify that the base memref type has a strided layout map.
   if (!isStrided(baseType))
     return op.emitError("base type ") << baseType << " is not strided";
 
-  if (failed(verifyOpWithOffsetSizesAndStrides(op)))
-    return failure();
-
   // Verify result type against inferred type.
   auto expectedType = SubViewOp::inferResultType(
       baseType, extractFromI64ArrayAttr(op.static_offsets()),
       extractFromI64ArrayAttr(op.static_sizes()),
       extractFromI64ArrayAttr(op.static_strides()));
 
   auto result = isRankReducedType(expectedType, subViewType);
   return produceSubViewErrorMsg(result, op, expectedType);
 }
 
 raw_ostream &mlir::operator<<(raw_ostream &os, Range &range) {
   return os << "range " << range.offset << ":" << range.size << ":"
             << range.stride;
 }
 
 /// Return the list of Range (i.e. offset, size, stride). Each Range
 /// entry contains either the dynamic value or a ConstantIndexOp constructed
 /// with `b` at location `loc`.
-template <typename OpType>
-static SmallVector<Range, 8> getOrCreateRangesImpl(OpType op, OpBuilder &b,
-                                                   Location loc) {
+SmallVector<Range, 8> mlir::getOrCreateRanges(OffsetSizeAndStrideOpInterface op,
+                                              OpBuilder &b, Location loc) {
+  std::array<unsigned, 3> ranks = op.getArrayAttrRanks();
+  assert(ranks[0] == ranks[1] && "expected offset and sizes of equal ranks");
+  assert(ranks[1] == ranks[2] && "expected sizes and strides of equal ranks");
   SmallVector<Range, 8> res;
-  unsigned rank = op.getSourceRank();
+  unsigned rank = ranks[0];
   res.reserve(rank);
   for (unsigned idx = 0; idx < rank; ++idx) {
     Value offset =
         op.isDynamicOffset(idx)
             ? op.getDynamicOffset(idx)
             : b.create<ConstantIndexOp>(loc, op.getStaticOffset(idx));
     Value size = op.isDynamicSize(idx)
                      ? op.getDynamicSize(idx)
                      : b.create<ConstantIndexOp>(loc, op.getStaticSize(idx));
     Value stride =
         op.isDynamicStride(idx)
             ? op.getDynamicStride(idx)
             : b.create<ConstantIndexOp>(loc, op.getStaticStride(idx));
     res.emplace_back(Range{offset, size, stride});
   }
   return res;
 }
 
-SmallVector<Range, 8> SubViewOp::getOrCreateRanges(OpBuilder &b, Location loc) {
-  return ::getOrCreateRangesImpl(*this, b, loc);
-}
-
 namespace {
 
 /// Take a list of `values` with potential new constant to extract and a list
 /// of `constantValues` with`values.size()` sentinel that evaluate to true by
 /// applying `isDynamic`.
 /// Detects the `values` produced by a ConstantIndexOp and places the new
 /// constant in place of the corresponding sentinel value.
 void canonicalizeSubViewPart(SmallVectorImpl<Value> &values,
if (llvm::none_of(op.getOperands(), [](Value operand) {
         }))
       return failure();
 
     // At least one of offsets/sizes/strides is a new constant.
     // Form the new list of operands and constant attributes from the existing.
     SmallVector<Value, 8> newOffsets(op.offsets());
     SmallVector<int64_t, 8> newStaticOffsets =
         extractFromI64ArrayAttr(op.static_offsets());
-    assert(newStaticOffsets.size() == op.getSourceRank());
+    std::array<unsigned, 3> ranks = op.getArrayAttrRanks();
+    (void)ranks;
+    assert(newStaticOffsets.size() == ranks[0]);
     canonicalizeSubViewPart(newOffsets, newStaticOffsets,
                             ShapedType::isDynamicStrideOrOffset);
 
     SmallVector<Value, 8> newSizes(op.sizes());
     SmallVector<int64_t, 8> newStaticSizes =
         extractFromI64ArrayAttr(op.static_sizes());
-    assert(newStaticOffsets.size() == op.getSourceRank());
+    assert(newStaticSizes.size() == ranks[1]);
     canonicalizeSubViewPart(newSizes, newStaticSizes, ShapedType::isDynamic);
 
     SmallVector<Value, 8> newStrides(op.strides());
     SmallVector<int64_t, 8> newStaticStrides =
         extractFromI64ArrayAttr(op.static_strides());
-    assert(newStaticOffsets.size() == op.getSourceRank());
+    assert(newStaticStrides.size() == ranks[2]);
     canonicalizeSubViewPart(newStrides, newStaticStrides,
                             ShapedType::isDynamicStrideOrOffset);
 
     // Create the new op in canonical form.
     auto newOp = rewriter.create<OpType>(
         op.getLoc(), op.source(), newStaticOffsets, newStaticSizes,
         newStaticStrides, newOffsets, newSizes, newStrides);
 

 
 void SubViewOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                             MLIRContext *context) {
   results.insert<OpWithOffsetSizesAndStridesConstantArgumentFolder<SubViewOp>,
                  SubViewOpMemRefCastFolder>(context);
 }
 
 OpFoldResult SubViewOp::fold(ArrayRef<Attribute> operands) {
-  if (getResultRank() == 0 && getSourceRank() == 0)
+  if (getResult().getType().cast<ShapedType>().getRank() == 0 &&
+      source().getType().cast<ShapedType>().getRank() == 0)
     return getViewSource();
 
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // SubTensorOp
 //===----------------------------------------------------------------------===//
SmallVector<int64_t, 4> staticOffsetsVector(
       rank, ShapedType::kDynamicStrideOrOffset);
   SmallVector<int64_t, 4> staticSizesVector(rank, ShapedType::kDynamicSize);
   SmallVector<int64_t, 4> staticStridesVector(
       rank, ShapedType::kDynamicStrideOrOffset);
   build(b, result, source, staticOffsetsVector, staticSizesVector,
         staticStridesVector, offsets, sizes, strides, attrs);
 }
 
-SmallVector<Range, 8> SubTensorOp::getOrCreateRanges(OpBuilder &b,
-                                                     Location loc) {
-  return ::getOrCreateRangesImpl(*this, b, loc);
-}
-
 /// Verifier for SubTensorOp.
 static LogicalResult verify(SubTensorOp op) {
-  if (failed(verifyOpWithOffsetSizesAndStrides(op)))
-    return failure();
-
   // Verify result type against inferred type.
   auto expectedType = SubTensorOp::inferResultType(
       op.getSourceType(), extractFromI64ArrayAttr(op.static_offsets()),
       extractFromI64ArrayAttr(op.static_sizes()),
       extractFromI64ArrayAttr(op.static_strides()));
   auto result = isRankReducedType(expectedType, op.getType());
   return produceSubViewErrorMsg(result, op, expectedType);
 }
SmallVector<int64_t, 4> staticOffsetsVector(
       rank, ShapedType::kDynamicStrideOrOffset);
   SmallVector<int64_t, 4> staticSizesVector(rank, ShapedType::kDynamicSize);
   SmallVector<int64_t, 4> staticStridesVector(
       rank, ShapedType::kDynamicStrideOrOffset);
   build(b, result, source, dest, staticOffsetsVector, staticSizesVector,
         staticStridesVector, offsets, sizes, strides, attrs);
 }
 
-SmallVector<Range, 8> SubTensorInsertOp::getOrCreateRanges(OpBuilder &b,
-                                                           Location loc) {
-  return ::getOrCreateRangesImpl(*this, b, loc);
-}
-
 /// Verifier for SubViewOp.
 static LogicalResult verify(SubTensorInsertOp op) {
-  if (failed(verifyOpWithOffsetSizesAndStrides(op)))
-    return failure();
   if (op.getType() != op.dest().getType())
     return op.emitError("expected result type to be ") << op.dest().getType();
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TensorCastOp
 //===----------------------------------------------------------------------===//

mlir/lib/Interfaces/ViewLikeInterface.cpp

 //===- ViewLikeInterface.cpp - View-like operations in MLIR ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Interfaces/ViewLikeInterface.h"
 
+#include "mlir/IR/StandardTypes.h"
+
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // ViewLike Interfaces
 //===----------------------------------------------------------------------===//
 
 /// Include the definitions of the loop-like interfaces.
 #include "mlir/Interfaces/ViewLikeInterface.cpp.inc"
+
+static LogicalResult verifyOpWithOffsetSizesAndStridesPart(
+    OffsetSizeAndStrideOpInterface op, StringRef name,
+    unsigned expectedNumElements, StringRef attrName, ArrayAttr attr,
+    llvm::function_ref<bool(int64_t)> isDynamic, ValueRange values) {
+  /// Check static and dynamic offsets/sizes/strides breakdown.
+  if (attr.size() != expectedNumElements)
+    return op.emitError("expected ")
+           << expectedNumElements << " " << name << " values";
+  unsigned expectedNumDynamicEntries =
+      llvm::count_if(attr.getValue(), [&](Attribute attr) {
+        return isDynamic(attr.cast<IntegerAttr>().getInt());
+      });
+  if (values.size() != expectedNumDynamicEntries)
+    return op.emitError("expected ")
+           << expectedNumDynamicEntries << " dynamic " << name << " values";
+  return success();
+}
+
+LogicalResult mlir::verify(OffsetSizeAndStrideOpInterface op) {
+  std::array<unsigned, 3> ranks = op.getArrayAttrRanks();
+  if (failed(verifyOpWithOffsetSizesAndStridesPart(
+          op, "offset", ranks[0],
+          OffsetSizeAndStrideOpInterface::getStaticOffsetsAttrName(),
+          op.static_offsets(), ShapedType::isDynamicStrideOrOffset,
+          op.offsets())))
+    return failure();
+  if (failed(verifyOpWithOffsetSizesAndStridesPart(
+          op, "size", ranks[1],
+          OffsetSizeAndStrideOpInterface::getStaticSizesAttrName(),
+          op.static_sizes(), ShapedType::isDynamic, op.sizes())))
+    return failure();
+  if (failed(verifyOpWithOffsetSizesAndStridesPart(
+          op, "stride", ranks[2],
+          OffsetSizeAndStrideOpInterface::getStaticStridesAttrName(),
+          op.static_strides(), ShapedType::isDynamicStrideOrOffset,
+          op.strides())))
+    return failure();
+  return success();
+}

mlir/test/IR/invalid-ops.mlir

func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<8x16x4xf32, offset: 0, strides: [64, 4, 1], 2>
   // expected-error@+1 {{different memory spaces}}
-  %1 = subview %0[0, 0, 0][%arg2][1, 1, 1]
+  %1 = subview %0[0, 0, 0][%arg2, %arg2, %arg2][1, 1, 1]
     : memref<8x16x4xf32, offset: 0, strides: [64, 4, 1], 2> to
       memref<8x?x4xf32, affine_map<(d0, d1, d2)[s0] -> (d0 * s0 + d1 * 4 + d2)>>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 + d1, d1 + d2, d2)>>
   // expected-error@+1 {{is not strided}}
-  %1 = subview %0[0, 0, 0][%arg2][1, 1, 1]
+  %1 = subview %0[0, 0, 0][%arg2, %arg2, %arg2][1, 1, 1]
     : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 + d1, d1 + d2, d2)>> to
       memref<8x?x4xf32, offset: 0, strides: [?, 4, 1]>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {