[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
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:
 
def SubViewOp : BaseOpWithOffsetSizesAndStrides<
   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.
def SubTensorOp : BaseOpWithOffsetSizesAndStrides<"subtensor", [OffsetSizeAndStrideOpInterface]> {
 
   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`.

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 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;
+};
+} // 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 = [{
+    OffsetSizeAndStrideOpInterface
+  }];
+  let cppNamespace = "::mlir";
+  let methods = [
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the rankof the operation.
+      }],
+      /*retTy=*/"unsigned",
+      /*methodName=*/"getRank",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.getSourceRank();
+      }]
+    >,
+    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 operands.
+      }],
+      /*retTy=*/"ArrayAttr",
+      /*methodName=*/"static_offsets",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.static_offsets();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the static size operands.
+      }],
+      /*retTy=*/"ArrayAttr",
+      /*methodName=*/"static_sizes",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.static_sizes();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the dynamic stride operands.
+      }],
+      /*retTy=*/"ArrayAttr",
+      /*methodName=*/"static_strides",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.static_strides();
+      }]
+    >,
+
+    InterfaceMethod<
+      /*desc=*/[{
+       Return true if the offset `idx` is a static constant.
+      }],
+      /*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 a static constant.
+      }],
+      /*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 a static constant.
+      }],
+      /*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=*/[{
+        Return the dynamic stride operands.
+      }],
+      /*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";
+    }
+  }];
+}
+
 #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

 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();
+static LogicalResult
+verifyOpWithOffsetSizesAndStrides(OffsetSizeAndStrideOpInterface op,
+                                  unsigned rank) {
   if (failed(verifyOpWithOffsetSizesAndStridesPart(
-          op, "offset", srcRank, op.getStaticOffsetsAttrName(),
+          op, "offset", rank,
+          OffsetSizeAndStrideOpInterface::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())))
+          op, "size", rank,
+          OffsetSizeAndStrideOpInterface::getStaticSizesAttrName(),
+          op.static_sizes(), ShapedType::isDynamic, op.sizes())))
     return failure();
   if (failed(verifyOpWithOffsetSizesAndStridesPart(
-          op, "stride", srcRank, op.getStaticStridesAttrName(),
+          op, "stride", rank,
+          OffsetSizeAndStrideOpInterface::getStaticStridesAttrName(),
           op.static_strides(), ShapedType::isDynamicStrideOrOffset,
           op.strides())))
     return failure();
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // AllocOp / AllocaOp
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())};
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())))
+          op, "offset", 1,
+          OffsetSizeAndStrideOpInterface::getStaticOffsetsAttrName(),
+          op.static_offsets(), ShapedType::isDynamicStrideOrOffset,
+          op.offsets())))
     return failure();
-  unsigned resultRank = op.getResultRank();
+  unsigned resultRank = op.getResult().getType().cast<ShapedType>().getRank();
   if (failed(verifyOpWithOffsetSizesAndStridesPart(
-          op, "size", resultRank, op.getStaticSizesAttrName(),
+          op, "size", resultRank,
+          OffsetSizeAndStrideOpInterface::getStaticSizesAttrName(),
           op.static_sizes(), ShapedType::isDynamic, op.sizes())))
     return failure();
   if (failed(verifyOpWithOffsetSizesAndStridesPart(
-          op, "stride", resultRank, op.getStaticStridesAttrName(),
+          op, "stride", resultRank,
+          OffsetSizeAndStrideOpInterface::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())))) {
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)))
+  if (failed(verifyOpWithOffsetSizesAndStrides(op, op.getSourceRank())))
     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) {
   SmallVector<Range, 8> res;
-  unsigned rank = op.getSourceRank();
+  unsigned rank = op.getRank();
   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,

 
 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)))
+  if (failed(verifyOpWithOffsetSizesAndStrides(op, op.getSourceRank())))
     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());
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)))
+  if (failed(verifyOpWithOffsetSizesAndStrides(op, op.getSourceRank())))
     return failure();
   if (op.getType() != op.dest().getType())
     return op.emitError("expected result type to be ") << op.dest().getType();
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TensorCastOp