[mlir] Utility method for getting mixed integer and values list as just values.

[mravishankar]

Summary

For a list of mixed integer and SSA values (used for offsets, sizes
and strides in OffsetSizeAndStrideOpInterface) return the entries as
SSA values.

[hanchung]

just few style nits.

mlir/include/mlir/Interfaces/ViewLikeInterface.td

183

Add a period at the end.

218

ditto

253

ditto

mlir/lib/Interfaces/ViewLikeInterface.cpp

11–12

Add a blank line between these two.

44–45

Add a blank line between two methods.

[mravishankar]

Address comments and use ValueRange instead OperandRange for values.

[mravishankar]

Moving the utility methods to StandardDialect/Utils since keep it on
ViewInterface is a layering violation. Also drop the interface methods
that use that utility.

[rriddle]

mlir/lib/Dialect/StandardOps/Utils/Utils.cpp

36 ↗

(On Diff #327576)

Can you use integers.getAsValueRange<IntegerAttr>() instead?

39 ↗

(On Diff #327576)

nit: Drop trivial braces.

[mravishankar]

Address comments

mlir/lib/Dialect/StandardOps/Utils/Utils.cpp

36 ↗

(On Diff #327576)

Thanks!

[mravishankar]

@nicolasvasilache suggestion abandoning this patch. The intent is to make the use of OpFoldResult more common, and having a fall back to get Value would affect that.

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

inline SmallVector<OpFoldResult> getMixedPadImpl(ArrayAttr staticAttrs,
       return res;
     }
     SmallVector<OpFoldResult> getMixedLowPad() {
       return getMixedPadImpl(static_low(), low());
     }
     SmallVector<OpFoldResult> getMixedHighPad() {
       return getMixedPadImpl(static_high(), high());
     }
+    SmallVector<Value, 4> getLowPadAsValues(OpBuilder &b, Location loc) {
+      return getOperandsOrIntegersSizesListAsValues(b, loc, low(),
+          static_low());
+    }
+    SmallVector<Value, 4> getHighPadAsValues(OpBuilder &b, Location loc) {
+      return getOperandsOrIntegersSizesListAsValues(b, loc, high(),
+          static_high());
+    }
   }];
 
   let builders = [
     // Build a PadTensorOp with mixed static and dynamic entries.
     OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$staticLow,
       "ArrayRef<int64_t>":$staticHigh, "ValueRange":$low, "ValueRange":$high,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a PadTensorOp with all dynamic entries.

mlir/include/mlir/Interfaces/ViewLikeInterface.h

 struct Range {
   Value offset;
   Value size;
   Value stride;
 };
 
 class OffsetSizeAndStrideOpInterface;
 LogicalResult verify(OffsetSizeAndStrideOpInterface op);
+
+/// Utility method to take a list of mixed static and dynamic values that
+/// represent offsets or strides and return a vector of Values. The `values`
+/// correspond to the dynamic values for the position in `integers` (which is a
+/// ArrayAttr of IntegerAttrs) which contain ShapedType::kDynamicStrideOrOffset.
+SmallVector<Value, 4> getOperandsOrIntegersOffsetsOrStridesListAsValues(
+    OpBuilder &b, Location loc, ValueRange values, ArrayAttr integers);
+
+/// Utility method to take a list of mixed static and dynamic values that
+/// represent sizes and return a vector of Values. The `values` correspond to
+/// the dynamic values for the position in `integers` (which is a ArrayAttr of
+/// IntegerAttrs) which contain ShapedType::kDynamicSize.
+SmallVector<Value, 4>
+getOperandsOrIntegersSizesListAsValues(OpBuilder &b, Location loc,
+                                       ValueRange values, ArrayAttr integers);
 } // namespace mlir
 
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/ViewLikeInterface.h.inc"
 
 namespace mlir {
 
 /// Printer hook for custom directive in assemblyFormat.

mlir/include/mlir/Interfaces/ViewLikeInterface.td

InterfaceMethod<
           else
             res.push_back($_op.static_offsets()[idx]);
         }
         return res;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
+        Return a vector of all the static or dynamic offsets of the op
+        as Values.
+      }],
+      /*retTy=*/"::mlir::SmallVector<::mlir::Value, 4>",
+      /*methodName=*/"getOffsetsAsValues",
+      /*args=*/(ins "OpBuilder &":$b, "Location":$loc),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return getOperandsOrIntegersOffsetsOrStridesListAsValues(
+            b, loc, $_op.offsets(), $_op.static_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;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
+        Return a vector of all the static or dynamic sizes of the op
+        as Values.
+      }],
+      /*retTy=*/"::mlir::SmallVector<::mlir::Value, 4>",
+      /*methodName=*/"getSizesAsValues",
+      /*args=*/(ins "OpBuilder &":$b, "Location":$loc),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return getOperandsOrIntegersSizesListAsValues(
+            b, loc, $_op.sizes(), $_op.static_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;
       }]
     >,
+    InterfaceMethod<
+      /*desc=*/[{
+        Return a vector of all the static or dynamic strides of the op
+        as Values.
+      }],
+      /*retTy=*/"::mlir::SmallVector<::mlir::Value, 4>",
+      /*methodName=*/"getStridesAsValues",
+      /*args=*/(ins "OpBuilder &":$b, "Location":$loc),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return getOperandsOrIntegersOffsetsOrStridesListAsValues(
+            b, loc, $_op.strides(), $_op.static_strides());
+      }]
+    >,
 
     InterfaceMethod<
       /*desc=*/[{
         Return true if the offset `idx` is dynamic.
       }],
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicOffset",
       /*args=*/(ins "unsigned":$idx),

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/Dialect/StandardOps/IR/Ops.h"
+
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // ViewLike Interfaces
 //===----------------------------------------------------------------------===//
 
 /// Include the definitions of the loop-like interfaces.
 #include "mlir/Interfaces/ViewLikeInterface.cpp.inc"
 
+template <int64_t dynVal>
+static SmallVector<Value, 4>
+getOperandsOrIntegersListAsValues(OpBuilder &b, Location loc, ValueRange values,
+                                  ArrayAttr integers) {
+  SmallVector<Value, 4> allValues;
+  unsigned dynamicOperandNum = 0;
+  for (auto integerValue : llvm::map_range(integers, [](Attribute attr) {
+         return attr.cast<IntegerAttr>().getInt();
+       })) {
+    if (integerValue != dynVal) {
+      allValues.push_back(b.create<ConstantIndexOp>(loc, integerValue));
+    } else {
+      allValues.push_back(values[dynamicOperandNum++]);
+    }
+  }
+  return allValues;
+}
+
+SmallVector<Value, 4> mlir::getOperandsOrIntegersOffsetsOrStridesListAsValues(
+    OpBuilder &b, Location loc, ValueRange values, ArrayAttr integers) {
+  return getOperandsOrIntegersListAsValues<ShapedType::kDynamicStrideOrOffset>(
+      b, loc, values, integers);
+}
+
+SmallVector<Value, 4> mlir::getOperandsOrIntegersSizesListAsValues(
+    OpBuilder &b, Location loc, ValueRange values, ArrayAttr integers) {
+  return getOperandsOrIntegersListAsValues<ShapedType::kDynamicSize>(
+      b, loc, values, integers);
+}
+
 LogicalResult mlir::verifyListOfOperandsOrIntegers(
     Operation *op, StringRef name, unsigned maxNumElements, ArrayAttr attr,
     ValueRange values, llvm::function_ref<bool(int64_t)> isDynamic) {
   /// Check static and dynamic offsets/sizes/strides does not overflow type.
   if (attr.size() > maxNumElements)
     return op->emitError("expected <= ")
            << maxNumElements << " " << name << " values";
   unsigned expectedNumDynamicEntries =