[mlir][Interfaces][NFC] Delete dead code from OffsetSizeAndStrideOpInterface

[springerm]

Summary

Also make getNumDynamicEntriesUpToIdx a helper function. It does not have to be an interface method.

Depends On: D156857

[springerm]

update

mlir/include/mlir/Interfaces/ViewLikeInterface.h

 namespace detail {
 
 LogicalResult verifyOffsetSizeAndStrideOp(OffsetSizeAndStrideOpInterface 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);
+
 } // namespace detail
 } // namespace mlir
 
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/ViewLikeInterface.h.inc"
 
 namespace mlir {
 

mlir/include/mlir/Interfaces/ViewLikeInterface.td

InterfaceMethod<
         corresponding operand.
       }],
       /*retTy=*/"unsigned",
       /*methodName=*/"getIndexOfDynamicOffset",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert($_op.isDynamicOffset(idx) && "expected dynamic offset");
-        auto numDynamic = getNumDynamicEntriesUpToIdx(
-          getStaticOffsets(), ::mlir::ShapedType::isDynamic, idx);
+        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 = getNumDynamicEntriesUpToIdx(
-          getStaticSizes(), ::mlir::ShapedType::isDynamic, idx);
+        auto numDynamic = ::mlir::detail::getNumDynamicEntriesUpToIdx(
+          getStaticSizes(), idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() +
           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 = getNumDynamicEntriesUpToIdx(
-          getStaticStrides(), ::mlir::ShapedType::isDynamic, idx);
+        auto numDynamic = ::mlir::detail::getNumDynamicEntriesUpToIdx(
+          getStaticStrides(), idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() +
           getOffsets().size() + getSizes().size() + numDynamic;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
-        Helper method to compute the number of dynamic entries of `staticVals`,
-        up to `idx` using `isDynamic` to determine whether an entry is dynamic.
-      }],
-      /*retTy=*/"unsigned",
-      /*methodName=*/"getNumDynamicEntriesUpToIdx",
-      /*args=*/(ins "::llvm::ArrayRef<int64_t>":$staticVals,
-                    "::llvm::function_ref<bool(int64_t)>":$isDynamic,
-                    "unsigned":$idx),
-      /*methodBody=*/"",
-      /*defaultImplementation=*/[{
-        return std::count_if(
-          staticVals.begin(), staticVals.begin() + idx,
-          [&](int64_t val) {
-            return isDynamic(val);
-          });
-      }]
-    >,
-
-    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<
       /*defaultImplementation=*/[{
         return ::llvm::all_of(getMixedOffsets(), [](::mlir::OpFoldResult ofr) {
           return ::mlir::getConstantIntValue(ofr) == static_cast<int64_t>(0);
         });
       }]
     >,
   ];
 
-  let extraClassDeclaration = [{
-    static unsigned getOffsetOperandGroupPosition() { return 0; }
-    static unsigned getSizeOperandGroupPosition() { return 1; }
-    static unsigned getStrideOperandGroupPosition() { return 2; }
-    static ::llvm::StringRef getStaticOffsetsAttrName() {
-      return "static_offsets";
-    }
-    static ::llvm::StringRef getStaticSizesAttrName() {
-      return "static_sizes";
-    }
-    static ::llvm::StringRef getStaticStridesAttrName() {
-      return "static_strides";
-    }
-    static ::llvm::ArrayRef<::llvm::StringRef> getSpecialAttrNames() {
-      static ::llvm::SmallVector<::llvm::StringRef, 4> names{
-        ::mlir::OffsetSizeAndStrideOpInterface::getStaticOffsetsAttrName(),
-        ::mlir::OffsetSizeAndStrideOpInterface::getStaticSizesAttrName(),
-        ::mlir::OffsetSizeAndStrideOpInterface::getStaticStridesAttrName(),
-        ::mlir::OpTrait::AttrSizedOperandSegments<void>::getOperandSegmentSizeAttr()};
-      return names;
-    }
-  }];
-
   let verify = [{
     return ::mlir::detail::verifyOffsetSizeAndStrideOp(
         ::mlir::cast<::mlir::OffsetSizeAndStrideOpInterface>($_op));
   }];
 }
 
 #endif // MLIR_INTERFACES_VIEWLIKEINTERFACE

mlir/lib/Interfaces/ViewLikeInterface.cpp

bool mlir::detail::sameOffsetsSizesAndStrides(
   for (auto it : llvm::zip(a.getMixedSizes(), b.getMixedSizes()))
     if (!cmp(std::get<0>(it), std::get<1>(it)))
       return false;
   for (auto it : llvm::zip(a.getMixedStrides(), b.getMixedStrides()))
     if (!cmp(std::get<0>(it), std::get<1>(it)))
       return false;
   return true;
 }
+
+unsigned mlir::detail::getNumDynamicEntriesUpToIdx(ArrayRef<int64_t> staticVals,
+                                                   unsigned idx) {
+  return std::count_if(staticVals.begin(), staticVals.begin() + idx,
+                       [&](int64_t val) { return ShapedType::isDynamic(val); });
+}