[mlir] Provide getMixedOffsets/sizes/strides as free functions

[Hardcode84]

Summary

• This is usedul when you need to build mixed array from external static/dynamic arrays (e.g. from adaptor during dialect conversion)
• Also, to reduce C++ code in td and generated files

[Hardcode84]

Fix linux build

mlir/include/mlir/Interfaces/ViewLikeInterface.h

 struct Range {
   Value offset;
   Value size;
   Value stride;
 };
 
 class OffsetSizeAndStrideOpInterface;
 
+/// Return a vector of all the static or dynamic offsets of the op from provided
+/// external static and dynamic offsets.
+SmallVector<OpFoldResult, 4> getMixedOffsets(OffsetSizeAndStrideOpInterface op,
+                                             ArrayAttr staticOffsets,
+                                             ValueRange offsets);
+
+/// Return a vector of all the static or dynamic sizes of the op from provided
+/// external static and dynamic sizes.
+SmallVector<OpFoldResult, 4> getMixedSizes(OffsetSizeAndStrideOpInterface op,
+                                           ArrayAttr staticSizes,
+                                           ValueRange sizes);
+
+/// Return a vector of all the static or dynamic strides of the op from provided
+/// external static and dynamic strides.
+SmallVector<OpFoldResult, 4> getMixedStrides(OffsetSizeAndStrideOpInterface op,
+                                             ArrayAttr staticStrides,
+                                             ValueRange strides);
+
 namespace detail {
 LogicalResult verifyOffsetSizeAndStrideOp(OffsetSizeAndStrideOpInterface op);
 
 bool sameOffsetsSizesAndStrides(
     OffsetSizeAndStrideOpInterface a, OffsetSizeAndStrideOpInterface b,
     llvm::function_ref<bool(OpFoldResult, OpFoldResult)> cmp);
 } // namespace detail
 } // namespace mlir

mlir/include/mlir/Interfaces/ViewLikeInterface.td

InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic sizes of the op.
       }],
       /*retTy=*/"::mlir::SmallVector<::mlir::OpFoldResult, 4>",
       /*methodName=*/"getMixedOffsets",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        ::mlir::SmallVector<::mlir::OpFoldResult, 4> res;
-        unsigned numDynamic = 0;
-        unsigned count = $_op.static_offsets().size();
-        for (unsigned idx = 0; idx < count; ++idx) {
-          if (isDynamicOffset(idx))
-            res.push_back($_op.offsets()[numDynamic++]);
-          else
-            res.push_back($_op.static_offsets()[idx]);
-        }
-        return res;
+        return ::mlir::getMixedOffsets($_op, $_op.static_offsets(),
+                                       $_op.offsets());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic sizes of the op.
       }],
       /*retTy=*/"::mlir::SmallVector<::mlir::OpFoldResult, 4>",
       /*methodName=*/"getMixedSizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        ::mlir::SmallVector<::mlir::OpFoldResult, 4> res;
-        unsigned numDynamic = 0;
-        unsigned count = $_op.static_sizes().size();
-        for (unsigned idx = 0; idx < count; ++idx) {
-          if (isDynamicSize(idx))
-            res.push_back($_op.sizes()[numDynamic++]);
-          else
-            res.push_back($_op.static_sizes()[idx]);
-        }
-        return res;
+        return ::mlir::getMixedSizes($_op, $_op.static_sizes(), $_op.sizes());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic strides of the op.
       }],
       /*retTy=*/"::mlir::SmallVector<::mlir::OpFoldResult, 4>",
       /*methodName=*/"getMixedStrides",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        ::mlir::SmallVector<::mlir::OpFoldResult, 4> res;
-        unsigned numDynamic = 0;
-        unsigned count = $_op.static_strides().size();
-        for (unsigned idx = 0; idx < count; ++idx) {
-          if (isDynamicStride(idx))
-            res.push_back($_op.strides()[numDynamic++]);
-          else
-            res.push_back($_op.static_strides()[idx]);
-        }
-        return res;
+        return ::mlir::getMixedStrides($_op, $_op.static_strides(),
+                                       $_op.strides());
       }]
     >,
 
     InterfaceMethod<
       /*desc=*/[{
         Return true if the offset `idx` is dynamic.
       }],
       /*retTy=*/"bool",

mlir/lib/Interfaces/ViewLikeInterface.cpp

void OffsetSizeAndStrideOpInterface::expandToRank(
   Attribute zero = IntegerAttr::get(IndexType::get(ctx), APInt(64, 0));
   Attribute one = IntegerAttr::get(IndexType::get(ctx), APInt(64, 1));
   for (unsigned i = offsets.size(); i < rank; ++i) {
     offsets.push_back(zero);
     sizes.push_back(createOrFoldDim(target, i));
     strides.push_back(one);
   }
 }
+
+SmallVector<OpFoldResult, 4>
+mlir::getMixedOffsets(OffsetSizeAndStrideOpInterface op,
+                      ArrayAttr staticOffsets, ValueRange offsets) {
+  SmallVector<OpFoldResult, 4> res;
+  unsigned numDynamic = 0;
+  unsigned count = static_cast<unsigned>(staticOffsets.size());
+  for (unsigned idx = 0; idx < count; ++idx) {
+    if (op.isDynamicOffset(idx))
+      res.push_back(offsets[numDynamic++]);
+    else
+      res.push_back(staticOffsets[idx]);
+  }
+  return res;
+}
+
+SmallVector<OpFoldResult, 4>
+mlir::getMixedSizes(OffsetSizeAndStrideOpInterface op, ArrayAttr staticSizes,
+                    ValueRange sizes) {
+  SmallVector<OpFoldResult, 4> res;
+  unsigned numDynamic = 0;
+  unsigned count = static_cast<unsigned>(staticSizes.size());
+  for (unsigned idx = 0; idx < count; ++idx) {
+    if (op.isDynamicSize(idx))
+      res.push_back(sizes[numDynamic++]);
+    else
+      res.push_back(staticSizes[idx]);
+  }
+  return res;
+}
+
+SmallVector<OpFoldResult, 4>
+mlir::getMixedStrides(OffsetSizeAndStrideOpInterface op,
+                      ArrayAttr staticStrides, ValueRange strides) {
+  SmallVector<OpFoldResult, 4> res;
+  unsigned numDynamic = 0;
+  unsigned count = static_cast<unsigned>(staticStrides.size());
+  for (unsigned idx = 0; idx < count; ++idx) {
+    if (op.isDynamicStride(idx))
+      res.push_back(strides[numDynamic++]);
+    else
+      res.push_back(staticStrides[idx]);
+  }
+  return res;
+}