[mlir][Interfaces] Extract MixedOffsetsOpInterface from OffsetSizeAndStrideOpInterface

[springerm]

Summary

This revision splits OffsetSizeAndStrideOpInterface into two interfaces: OffsetSizeAndStrideOpInterface and MixedOffsetsOpInterface. The latter interface can be implemented by ops that have indices/offsets but not sizes or strides.

Depends On: D156871

[mravishankar]

Does the new interface have to be offsets? It could be any mixed static/dynamic set of indices? Maybe the interfaces name should not be tied to offsets?

[dcaballe]

Thanks, Matthias! LGTM

In D156899#4554217, @mravishankar wrote:

Does the new interface have to be offsets? It could be any mixed static/dynamic set of indices? Maybe the interfaces name should not be tied to offsets?

I think the problem is that offsets, sizes and strides have basically the same API with a different name so if we make one generic it' won't be clear what it refers to in ops that have the three. Perhaps a follow up step would be to refactor these interfaces into a generic one that allows an arbitrary number of mixed type operands. The API methods would be more generic but it would allows to use it for cases that are not offsets, sizes and strides.

There's also the question of why we need these interfaces altogether when we could represent constant indices with constant ops, but that's a separate discussion :)

[springerm]

I think the problem is that offsets, sizes and strides have basically the same API with a different name

exactly that’s the reason. the existing interface uses the term “offsets” and i wanted to use interface inheritance to avoid code duplication.

[mravishankar]

In D156899#4554554, @springerm wrote:

I think the problem is that offsets, sizes and strides have basically the same API with a different name

exactly that’s the reason. the existing interface uses the term “offsets” and i wanted to use interface inheritance to avoid code duplication.

I see what you are saying, but I am echoing what Diego is saying. We should have one interface that allows representing a list of mixed constant and dynamic values. Then the offsets, sizes and strides, uses that interface. This inheritance is kind of strange. Anyway, removing my blocker here.

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

let extraClassDeclaration = extraBaseClassDeclaration # [{
     // Return the expected size of each of the `static_offsets`, `static_sizes`
     // and `static_strides` attributes.
     int64_t getOffsetsRank() { return 1; }
     int64_t getSizesRank() { return getType().getRank(); }
     int64_t getStridesRank() { return getType().getRank(); }
 
     /// Return the number of leading operands before the `offsets`, `sizes` and
     /// and `strides` operands.
-    static unsigned getOffsetSizeAndStrideStartOperandIndex() { return 1; }
+    static unsigned getOffsetsOperandIndex() { return 1; }
 
     /// Return a vector of all the static or dynamic sizes of the op, while
     /// statically inferring the sizes of the dynamic sizes, when possible.
     /// This is best effort.
     /// E.g., if `getMixedSizes` returns `[2, %dyn_size]`, but the resulting
     /// memref type is `memref<2x8xi16>`, this method will return `[2, 8]`.
     /// Similarly if the resulting memref type is `memref<2x?xi16>`, but
     /// `%dyn_size` can statically be pinned to a constant value, this
let extraClassDeclaration = extraBaseClassDeclaration # [{
     static Type inferRankReducedResultType(ArrayRef<int64_t> resultShape,
                                            MemRefType sourceMemRefType,
                                            ArrayRef<OpFoldResult> staticOffsets,
                                            ArrayRef<OpFoldResult> staticSizes,
                                            ArrayRef<OpFoldResult> staticStrides);
 
     /// Return the number of leading operands before the `offsets`, `sizes` and
     /// and `strides` operands.
-    static unsigned getOffsetSizeAndStrideStartOperandIndex() { return 1; }
+    static unsigned getOffsetsOperandIndex() { return 1; }
 
     /// Return the dimensions of the source type that are dropped when
     /// the result is rank-reduced.
     llvm::SmallBitVector getDroppedDims();
 
     /// Given a `value`, asserted to be of MemRefType, build a SubViewOp that
     /// results in a rank reduction to the desired memref shape and return the
     /// new value created.

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

let extraClassDeclaration = extraBaseClassDeclaration # [{
     // Return the expected size of each of the `static_offsets`, `static_sizes`
     // and `static_strides` attributes.
     int64_t getOffsetsRank() { return getSourceType().getRank(); }
     int64_t getSizesRank() { return getSourceType().getRank(); }
     int64_t getStridesRank() { return getSourceType().getRank(); }
 
     /// Return the number of leading operands before the `offsets`, `sizes` and
     /// and `strides` operands.
-    static unsigned getOffsetSizeAndStrideStartOperandIndex() { return 1; }
+    static unsigned getOffsetsOperandIndex() { return 1; }
 
     /// Return the dimensions of the source that are dropped in the
     /// result when the result is rank-reduced.
     llvm::SmallBitVector getDroppedDims();
 
     /// Given a `value`, asserted to be of RankedTensorType, build an
     /// ExtractSliceOp that results in a rank-reducing extract to the desired
     /// tensor shape and return the new value created.
let extraClassDeclaration = extraBaseClassDeclaration # [{
     int64_t getStridesRank() { return getDestType().getRank(); }
 
     /// Return the dimensions of the dest that are omitted to insert a source
     /// when the result is rank-extended.
     llvm::SmallBitVector getDroppedDims();
 
     /// Return the number of leading operands before the `offsets`, `sizes` and
     /// and `strides` operands.
-    static unsigned getOffsetSizeAndStrideStartOperandIndex() { return 2; }
+    static unsigned getOffsetsOperandIndex() { return 2; }
 
     std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
       return {1, 2};  // `dest` operand
     }
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
let extraClassDeclaration = [{
     // Return the expected size of each of the `static_offsets`, `static_sizes`
     // and `static_strides` attributes.
     int64_t getOffsetsRank() { return getDestType().getRank(); }
     int64_t getSizesRank() { return getDestType().getRank(); }
     int64_t getStridesRank() { return getDestType().getRank(); }
 
     /// Return the number of leading operands before `offsets`, `sizes` and
     /// `strides` operands.
-    static unsigned getOffsetSizeAndStrideStartOperandIndex() { return 1; }
+    static unsigned getOffsetsOperandIndex() { return 1; }
 
     /// Return the OpResult of the enclosing ForallOp that is
     /// corresponding to this ParallelInsertSliceOp.
     OpResult getTiedOpResult();
 
     /// Return the dimensions of the dest that are omitted to insert a source
     /// when the result is rank-extended.
     llvm::SmallBitVector getDroppedDims();

mlir/include/mlir/Interfaces/ViewLikeInterface.h

 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 
 class OffsetSizeAndStrideOpInterface;
+class MixedOffsetsOpInterface;
 
 namespace detail {
 
+/// Verifier for `OffsetSizeAndStrideOpInterface`.
 LogicalResult verifyOffsetSizeAndStrideOp(OffsetSizeAndStrideOpInterface op);
 
+/// Verifier for `MixedOffsetsOpInterface`.
+LogicalResult verifyMixedOffsetsOp(MixedOffsetsOpInterface op);
+
 bool sameOffsetsSizesAndStrides(
     OffsetSizeAndStrideOpInterface a, OffsetSizeAndStrideOpInterface b,
     llvm::function_ref<bool(OpFoldResult, OpFoldResult)> cmp);
 
 /// Helper method to compute the number of dynamic entries of `staticVals`,
 /// up to `idx`.
 unsigned getNumDynamicEntriesUpToIdx(ArrayRef<int64_t> staticVals,
                                      unsigned idx);

mlir/include/mlir/Interfaces/ViewLikeInterface.td

def ViewLikeOpInterface : OpInterface<"ViewLikeOpInterface"> {
 
   let methods = [
     InterfaceMethod<
       "Returns the source buffer from which the view is created.",
       "::mlir::Value", "getViewSource">
   ];
 }
 
-def OffsetSizeAndStrideOpInterface : OpInterface<"OffsetSizeAndStrideOpInterface"> {
+def MixedOffsetsOpInterface : OpInterface<"MixedOffsetsOpInterface"> {
   let description = [{
     Common interface for ops that allow specifying mixed dynamic and static
-    offsets, sizes and strides variadic operands.
+    offsets.
+
     Ops that implement this interface need to expose the following methods:
-      1. `getOffsetSizeAndStrideRank` 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.
-      4. `getOffsetSizeAndStrideStartOperandIndex` method that specifies the
-         starting index of the OffsetSizeAndStrideOpInterface operands
+      1. `getOffsetsRank` specifies the number of offsets.
+      2. `getOffsets` returns the dynamic offsets.
+      3. `getStaticOffsets` return the static offsets.
+      4. `getOffsetsStartOperandIndex` specifies the starting index of the
+         `MixedOffsetsOpInterface` operands (dynamic offsets).
 
     The invariants of this interface are:
-      1. `static_offsets`, `static_sizes` and `static_strides` have a length of
-          exactly `getOffsetsRank`, `getSizesRank` and `getStridesRank`,
-          respectively.
-      2. `offsets`, `sizes` and `strides` have each length of at most
-         `getOffsetsRank`, `getSizesRank` and `getStridesRank`, respectively.
-      3. if an entry of `static_offsets` (resp. `static_sizes`,
-         `static_strides`) is equal to a special sentinel value, namely
-         `ShapedType::kDynamic`, 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).
-      5. `offsets`, `sizes` and `strides` operands are specified in this order
-         at operand index starting at `getOffsetSizeAndStrideStartOperandIndex`.
+      1. The array returned by `getStaticOffsets` has a size of exactly
+         `getOffsetsRank`.
+      2. The range returned by `getOffsets` has a size of at most
+         `getOffsetsRank`.
+      3. If an entry of `getStaticOffsets` is equal to a special sentinel value,
+         namely `ShapedType::kDynamic`, then the corresponding entry is a
+         dynamic offset.
+      4. A variadic `getOffsets` operand must be present for each dynamic
+         offset.
+      5. `getOffsets` operands are a consective block of operands with a
+         starting index of `getOffsetsOperandIndex`.
 
     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 = [
     StaticInterfaceMethod<
       /*desc=*/[{
         Return the number of leading operands before the `offsets`, `sizes` and
         and `strides` operands.
       }],
       /*retTy=*/"unsigned",
-      /*methodName=*/"getOffsetSizeAndStrideStartOperandIndex",
+      /*methodName=*/"getOffsetsOperandIndex",
       /*args=*/(ins)
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the expected size of the `static_offsets` attribute.
       }],
       /*retTy=*/"int64_t",
       /*methodName=*/"getOffsetsRank",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         FailureOr<int64_t> rank = ::mlir::detail::defaultArrayRank($_op);
         if (succeeded(rank))
           return *rank;
         llvm_unreachable("getOffsetsRank not implemented");
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
-        Return the expected size of the `static_sizes` attribute.
+        Return the dynamic offset operands.
+      }],
+      /*retTy=*/"::mlir::OperandRange",
+      /*methodName=*/"getOffsets",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.getOffsets();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the static offset attributes.
+      }],
+      /*retTy=*/"::llvm::ArrayRef<int64_t>",
+      /*methodName=*/"getStaticOffsets",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.getStaticOffsets();
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return a vector of all the static or dynamic sizes of the op.
+      }],
+      /*retTy=*/"::llvm::SmallVector<::mlir::OpFoldResult, 4>",
+      /*methodName=*/"getMixedOffsets",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        Builder b($_op->getContext());
+        return ::mlir::getMixedValues($_op.getStaticOffsets(),
+                                      $_op.getOffsets(), b);
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/"Return true if the offset `idx` is dynamic.",
+      /*retTy=*/"bool",
+      /*methodName=*/"isDynamicOffset",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return ::mlir::ShapedType::isDynamic(getStaticOffsets()[idx]);
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the offset `idx` is a static constant and return its value.
       }],
       /*retTy=*/"int64_t",
-      /*methodName=*/"getSizesRank",
+      /*methodName=*/"getStaticOffset",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        assert(!$_op.isDynamicOffset(idx) && "expected static offset");
+        return getStaticOffsets()[idx];
+      }]
+    >,
+    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 = ::mlir::detail::getNumDynamicEntriesUpToIdx(
+          getStaticOffsets(), idx);
+        return $_op.getOffsetsOperandIndex() + numDynamic;
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Assert the offset `idx` is dynamic and return its value.
+      }],
+      /*retTy=*/"::mlir::Value",
+      /*methodName=*/"getDynamicOffset",
+      /*args=*/(ins "unsigned":$idx),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.getOperand(getIndexOfDynamicOffset(idx));
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/[{ Return true if all offsets are guaranteed to be 0. }],
+      /*retTy=*/"bool",
+      /*methodName=*/"hasZeroOffset",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        FailureOr<int64_t> rank = ::mlir::detail::defaultArrayRank($_op);
-        if (succeeded(rank))
-          return *rank;
-        llvm_unreachable("getOffsetsRank not implemented");
+        return ::llvm::all_of(getMixedOffsets(), [](::mlir::OpFoldResult ofr) {
+          return ::mlir::getConstantIntValue(ofr) == static_cast<int64_t>(0);
+        });
       }]
     >,
+  ];
+
+  let verify = [{
+    return ::mlir::detail::verifyMixedOffsetsOp(
+        ::mlir::cast<::mlir::MixedOffsetsOpInterface>($_op));
+  }];
+}
+
+def OffsetSizeAndStrideOpInterface
+    : OpInterface<"OffsetSizeAndStrideOpInterface", [MixedOffsetsOpInterface]> {
+  let description = [{
+    Common interface for ops that allow specifying mixed dynamic and static
+    offsets, sizes and strides variadic operands. This interface inherits from
+    `MixedOffsetOpInterface`.
+
+    Ops that implement this interface need to expose the following methods:
+      1. `getOffsetsRank`, `getSizesRank` and `getStridesRank` specify the
+         number of offsets, sizes and strides.
+      2. `getOffsets`, `getSizes` and `getStrides` returns the dynamic offsets,
+         sizes and strides.
+      3. `getStaticOffsets`, `getStaticSizes` and `getStaticStrides` return the
+         static offsets, sizes and strides.
+      4. `getOffsetsStartOperandIndex` specifies the starting index of the
+         `OffsetSizeAndStrideOpInterface` operands (dynamic offsets, sizes and
+         strides).
+
+    The invariants of this interface are:
+      1. The arrays returned by `getStaticOffsets`, `getStaticSizes` and
+         `getStaticStrides` have a size of exactly `getOffsetsRank`,
+         `getSizesRank` and `getStridesRank`.
+      2. The ranges returned by `getOffsets`, `getSizes` and `getStrides` have
+         a size of at most `getOffsetsRank`, `getSizesRank` and
+         `getStridesRank`.
+      3. If an entry of `getStaticOffsets`, `getStaticSizes` or
+        `getStaticStrides` is equal to a special sentinel value, namely
+        `ShapedType::kDynamic`, then the corresponding entry is a dynamic
+         offset, size or stride.
+      4. A variadic `getOffsets`, `getSizes` or `getStrides` operand must be
+         present for each dynamic offset, size or stride.
+      5. `getOffsets`, `getSizes` and `getStrides` operands are a consective
+         block of operands with a starting index of `getOffsetsOperandIndex`.
+
+    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 size of the `static_strides` attribute.
+        Return the expected size of the `static_sizes` attribute.
       }],
       /*retTy=*/"int64_t",
-      /*methodName=*/"getStridesRank",
+      /*methodName=*/"getSizesRank",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         FailureOr<int64_t> rank = ::mlir::detail::defaultArrayRank($_op);
         if (succeeded(rank))
           return *rank;
         llvm_unreachable("getOffsetsRank not implemented");
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
-        Return the dynamic offset operands.
+        Return the expected size of the `static_strides` attribute.
       }],
-      /*retTy=*/"::mlir::OperandRange",
-      /*methodName=*/"getOffsets",
+      /*retTy=*/"int64_t",
+      /*methodName=*/"getStridesRank",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return $_op.getOffsets();
+        FailureOr<int64_t> rank = ::mlir::detail::defaultArrayRank($_op);
+        if (succeeded(rank))
+          return *rank;
+        llvm_unreachable("getOffsetsRank not implemented");
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the dynamic size operands.
       }],
       /*retTy=*/"::mlir::OperandRange",
       /*methodName=*/"getSizes",
InterfaceMethod<
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getStrides();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
-        Return the static offset attributes.
-      }],
-      /*retTy=*/"::llvm::ArrayRef<int64_t>",
-      /*methodName=*/"getStaticOffsets",
-      /*args=*/(ins),
-      /*methodBody=*/"",
-      /*defaultImplementation=*/[{
-        return $_op.getStaticOffsets();
-      }]
-    >,
-    InterfaceMethod<
-      /*desc=*/[{
         Return the static size attributes.
       }],
       /*retTy=*/"::llvm::ArrayRef<int64_t>",
       /*methodName=*/"getStaticSizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getStaticSizes();
InterfaceMethod<
         return $_op.getStaticStrides();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic sizes of the op.
       }],
       /*retTy=*/"::llvm::SmallVector<::mlir::OpFoldResult, 4>",
-      /*methodName=*/"getMixedOffsets",
-      /*args=*/(ins),
-      /*methodBody=*/"",
-      /*defaultImplementation=*/[{
-        Builder b($_op->getContext());
-        return ::mlir::getMixedValues($_op.getStaticOffsets(),
-                                      $_op.getOffsets(), b);
-      }]
-    >,
-    InterfaceMethod<
-      /*desc=*/[{
-        Return a vector of all the static or dynamic sizes of the op.
-      }],
-      /*retTy=*/"::llvm::SmallVector<::mlir::OpFoldResult, 4>",
       /*methodName=*/"getMixedSizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         Builder b($_op->getContext());
         return
             ::mlir::getMixedValues($_op.getStaticSizes(), $_op.getSizes(), b);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic strides of the op.
       }],
       /*retTy=*/"::llvm::SmallVector<::mlir::OpFoldResult, 4>",
       /*methodName=*/"getMixedStrides",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         Builder b($_op->getContext());
         return ::mlir::getMixedValues($_op.getStaticStrides(),
                                       $_op.getStrides(), b);
       }]
     >,
-
-    InterfaceMethod<
-      /*desc=*/"Return true if the offset `idx` is dynamic.",
-      /*retTy=*/"bool",
-      /*methodName=*/"isDynamicOffset",
-      /*args=*/(ins "unsigned":$idx),
-      /*methodBody=*/"",
-      /*defaultImplementation=*/[{
-        return ::mlir::ShapedType::isDynamic(getStaticOffsets()[idx]);
-      }]
-    >,
     InterfaceMethod<
       /*desc=*/"Return true if the size `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicSize",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return ::mlir::ShapedType::isDynamic(getStaticSizes()[idx]);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return true if the stride `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicStride",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return ::mlir::ShapedType::isDynamic(getStaticStrides()[idx]);
       }]
     >,
     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");
-        return getStaticOffsets()[idx];
-      }]
-    >,
-    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");
         return getStaticSizes()[idx];
       }]
     >,
     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");
         return getStaticStrides()[idx];
       }]
     >,
-
-    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 = ::mlir::detail::getNumDynamicEntriesUpToIdx(
-          getStaticOffsets(), idx);
-        return $_op.getOffsetSizeAndStrideStartOperandIndex() + 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 = ::mlir::detail::getNumDynamicEntriesUpToIdx(
           getStaticSizes(), idx);
-        return $_op.getOffsetSizeAndStrideStartOperandIndex() +
-          getOffsets().size() + numDynamic;
+        return $_op.getOffsetsOperandIndex() + $_op.getOffsets().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 = ::mlir::detail::getNumDynamicEntriesUpToIdx(
           getStaticStrides(), idx);
-        return $_op.getOffsetSizeAndStrideStartOperandIndex() +
-          getOffsets().size() + getSizes().size() + numDynamic;
-      }]
-    >,
-    InterfaceMethod<
-      /*desc=*/[{
-        Assert the offset `idx` is dynamic and return its value.
-      }],
-      /*retTy=*/"::mlir::Value",
-      /*methodName=*/"getDynamicOffset",
-      /*args=*/(ins "unsigned":$idx),
-      /*methodBody=*/"",
-      /*defaultImplementation=*/[{
-        return $_op.getOperand(getIndexOfDynamicOffset(idx));
+        return $_op.getOffsetsOperandIndex() +
+            $_op.getOffsets().size() + getSizes().size() + numDynamic;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the size `idx` is dynamic and return its value.
       }],
       /*retTy=*/"::mlir::Value",
       /*methodName=*/"getDynamicSize",
InterfaceMethod<
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return ::llvm::all_of(getMixedStrides(), [](::mlir::OpFoldResult ofr) {
           return ::mlir::getConstantIntValue(ofr) == static_cast<int64_t>(1);
         });
       }]
     >,
-    InterfaceMethod<
-      /*desc=*/[{ Return true if all offsets are guaranteed to be 0. }],
-      /*retTy=*/"bool",
-      /*methodName=*/"hasZeroOffset",
-      /*args=*/(ins),
-      /*methodBody=*/"",
-      /*defaultImplementation=*/[{
-        return ::llvm::all_of(getMixedOffsets(), [](::mlir::OpFoldResult ofr) {
-          return ::mlir::getConstantIntValue(ofr) == static_cast<int64_t>(0);
-        });
-      }]
-    >,
   ];
 
   let verify = [{
     return ::mlir::detail::verifyOffsetSizeAndStrideOp(
         ::mlir::cast<::mlir::OffsetSizeAndStrideOpInterface>($_op));
   }];
 }
 
 #endif // MLIR_INTERFACES_VIEWLIKEINTERFACE

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

isSubsetLocationLoopInvariant(scf::ForOp forOp,
   return true;
 }
 
 /// Return true if the location of the subset defined by the op is invariant of
 /// the loop iteration.
 static bool isSubsetLocationLoopInvariant(scf::ForOp forOp,
                                           tensor::InsertSliceOp insertSliceOp) {
   for (Value operand : insertSliceOp->getOperands().drop_front(
-           tensor::InsertSliceOp::getOffsetSizeAndStrideStartOperandIndex()))
+           tensor::InsertSliceOp::getOffsetsOperandIndex()))
     if (!forOp.isDefinedOutsideOfLoop(operand))
       return false;
   return true;
 }
 
 /// Given an `srcTensor` that is a block argument belong to a loop.
 /// Greedily look for the first read that can be hoisted out of the loop (i.e.
 /// that satisfied the conditions):

mlir/lib/Interfaces/ViewLikeInterface.cpp

unsigned expectedNumDynamicEntries =
         return ShapedType::isDynamic(staticVal);
       });
   if (values.size() != expectedNumDynamicEntries)
     return op->emitError("expected ")
            << expectedNumDynamicEntries << " dynamic " << name << " values";
   return success();
 }
 
+LogicalResult mlir::detail::verifyMixedOffsetsOp(MixedOffsetsOpInterface op) {
+  return verifyListOfOperandsOrIntegers(op, "offset", op.getOffsetsRank(),
+                                        op.getStaticOffsets(), op.getOffsets());
+}
+
 LogicalResult
 mlir::detail::verifyOffsetSizeAndStrideOp(OffsetSizeAndStrideOpInterface op) {
   // Offsets can come in 2 flavors:
   //   1. Either single entry (when getOffsetsRank() == 1).
   //   2. Or as an array whose rank must match that of the mixed sizes.
   // So that the result type is well-formed.
   if (!(op.getMixedOffsets().size() == 1 &&
         op.getOffsetsRank() == 1) && // NOLINT
       op.getMixedOffsets().size() != op.getMixedSizes().size())
     return op->emitError(
                "expected mixed offsets rank to match mixed sizes rank (")
            << op.getMixedOffsets().size() << " vs " << op.getMixedSizes().size()
            << ") so the rank of the result type is well-formed.";
   // Ranks of mixed sizes and strides must always match so the result type is
   // well-formed.
   if (op.getMixedSizes().size() != op.getMixedStrides().size())
     return op->emitError(
                "expected mixed sizes rank to match mixed strides rank (")
            << op.getMixedSizes().size() << " vs " << op.getMixedStrides().size()
            << ") so the rank of the result type is well-formed.";
 
-  if (failed(verifyListOfOperandsOrIntegers(op, "offset", op.getOffsetsRank(),
-                                            op.getStaticOffsets(),
-                                            op.getOffsets())))
+  if (failed(verifyMixedOffsetsOp(
+          cast<MixedOffsetsOpInterface>(op.getOperation()))))
     return failure();
   if (failed(verifyListOfOperandsOrIntegers(
           op, "size", op.getSizesRank(), op.getStaticSizes(), op.getSizes())))
     return failure();
   if (failed(verifyListOfOperandsOrIntegers(op, "stride", op.getStridesRank(),
                                             op.getStaticStrides(),
                                             op.getStrides())))
     return failure();