[MLIR] Adopt `DenseI64ArrayAttr` in tensor, memref and linalg transform

[chelini]

Summary

This commit is a first step toward removing inconsistencies between dynamic
and static attributes (i64 v. index) by dropping I64ArrayAttr and
using DenseI64ArrayAttr in Tensor, Memref and Linalg Transform ops.
In Linalg Transform ops only TileToScfForOp and TileOp have been updated.

See related discussion: https://discourse.llvm.org/t/rfc-inconsistency-between-dynamic-and-static-attributes-i64-v-index/66612/1

[chelini]

Please consider this a work in progress. Before finalizing, I do have some comments and questions:
a) getMixedValues now requires an extra parameter, an MLIRContext, as we need a builder to create an attribute from an int64_t (staticValues). Do you see any problem with this API change? Do you see better alternatives?
b) The attribute interchange in transform.structured.tile now requires adding array<i64: something as the syntax of dense attribute differs if we use ODS or custom parser/printer (see: https://github.com/llvm/llvm-project/commit/2092d1438c36606d82df20fd36f16de033d31147). I suggested moving transform.structured.tile to use ODS and avoid a custom printer/parser. What do you think? 
c) Do you know how to create a DenseXXXArrayAttr using the Python API?

[nicolasvasilache]

In D138567#3946489, @chelini wrote:

Please consider this a work in progress. Before finalizing, I do have some comments and questions:
a) getMixedValues now requires an extra parameter, an MLIRContext, as we need a builder to create an attribute from an int64_t (staticValues). Do you see any problem with this API change? Do you see better alternatives?

See suggestions inline.

b) The attribute interchange in transform.structured.tile now requires adding array<i64: something as the syntax of dense attribute differs if we use ODS or custom parser/printer (see: https://github.com/llvm/llvm-project/commit/2092d1438c36606d82df20fd36f16de033d31147). I suggested moving transform.structured.tile to use ODS and avoid a custom printer/parser. What do you think? 

Yes please!

c) Do you know how to create a DenseXXXArrayAttr using the Python API?

@ftynse ?

mlir/include/mlir/Interfaces/ViewLikeInterface.h

23–24

drop the , 4 part

23–24

This could move to include/mlir/Dialect/Utils/StaticValueUtils.h

23–24

This could take a Builder, to be consistent with the helper below.

23–24

This could also move to include/mlir/Dialect/Utils/StaticValueUtils.h

[ftynse]

In D138567#3946726, @nicolasvasilache wrote:

In D138567#3946489, @chelini wrote:

c) Do you know how to create a DenseXXXArrayAttr using the Python API?

@ftynse ?

mlir.ir.DenseXXXArrayAttr.get(...)? Python API is quite self-consistent.

[chelini]

• Fix python tests

• getMixedValues now takes a builder

[chelini]

Doc

[chelini]

Move getMixedValues and decomposeMixedValues in StaticValueUtils.h

[chelini]

@nicolasvasilache and @ftynse, I made the changes suggested and fixed the Python tests. I am now looking into how we can use the assembly form for TileOp, but it isn't possible to specify the number or results (i.e., loops) based on some constraints in ODS (i.e., tile size equals 0). See: https://github.com/llvm/llvm-project/blob/15e76eed0c7662f8a4bce849a58637070d3b0a75/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp#L1330
If we want to be consistent, we need to modify the parser and printer of DynamicIndexList to parse print array<i64: something>, making the IR more verbose but consistent. Thoughts or suggestions? I am asking because DynamicIndexList touches a lot of operations and I want to agree on the changes before doing.

[ftynse]

It is possible to pass a reference to something into a custom printer/parser directive. So you can have an additional custom directive that "parses" the results and takes a reference to the "tile size" attribute. It then doesn't actually parse anything, but populates the list of result types based on the content of the attribute. It's hacky but should work.

mlir/python/mlir/dialects/_structured_transform_ops_ext.py

52

Nit: call this _get_dense_int64_array_attr in case somebody will eventually need a different width.

[chelini]

• _get_dense_int_array_attr -> _get_dense_int64_array_attr

• Change parser/printer for TileOp and TileToScfForOp to parse the short form of DenseI64ArrayAttr to be consistent with what we parse via parseDynamicIndexList.

[chelini]

It turned out that there is a way to print a DenseXXXArrayAttr in C++ using the
short form: see https://reviews.llvm.org/D132758. Adjust the code.

[nicolasvasilache]

Nice cleanup, thanks @chelini !

[mehdi_amini]

Nice, thanks!

[qcolombet]

Thanks for doing this @chelini!

mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td

let description = [{
     that of the list associated with the `target` handle.
 
     If the internal implementation of tiling for any of the operations fails,
     produces a definite failure.
   }];
 
   let arguments = (ins PDL_Operation:$target,
                    Variadic<PDL_Operation>:$dynamic_sizes,
-                   DefaultValuedAttr<I64ArrayAttr, "{}">:$static_sizes,
-                   DefaultValuedAttr<I64ArrayAttr, "{}">:$interchange);
+                   DefaultValuedOptionalAttr<DenseI64ArrayAttr, "{}">:$static_sizes,
+                   DefaultValuedOptionalAttr<DenseI64ArrayAttr, "{}">:$interchange);
   let results = (outs PDL_Operation:$tiled_linalg_op,
                       Variadic<PDL_Operation>:$loops);
 
   let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     /// Returns the list of tile sizes, which may be static (Attribute) or
     /// dynamic (Value).
let description = [{
     %sz = pdl_match @match_size_op in %arg1
     %3:2 = transform.structured.tile_to_foreach_thread_op %0 tile_sizes [0, %sz, 20]
     ```
   }];
 
   let arguments = (ins PDL_Operation:$target,
                    Variadic<PDL_Operation>:$num_threads,
                    Variadic<PDL_Operation>:$tile_sizes,
-                   DefaultValuedAttr<I64ArrayAttr, "{}">:$static_num_threads,
-                   DefaultValuedAttr<I64ArrayAttr, "{}">:$static_tile_sizes,
+                   DefaultValuedOptionalAttr<DenseI64ArrayAttr, "{}">:$static_num_threads,
+                   DefaultValuedOptionalAttr<DenseI64ArrayAttr, "{}">:$static_tile_sizes,
                    OptionalAttr<DeviceMappingArrayAttr>:$mapping);
   let results = (outs PDL_Operation:$foreach_thread_op,
                       PDL_Operation:$tiled_op);
 
   let builders = [
     OpBuilder<(ins "Value":$target,
                    "ArrayRef<int64_t>":$staticTileSizes,
                    CArg<"::mlir::transform::TileSizesSpec", 
let description = [{
     that of the list associated with the `target` handle.
 
     If the internal implementation of tiling for any of the operations fails,
     produces a definite failure.
   }];
 
   let arguments = (ins PDL_Operation:$target,
                    Variadic<PDL_Operation>:$dynamic_sizes,
-                   DefaultValuedAttr<I64ArrayAttr, "{}">:$static_sizes,
-                   DefaultValuedAttr<I64ArrayAttr, "{}">:$interchange);
+                   DefaultValuedOptionalAttr<DenseI64ArrayAttr, "{}">:$static_sizes,
+                   DefaultValuedOptionalAttr<DenseI64ArrayAttr, "{}">:$interchange);
   let results = (outs PDL_Operation:$tiled_linalg_op,
                       Variadic<PDL_Operation>:$loops);
 
   let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     /// Returns the list of tile sizes, which may be static (Attribute) or
     /// dynamic (Value).

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

let description = [{
     : memref<*xf32> to memref<?x?xf32, strided<[?, ?], offset: ?>>
     ```
   }];
 
   let arguments = (ins Arg<AnyRankedOrUnrankedMemRef, "", []>:$source,
                        Variadic<Index>:$offsets,
                        Variadic<Index>:$sizes,
                        Variadic<Index>:$strides,
-                       I64ArrayAttr:$static_offsets,
-                       I64ArrayAttr:$static_sizes,
-                       I64ArrayAttr:$static_strides);
+                       DenseI64ArrayAttr:$static_offsets,
+                       DenseI64ArrayAttr:$static_sizes,
+                       DenseI64ArrayAttr:$static_strides);
   let results = (outs AnyMemRef:$result);
 
   let assemblyFormat = [{
     $source `to` `offset` `` `:`
     custom<DynamicIndexList>($offsets, $static_offsets)
     `` `,` `sizes` `` `:`
     custom<DynamicIndexList>($sizes, $static_sizes)
     `` `,` `strides` `` `:`
def MemRef_ExpandShapeOp : MemRef_ReassociativeReshapeOp<"expand_shape", [
   let description = [{
     The `memref.expand_shape` op produces a new view with a higher rank whose
     sizes are a reassociation of the original `view`. The operation is limited
     to such reassociations, where a dimension is expanded into one or multiple
     contiguous dimensions. Such reassociations never require additional allocs
     or copies.
 
     A reassociation is defined as a grouping of dimensions and is represented
-    with an array of I64ArrayAttr attributes.
+    with an array of DenseI64ArrayAttr attributes.
 
     Example:
 
     ```mlir
     %r = memref.expand_shape %0 [[0, 1], [2]]
         : memref<?x?xf32> into memref<?x5x?xf32>
     ```
 
let description = [{
     Collapsing non-contiguous dimensions is undefined behavior. When a group of
     dimensions can be statically proven to be non-contiguous, collapses of such
     groups are rejected in the verifier on a best-effort basis. In the general
     case, collapses of dynamically-sized dims with dynamic strides cannot be
     proven to be contiguous or non-contiguous due to limitations in the memref
     type.
 
     A reassociation is defined as a continuous grouping of dimensions and is
-    represented with an array of I64ArrayAttr attribute.
+    represented with an array of DenseI64ArrayAttr attribute.
 
     Note: Only the dimensions within a reassociation group must be contiguous.
     The remaining dimensions may be non-contiguous.
 
     The result memref type can be zero-ranked if the source memref type is
     statically shaped with all dimensions being unit extent. In such a case, the
     reassociation indices must be empty.
 
%3 = memref.subview %2[3, 4, 2][1, 6, 3][1, 1, 1] :
       memref<8x16x4xf32> to memref<6x3xf32, strided<[4, 1], offset: 210>>
     ```
   }];
 
   let arguments = (ins AnyMemRef:$source,
                        Variadic<Index>:$offsets,
                        Variadic<Index>:$sizes,
                        Variadic<Index>:$strides,
-                       I64ArrayAttr:$static_offsets,
-                       I64ArrayAttr:$static_sizes,
-                       I64ArrayAttr:$static_strides);
+                       DenseI64ArrayAttr:$static_offsets,
+                       DenseI64ArrayAttr:$static_sizes,
+                       DenseI64ArrayAttr:$static_strides);
   let results = (outs AnyMemRef:$result);
 
   let assemblyFormat = [{
     $source ``
     custom<DynamicIndexList>($offsets, $static_offsets)
     custom<DynamicIndexList>($sizes, $static_sizes)
     custom<DynamicIndexList>($strides, $static_strides)
     attr-dict `:` type($source) `to` type($result)

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

let description = [{
     ```
   }];
 
   let arguments = (ins
     AnyRankedTensor:$source,
     Variadic<Index>:$offsets,
     Variadic<Index>:$sizes,
     Variadic<Index>:$strides,
-    I64ArrayAttr:$static_offsets,
-    I64ArrayAttr:$static_sizes,
-    I64ArrayAttr:$static_strides
+    DenseI64ArrayAttr:$static_offsets,
+    DenseI64ArrayAttr:$static_sizes,
+    DenseI64ArrayAttr:$static_strides
   );
   let results = (outs AnyRankedTensor:$result);
 
   let assemblyFormat = [{
     $source ``
     custom<DynamicIndexList>($offsets, $static_offsets)
     custom<DynamicIndexList>($sizes, $static_sizes)
     custom<DynamicIndexList>($strides, $static_strides)
def Tensor_InsertSliceOp : Tensor_OpWithOffsetSizesAndStrides<"insert_slice", [
   }];
 
   let arguments = (ins
     AnyRankedTensor:$source,
     AnyRankedTensor:$dest,
     Variadic<Index>:$offsets,
     Variadic<Index>:$sizes,
     Variadic<Index>:$strides,
-    I64ArrayAttr:$static_offsets,
-    I64ArrayAttr:$static_sizes,
-    I64ArrayAttr:$static_strides
+    DenseI64ArrayAttr:$static_offsets,
+    DenseI64ArrayAttr:$static_sizes,
+    DenseI64ArrayAttr:$static_strides
   );
   let results = (outs AnyRankedTensor:$result);
 
   let assemblyFormat = [{
     $source `into` $dest ``
     custom<DynamicIndexList>($offsets, $static_offsets)
     custom<DynamicIndexList>($sizes, $static_sizes)
     custom<DynamicIndexList>($strides, $static_strides)

 
 def Tensor_ExpandShapeOp : Tensor_ReassociativeReshapeOp<"expand_shape"> {
   let summary = "operation to produce a tensor with a higher rank";
   let description = [{
     The `tensor.expand_shape` op produces a new tensor with a higher
     rank whose sizes are a reassociation of the original `src`.
 
     A reassociation is defined as a continuous grouping of dimensions and is
-    represented with an array of I64ArrayAttr attribute.
+    represented with an array of DenseI64ArrayAttr attribute.
 
     The verification rule is that the reassociation maps are applied to the
     result tensor with the higher rank to obtain the operand tensor with the
     smaller rank.
 
     The operand tensor type of a reshape can be zero-ranked if the result
     tensor type is statically shaped with all dimensions being unit extent. In
     such cases the reassociation map is empty.

 
 def Tensor_CollapseShapeOp : Tensor_ReassociativeReshapeOp<"collapse_shape"> {
   let summary = "operation to produce a tensor with a smaller rank";
   let description = [{
     The `tensor.collapse_shape` op produces a new tensor with a smaller
     rank whose sizes are a reassociation of the original `src`.
 
     A reassociation is defined as a continuous grouping of dimensions and is
-    represented with an array of I64ArrayAttr attribute.
+    represented with an array of DenseI64ArrayAttr attribute.
 
     The verification rule is that the reassociation maps are applied to the
     operand tensor with the higher rank to obtain the result tensor with the
     smaller rank.
 
     The result tensor type of a reshape can be zero-ranked if the operand
     tensor type is statically shaped with all dimensions being unit extent. In
     such case the reassociation map is empty.
```mlir
       } : tensor<2x3xf32> to tensor<2x3xf32>
     ```
   }];
 
   let arguments = (ins
     AnyTensor:$source,
     Variadic<Index>:$low,
     Variadic<Index>:$high,
-    I64ArrayAttr:$static_low,
-    I64ArrayAttr:$static_high,
+    DenseI64ArrayAttr:$static_low,
+    DenseI64ArrayAttr:$static_high,
     UnitAttr:$nofold);
 
   let regions = (region SizedRegion<1>:$region);
 
   let results = (outs AnyTensor:$result);
 
   // TODO: Remove custom<InferType> when AllTypesMatch supports opt. operands.
   let assemblyFormat = [{
static RankedTensorType inferResultType(
                                 ArrayRef<int64_t> staticHigh,
                                 ArrayRef<int64_t> resultShape = {});
 
     // Return the pad value if it is a constant. Return null value otherwise.
     Value getConstantPaddingValue();
 
     // Return a vector of all the static or dynamic values (low/high padding) of
     // the op.
-    inline SmallVector<OpFoldResult> getMixedPadImpl(ArrayAttr staticAttrs,
+    inline SmallVector<OpFoldResult> getMixedPadImpl(ArrayRef<int64_t> staticAttrs,
                                                      ValueRange values) {
+      Builder builder(*this);
       SmallVector<OpFoldResult> res;
       unsigned numDynamic = 0;
       unsigned count = staticAttrs.size();
       for (unsigned idx = 0; idx < count; ++idx) {
-        if (ShapedType::isDynamic(staticAttrs[idx].cast<IntegerAttr>().getInt()))
+        if (ShapedType::isDynamic(staticAttrs[idx]))
           res.push_back(values[numDynamic++]);
         else
-          res.push_back(staticAttrs[idx]);
+          res.push_back(builder.getI64IntegerAttr(staticAttrs[idx]));
       }
       return res;
     }
     SmallVector<OpFoldResult> getMixedLowPad() {
       return getMixedPadImpl(getStaticLow(), getLow());
     }
     SmallVector<OpFoldResult> getMixedHighPad() {
       return getMixedPadImpl(getStaticHigh(), getHigh());
def Tensor_ParallelInsertSliceOp : Tensor_Op<"parallel_insert_slice", [
   }];
 
   let arguments = (ins
     AnyRankedTensor:$source,
     AnyRankedTensor:$dest,
     Variadic<Index>:$offsets,
     Variadic<Index>:$sizes,
     Variadic<Index>:$strides,
-    I64ArrayAttr:$static_offsets,
-    I64ArrayAttr:$static_sizes,
-    I64ArrayAttr:$static_strides
+    DenseI64ArrayAttr:$static_offsets,
+    DenseI64ArrayAttr:$static_sizes,
+    DenseI64ArrayAttr:$static_strides
   );
   let assemblyFormat = [{
     $source `into` $dest ``
     custom<DynamicIndexList>($offsets, $static_offsets)
     custom<DynamicIndexList>($sizes, $static_sizes)
     custom<DynamicIndexList>($strides, $static_strides)
     attr-dict `:` type($source) `into` type($dest)
   }];
def Tensor_PackOp : Tensor_RelayoutOp<"pack", [
 
   }];
   let arguments = (ins AnyRankedTensor:$source,
                        AnyRankedTensor:$dest,
                        Optional<AnyType>:$padding_value,
                        DefaultValuedOptionalAttr<DenseI64ArrayAttr, "{}">:$outer_dims_perm,
                        DenseI64ArrayAttr:$inner_dims_pos,
                        Variadic<Index>:$inner_tiles,
-                       I64ArrayAttr:$static_inner_tiles);
+                       DenseI64ArrayAttr:$static_inner_tiles);
   let results = (outs AnyRankedTensor:$result);
   let assemblyFormat = [{
     $source 
     (`padding_value` `(` $padding_value^ `:` type($padding_value) `)`)?
     (`outer_dims_perm` `=` $outer_dims_perm^)?  
     `inner_dims_pos` `=` $inner_dims_pos
     `inner_tiles` `=`
     custom<DynamicIndexList>($inner_tiles, $static_inner_tiles)
tensor.unapck %source outer_dims_perm = [1, 0] inner_dims_pos = [0, 1]
       inner_tiles = [8, 32] into %dest : tensor<8x16x8x32xf32> -> tensor<128x256xf32>
     ```
   }];
   let arguments = (ins AnyRankedTensor:$source,
                        AnyRankedTensor:$dest,
                        DefaultValuedOptionalAttr<DenseI64ArrayAttr, "{}">:$outer_dims_perm,
                        DenseI64ArrayAttr:$inner_dims_pos,
                        Variadic<Index>:$inner_tiles,
-                       I64ArrayAttr:$static_inner_tiles);
+                       DenseI64ArrayAttr:$static_inner_tiles);
   let results = (outs AnyRankedTensor:$result);
   let assemblyFormat = [{
     $source
     (`outer_dims_perm` `=` $outer_dims_perm^)?
     `inner_dims_pos` `=` $inner_dims_pos
     `inner_tiles` `=`
     custom<DynamicIndexList>($inner_tiles, $static_inner_tiles)
     `into` $dest attr-dict `:` type($source) `->` type($dest)

mlir/include/mlir/Dialect/Utils/StaticValueUtils.h

 
 /// Helper function to convert a vector of `OpFoldResult`s into a vector of
 /// `Value`s. For each `OpFoldResult` in `valueOrAttrVec` return the fold result
 /// if it casts to  a `Value` or create an index-type constant if it casts to
 /// `IntegerAttr`. No other attribute types are supported.
 SmallVector<Value> getAsValues(OpBuilder &b, Location loc,
                                ArrayRef<OpFoldResult> valueOrAttrVec);
 
+/// Return a vector of OpFoldResults with the same size a staticValues, but all
+/// elements for which ShapedType::isDynamic is true, will be replaced by
+/// dynamicValues.
+SmallVector<OpFoldResult> getMixedValues(ArrayRef<int64_t> staticValues,
+                                         ValueRange dynamicValues, Builder &b);
+
+/// Decompose a vector of mixed static or dynamic values into the corresponding
+/// pair of arrays. This is the inverse function of `getMixedValues`.
+std::pair<ArrayAttr, SmallVector<Value>>
+decomposeMixedValues(Builder &b,
+                     const SmallVectorImpl<OpFoldResult> &mixedValues);
+
 } // namespace mlir
 
 #endif // MLIR_DIALECT_UTILS_STATICVALUEUTILS_H

mlir/include/mlir/Interfaces/ViewLikeInterface.h

 
 #include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpImplementation.h"
 
 namespace mlir {
 
-/// Return a vector of OpFoldResults with the same size a staticValues, but all
-/// elements for which ShapedType::isDynamic is true, will be replaced by
-/// dynamicValues.
-SmallVector<OpFoldResult, 4> getMixedValues(ArrayAttr staticValues,
-                                            ValueRange dynamicValues);
-
-/// Decompose a vector of mixed static or dynamic values into the corresponding
-/// pair of arrays. This is the inverse function of `getMixedValues`.
-std::pair<ArrayAttr, SmallVector<Value>>
-decomposeMixedValues(Builder &b,
-                     const SmallVectorImpl<OpFoldResult> &mixedValues);
-
 class OffsetSizeAndStrideOpInterface;
 
 namespace detail {
 
 LogicalResult verifyOffsetSizeAndStrideOp(OffsetSizeAndStrideOpInterface op);
 
 bool sameOffsetsSizesAndStrides(
     OffsetSizeAndStrideOpInterface a, OffsetSizeAndStrideOpInterface b,
     llvm::function_ref<bool(OpFoldResult, OpFoldResult)> cmp);

 ///   custom<DynamicIndexList>($values, $integers)
 ///
 /// where `values` is of ODS type `Variadic<Index>` and `integers` is of ODS
 /// type `I64ArrayAttr`. Prints a list with either (1) the static integer value
 /// in `integers` is `dynVal` or (2) the next value otherwise. This allows
 /// idiomatic printing of mixed value and integer attributes in a list. E.g.
 /// `[%arg0, 7, 42, %arg42]`.
 void printDynamicIndexList(OpAsmPrinter &printer, Operation *op,
-                           OperandRange values, ArrayAttr integers);
+                           OperandRange values, ArrayRef<int64_t> integers);
 
 /// Pasrer hook for custom directive in assemblyFormat.
 ///
 ///   custom<DynamicIndexList>($values, $integers)
 ///
 /// where `values` is of ODS type `Variadic<Index>` and `integers` is of ODS
 /// type `I64ArrayAttr`. Parse a mixed list with either (1) static integer
 /// values or (2) SSA values. Fill `integers` with the integer ArrayAttr, where
 /// `dynVal` encodes the position of SSA values. Add the parsed SSA values
 /// to `values` in-order.
 //
 /// E.g. after parsing "[%arg0, 7, 42, %arg42]":
 ///   1. `result` is filled with the i64 ArrayAttr "[`dynVal`, 7, 42, `dynVal`]"
 ///   2. `ssa` is filled with "[%arg0, %arg1]".
 ParseResult
 parseDynamicIndexList(OpAsmParser &parser,
                       SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
-                      ArrayAttr &integers);
+                      DenseI64ArrayAttr &integers);
 
 /// Verify that a the `values` has as many elements as the number of entries in
 /// `attr` for which `isDynamic` evaluates to true.
 LogicalResult verifyListOfOperandsOrIntegers(Operation *op, StringRef name,
                                              unsigned expectedNumElements,
-                                             ArrayAttr attr, ValueRange values);
+                                             ArrayRef<int64_t> attr,
+                                             ValueRange values);
 
 } // namespace mlir
 
 #endif // MLIR_INTERFACES_VIEWLIKEINTERFACE_H_

mlir/include/mlir/Interfaces/ViewLikeInterface.td

InterfaceMethod<
       /*defaultImplementation=*/[{
         return $_op.getStrides();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the static offset attributes.
       }],
-      /*retTy=*/"::mlir::ArrayAttr",
+      /*retTy=*/"::llvm::ArrayRef<int64_t>",
       /*methodName=*/"static_offsets",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getStaticOffsets();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the static size attributes.
       }],
-      /*retTy=*/"::mlir::ArrayAttr",
+      /*retTy=*/"::llvm::ArrayRef<int64_t>",
       /*methodName=*/"static_sizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getStaticSizes();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the dynamic stride attributes.
       }],
-      /*retTy=*/"::mlir::ArrayAttr",
+      /*retTy=*/"::llvm::ArrayRef<int64_t>",
       /*methodName=*/"static_strides",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         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());
+                                      $_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=*/[{
-        return ::mlir::getMixedValues($_op.getStaticSizes(), $_op.sizes());
+        Builder b($_op->getContext());
+        return ::mlir::getMixedValues($_op.getStaticSizes(), $_op.sizes(), 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());
+                                      $_op.getStrides(), b);
       }]
     >,
 
     InterfaceMethod<
       /*desc=*/"Return true if the offset `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicOffset",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        ::llvm::APInt v = *(static_offsets()
-          .template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
-        return ::mlir::ShapedType::isDynamic(v.getSExtValue());
+        return ::mlir::ShapedType::isDynamic(static_offsets()[idx]);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return true if the size `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicSize",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        ::llvm::APInt v = *(static_sizes()
-          .template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
-        return ::mlir::ShapedType::isDynamic(v.getSExtValue());
+        return ::mlir::ShapedType::isDynamic(static_sizes()[idx]);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return true if the stride `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicStride",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        ::llvm::APInt v = *(static_strides()
-          .template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
-        return ::mlir::ShapedType::isDynamic(v.getSExtValue());
+        return ::mlir::ShapedType::isDynamic(static_strides()[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");
-        ::llvm::APInt v = *(static_offsets().
-          template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
-        return v.getSExtValue();
+        return static_offsets()[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");
-        ::llvm::APInt v = *(static_sizes().
-          template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
-        return v.getSExtValue();
+        return static_sizes()[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");
-        ::llvm::APInt v = *(static_strides().
-          template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
-        return v.getSExtValue();
+        return static_strides()[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 = getNumDynamicEntriesUpToIdx(
-          static_offsets().template cast<::mlir::ArrayAttr>(),
+          static_offsets(),
           ::mlir::ShapedType::isDynamic,
           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(
-          static_sizes().template cast<::mlir::ArrayAttr>(), ::mlir::ShapedType::isDynamic, idx);
+          static_sizes(), ::mlir::ShapedType::isDynamic, idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() +
           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<::mlir::ArrayAttr>(),
+          static_strides(),
           ::mlir::ShapedType::isDynamic,
           idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() +
           offsets().size() + sizes().size() + numDynamic;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
-        Helper method to compute the number of dynamic entries of `attr`, up to
+        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 "::mlir::ArrayAttr":$attr,
+      /*args=*/(ins "::llvm::ArrayRef<int64_t>":$staticVals,
                     "::llvm::function_ref<bool(int64_t)>":$isDynamic,
                     "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return std::count_if(
-          attr.getValue().begin(), attr.getValue().begin() + idx,
-          [&](::mlir::Attribute attr) {
-            return isDynamic(attr.cast<::mlir::IntegerAttr>().getInt());
+          staticVals.begin(), staticVals.begin() + idx,
+          [&](int64_t val) {
+            return isDynamic(val);
           });
       }]
     >,
 
     InterfaceMethod<
       /*desc=*/[{
         Assert the offset `idx` is dynamic and return its value.
       }],

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

matchAndRewrite(memref::SubViewOp subViewOp, OpAdaptor adaptor,
 
     auto sourceMemRefType = subViewOp.getSource().getType().cast<MemRefType>();
     auto sourceElementTy =
         typeConverter->convertType(sourceMemRefType.getElementType());
 
     auto viewMemRefType = subViewOp.getType();
     auto inferredType =
         memref::SubViewOp::inferResultType(
-            subViewOp.getSourceType(),
-            extractFromI64ArrayAttr(subViewOp.getStaticOffsets()),
-            extractFromI64ArrayAttr(subViewOp.getStaticSizes()),
-            extractFromI64ArrayAttr(subViewOp.getStaticStrides()))
+            subViewOp.getSourceType(), subViewOp.getStaticOffsets(),
+            subViewOp.getStaticSizes(), subViewOp.getStaticStrides())
             .cast<MemRefType>();
     auto targetElementTy =
         typeConverter->convertType(viewMemRefType.getElementType());
     auto targetDescTy = typeConverter->convertType(viewMemRefType);
     if (!sourceElementTy || !targetDescTy || !targetElementTy ||
         !LLVM::isCompatibleType(sourceElementTy) ||
         !LLVM::isCompatibleType(targetElementTy) ||
         !LLVM::isCompatibleType(targetDescTy))

mlir/lib/Conversion/TosaToTensor/TosaToTensor.cpp

 class SliceOpConverter : public OpRewritePattern<tosa::SliceOp> {
 public:
   using OpRewritePattern<tosa::SliceOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::SliceOp sliceOp,
                                 PatternRewriter &rewriter) const final {
     Location loc = sliceOp.getLoc();
     Value input = sliceOp.getInput();
-    SmallVector<int64_t> strides, sizes;
-    auto starts = sliceOp.getStart();
+    SmallVector<int64_t> strides, sizes, starts;
+    starts = extractFromI64ArrayAttr(sliceOp.getStart());
     strides.resize(sliceOp.getType().template cast<ShapedType>().getRank(), 1);
 
     SmallVector<Value> dynSizes;
     for (const auto &i : llvm::enumerate(sliceOp.getSize())) {
       int64_t size = i.value().cast<IntegerAttr>().getInt();
       size_t index = i.index();
       sizes.push_back(size == -1 ? ShapedType::kDynamic : size);
       if (!ShapedType::isDynamic(sizes.back()))
         continue;
 
       auto dim = rewriter.create<tensor::DimOp>(loc, input, index);
       auto offset = rewriter.create<arith::ConstantOp>(
-          loc,
-          rewriter.getIndexAttr(starts[index].cast<IntegerAttr>().getInt()));
+          loc, rewriter.getIndexAttr(starts[index]));
       dynSizes.push_back(rewriter.create<arith::SubIOp>(loc, dim, offset));
     }
 
     auto newSliceOp = rewriter.create<tensor::ExtractSliceOp>(
         sliceOp.getLoc(), sliceOp.getType(), input, ValueRange({}), dynSizes,
-        ValueRange({}), starts, rewriter.getI64ArrayAttr(sizes),
-        rewriter.getI64ArrayAttr(strides));
+        ValueRange({}), rewriter.getDenseI64ArrayAttr(starts),
+        rewriter.getDenseI64ArrayAttr(sizes),
+        rewriter.getDenseI64ArrayAttr(strides));
 
     rewriter.replaceOp(sliceOp, newSliceOp.getResult());
     return success();
   }
 };
 
 } // namespace
 
 void mlir::tosa::populateTosaToTensorConversionPatterns(
     RewritePatternSet *patterns) {
   patterns->add<SliceOpConverter>(patterns->getContext());
 }

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

 static SmallVector<unsigned> extractUIntArray(ArrayAttr attr) {
   SmallVector<unsigned> result;
   result.reserve(attr.size());
   for (APInt value : attr.getAsValueRange<IntegerAttr>())
     result.push_back(value.getZExtValue());
   return result;
 }
 
-/// Extracts a vector of int64_t from an array attribute. Asserts if the
-/// attribute contains values other than integers.
-static SmallVector<int64_t> extractI64Array(ArrayAttr attr) {
-  SmallVector<int64_t> result;
-  result.reserve(attr.size());
-  for (APInt value : attr.getAsValueRange<IntegerAttr>())
-    result.push_back(value.getSExtValue());
-  return result;
-}
-
 namespace {
 /// A simple pattern rewriter that implements no special logic.
 class SimpleRewriter : public PatternRewriter {
 public:
   SimpleRewriter(MLIRContext *context) : PatternRewriter(context) {}
 };
 } // namespace
 

 
 //===----------------------------------------------------------------------===//
 // TileOp
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure
 transform::TileOp::apply(TransformResults &transformResults,
                          TransformState &state) {
-  SmallVector<int64_t> tileSizes = extractFromI64ArrayAttr(getStaticSizes());
+  ArrayRef<int64_t> tileSizes = getStaticSizes();
 
   ArrayRef<Operation *> targets = state.getPayloadOps(getTarget());
   SmallVector<ArrayRef<Operation *>> dynamicSizeProducers;
   dynamicSizeProducers.reserve(getDynamicSizes().size());
   for (Value dynamicSizeProducerHandle : getDynamicSizes()) {
     dynamicSizeProducers.push_back(
         state.getPayloadOps(dynamicSizeProducerHandle));
 
if (!tileSizes.empty()) {
                 sizes.push_back(
                     dynamicSizeProducers[dynamicIdx++][index]->getResult(0));
               }
             }
             return sizes;
           });
     }
 
-    tilingOptions.setInterchange(extractI64Array(getInterchange()));
+    tilingOptions.setInterchange(getInterchange());
     SimpleRewriter rewriter(linalgOp.getContext());
     FailureOr<scf::SCFTilingResult> maybeTilingResult = tileUsingSCFForOp(
         rewriter, cast<TilingInterface>(linalgOp.getOperation()),
         tilingOptions);
     if (failed(maybeTilingResult))
       return DiagnosedSilenceableFailure::definiteFailure();
 
     if (linalgOp.hasBufferSemantics())
transform::TileOp::apply(TransformResults &transformResults,
   for (const auto &en : llvm::enumerate(loops))
     transformResults.set(getLoops()[en.index()].cast<OpResult>(), en.value());
 
   return DiagnosedSilenceableFailure::success();
 }
 
 SmallVector<OpFoldResult> transform::TileOp::getMixedSizes() {
   ValueRange dynamic = getDynamicSizes();
-  SmallVector<int64_t> tileSizes = extractFromI64ArrayAttr(getStaticSizes());
+  ArrayRef<int64_t> tileSizes = getStaticSizes();
   SmallVector<OpFoldResult> results;
   results.reserve(tileSizes.size());
   unsigned dynamicPos = 0;
   Builder builder(getContext());
   for (int64_t size : tileSizes) {
     if (size == ShapedType::kDynamic) {
       results.push_back(dynamic[dynamicPos++]);
     } else {
       results.push_back(builder.getIndexAttr(size));
     }
   }
   return results;
 }
 
 ParseResult transform::TileOp::parse(OpAsmParser &parser,
                                      OperationState &result) {
   OpAsmParser::UnresolvedOperand target;
   SmallVector<OpAsmParser::UnresolvedOperand> dynamicSizes;
-  ArrayAttr staticSizes;
+  DenseI64ArrayAttr staticSizes;
   auto pdlOperationType = pdl::OperationType::get(parser.getContext());
   if (parser.parseOperand(target) ||
       parser.resolveOperand(target, pdlOperationType, result.operands) ||
       parseDynamicIndexList(parser, dynamicSizes, staticSizes) ||
       parser.resolveOperands(dynamicSizes, pdlOperationType, result.operands) ||
       parser.parseOptionalAttrDict(result.attributes))
     return ParseResult::failure();
 
   result.addAttribute(getStaticSizesAttrName(result.name), staticSizes);
   size_t numExpectedLoops =
-      staticSizes.size() - llvm::count(extractFromI64ArrayAttr(staticSizes), 0);
+      staticSizes.size() - llvm::count(staticSizes.asArrayRef(), 0);
   result.addTypes(SmallVector<Type>(numExpectedLoops + 1, pdlOperationType));
   return success();
 }
 
 void TileOp::print(OpAsmPrinter &p) {
   p << ' ' << getTarget();
   printDynamicIndexList(p, getOperation(), getDynamicSizes(), getStaticSizes());
   p.printOptionalAttrDict((*this)->getAttrs(), {getStaticSizesAttrName()});
void transform::TileToForeachThreadOp::build(
   SmallVector<Value> dynamicTileSizes;
   dispatchIndexOpFoldResults(mixedTileSizes, dynamicTileSizes, staticTileSizes,
                              ShapedType::kDynamic);
   // Call the default builder which sets up the proper operands segment sizes
   // attributes for multiple variadic operands. In the absence of this, horrible
   // bugs ensue.
   MLIRContext *ctx = builder.getContext();
   auto operationType = pdl::OperationType::get(ctx);
-  auto staticTileSizesAttr = builder.getI64ArrayAttr(staticTileSizes);
+  auto staticTileSizesAttr = builder.getDenseI64ArrayAttr(staticTileSizes);
   build(builder, result,
         /*resultTypes=*/TypeRange{operationType, operationType},
         /*target=*/target,
         /*num_threads=*/ValueRange{},
         /*tile_sizes=*/dynamicTileSizes,
-        /*static_num_threads=*/builder.getI64ArrayAttr({}),
+        /*static_num_threads=*/builder.getDenseI64ArrayAttr({}),
         /*static_tile_sizes=*/staticTileSizesAttr,
         /*mapping=*/mapping);
 }
 
 void transform::TileToForeachThreadOp::build(OpBuilder &builder,
                                              OperationState &result,
                                              Value target,
                                              ArrayRef<int64_t> staticNumThreads,
void transform::TileToForeachThreadOp::build(
   SmallVector<Value> dynamicNumThreads;
   dispatchIndexOpFoldResults(mixedNumThreads, dynamicNumThreads,
                              staticNumThreads, ShapedType::kDynamic);
   // Call the default builder which sets up the proper operands segment sizes
   // attributes for multiple variadic operands. In the absence of this, horrible
   // bugs ensue.
   MLIRContext *ctx = builder.getContext();
   auto operationType = pdl::OperationType::get(ctx);
-  auto staticNumThreadsAttr = builder.getI64ArrayAttr(staticNumThreads);
+  auto staticNumThreadsAttr = builder.getDenseI64ArrayAttr(staticNumThreads);
   build(builder, result,
         /*resultTypes=*/TypeRange{operationType, operationType},
         /*target=*/target,
         /*num_threads=*/dynamicNumThreads,
         /*tile_sizes=*/ValueRange{},
         /*static_num_threads=*/staticNumThreadsAttr,
-        /*static_tile_sizes=*/builder.getI64ArrayAttr({}),
+        /*static_tile_sizes=*/builder.getDenseI64ArrayAttr({}),
         /*mapping=*/mapping);
 }
 
 // Given a list of OpFoldResults that are either index attrs or op
 // handles, return a list of OpFoldResults where all op handles are
 // replaced with the first (and only) OpResult of that payload op. (There
 // must be exactly one mapped payload op and it must have exactly one
 // index result.)
void transform::TileToForeachThreadOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   consumesHandle(getTarget(), effects);
   onlyReadsHandle(getTileSizes(), effects);
   onlyReadsHandle(getNumThreads(), effects);
   producesHandle(getResults(), effects);
 }
 
 SmallVector<OpFoldResult> TileToForeachThreadOp::getMixedNumThreads() {
-  return getMixedValues(getStaticNumThreads(), getNumThreads());
+  Builder b(getContext());
+  return getMixedValues(getStaticNumThreads(), getNumThreads(), b);
 }
 
 SmallVector<OpFoldResult> TileToForeachThreadOp::getMixedTileSizes() {
-  return getMixedValues(getStaticTileSizes(), getTileSizes());
+  Builder b(getContext());
+  return getMixedValues(getStaticTileSizes(), getTileSizes(), b);
 }
 
 LogicalResult TileToForeachThreadOp::verify() {
   if (getMixedNumThreads().empty() == getMixedTileSizes().empty())
     return emitOpError("either num_threads or tile_sizes must be specified");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TileToScfForOp
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure
 transform::TileToScfForOp::apply(TransformResults &transformResults,
                                  TransformState &state) {
-  SmallVector<int64_t> tileSizes = extractFromI64ArrayAttr(getStaticSizes());
+  ArrayRef<int64_t> tileSizes = getStaticSizes();
 
   ArrayRef<Operation *> targets = state.getPayloadOps(getTarget());
   SmallVector<ArrayRef<Operation *>> dynamicSizeProducers;
   dynamicSizeProducers.reserve(getDynamicSizes().size());
   for (Value dynamicSizeProducerHandle : getDynamicSizes()) {
     dynamicSizeProducers.push_back(
         state.getPayloadOps(dynamicSizeProducerHandle));
 
if (!tileSizes.empty()) {
                 sizes.push_back(
                     dynamicSizeProducers[dynamicIdx++][index]->getResult(0));
               }
             }
             return sizes;
           });
     }
 
-    tilingOptions.setInterchange(extractI64Array(getInterchange()));
+    tilingOptions.setInterchange(getInterchange());
     SimpleRewriter rewriter(tilingInterfaceOp.getContext());
     FailureOr<scf::SCFTilingResult> tilingResult =
         tileUsingSCFForOp(rewriter, tilingInterfaceOp, tilingOptions);
     if (failed(tilingResult))
       return DiagnosedSilenceableFailure::definiteFailure();
 
     rewriter.replaceOp(tilingInterfaceOp, tilingResult->replacements);
 
     tiled.append(tilingResult->tiledOps);
     for (const auto &en2 : llvm::enumerate(tilingResult->loops))
       loops[en2.index()].push_back(en2.value());
   }
 
   transformResults.set(getTiledLinalgOp().cast<OpResult>(), tiled);
   for (const auto &en : llvm::enumerate(loops))
     transformResults.set(getLoops()[en.index()].cast<OpResult>(), en.value());
 
   return DiagnosedSilenceableFailure::success();
 }
 
 SmallVector<OpFoldResult> transform::TileToScfForOp::getMixedSizes() {
   ValueRange dynamic = getDynamicSizes();
-  SmallVector<int64_t> tileSizes = extractFromI64ArrayAttr(getStaticSizes());
+  ArrayRef<int64_t> tileSizes = getStaticSizes();
   SmallVector<OpFoldResult> results;
   results.reserve(tileSizes.size());
   unsigned dynamicPos = 0;
   Builder builder(getContext());
   for (int64_t size : tileSizes) {
     if (size == ShapedType::kDynamic) {
       results.push_back(dynamic[dynamicPos++]);
     } else {
       results.push_back(builder.getIndexAttr(size));
     }
   }
   return results;
 }
 
 ParseResult transform::TileToScfForOp::parse(OpAsmParser &parser,
                                              OperationState &result) {
   OpAsmParser::UnresolvedOperand target;
   SmallVector<OpAsmParser::UnresolvedOperand> dynamicSizes;
-  ArrayAttr staticSizes;
+  DenseI64ArrayAttr staticSizes;
   auto pdlOperationType = pdl::OperationType::get(parser.getContext());
   if (parser.parseOperand(target) ||
       parser.resolveOperand(target, pdlOperationType, result.operands) ||
       parseDynamicIndexList(parser, dynamicSizes, staticSizes) ||
       parser.resolveOperands(dynamicSizes, pdlOperationType, result.operands) ||
       parser.parseOptionalAttrDict(result.attributes))
     return ParseResult::failure();
 
   result.addAttribute(getStaticSizesAttrName(result.name), staticSizes);
   size_t numExpectedLoops =
-      staticSizes.size() - llvm::count(extractFromI64ArrayAttr(staticSizes), 0);
+      staticSizes.size() - llvm::count(staticSizes.asArrayRef(), 0);
   result.addTypes(SmallVector<Type>(numExpectedLoops + 1, pdlOperationType));
   return success();
 }
 
 void TileToScfForOp::print(OpAsmPrinter &p) {
   p << ' ' << getTarget();
   printDynamicIndexList(p, getOperation(), getDynamicSizes(), getStaticSizes());
   p.printOptionalAttrDict((*this)->getAttrs(), {getStaticSizesAttrName()});

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

Value tmpTensor = rewriter
                                                 ValueRange{emptyTensor})
                         .result();
 
   // Copy original contents into new tensor
   // Uses linalg.generic, but could be done with tensor.insert_slice
   SmallVector<AffineExpr, 4> outputExprs;
   for (unsigned i = 0; i < resultShapedType.getRank(); ++i) {
     outputExprs.push_back(getAffineDimExpr(i, rewriter.getContext()) +
-                          padOp.getStaticLow()[i].cast<IntegerAttr>().getInt());
+                          padOp.getStaticLow()[i]);
   }
 
   SmallVector<AffineMap, 2> transferMaps = {
       rewriter.getMultiDimIdentityMap(inputShapedType.getRank()),
       AffineMap::get(resultShapedType.getRank(),
                      /*symbolCount=*/0, outputExprs, rewriter.getContext())};
 
   rewriter.replaceOpWithNewOp<linalg::GenericOp>(

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

void ReinterpretCastOp::build(OpBuilder &b, OperationState &result,
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offset, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamic);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamic);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamic);
   build(b, result, resultType, source, dynamicOffsets, dynamicSizes,
-        dynamicStrides, b.getI64ArrayAttr(staticOffsets),
-        b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
+        dynamicStrides, b.getDenseI64ArrayAttr(staticOffsets),
+        b.getDenseI64ArrayAttr(staticSizes),
+        b.getDenseI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 void ReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                               MemRefType resultType, Value source,
                               int64_t offset, ArrayRef<int64_t> sizes,
                               ArrayRef<int64_t> strides,
                               ArrayRef<NamedAttribute> attrs) {
LogicalResult ReinterpretCastOp::verify() {
   if (srcType.getMemorySpace() != resultType.getMemorySpace())
     return emitError("different memory spaces specified for source type ")
            << srcType << " and result memref type " << resultType;
   if (srcType.getElementType() != resultType.getElementType())
     return emitError("different element types specified for source type ")
            << srcType << " and result memref type " << resultType;
 
   // Match sizes in result memref type and in static_sizes attribute.
-  for (auto &en : llvm::enumerate(llvm::zip(
-           resultType.getShape(), extractFromI64ArrayAttr(getStaticSizes())))) {
+  for (auto &en :
+       llvm::enumerate(llvm::zip(resultType.getShape(), getStaticSizes()))) {
     int64_t resultSize = std::get<0>(en.value());
     int64_t expectedSize = std::get<1>(en.value());
     if (!ShapedType::isDynamic(resultSize) &&
         !ShapedType::isDynamic(expectedSize) && resultSize != expectedSize)
       return emitError("expected result type with size = ")
              << expectedSize << " instead of " << resultSize
              << " in dim = " << en.index();
   }
 
   // Match offset and strides in static_offset and static_strides attributes. If
   // result memref type has no affine map specified, this will assume an
   // identity layout.
   int64_t resultOffset;
   SmallVector<int64_t, 4> resultStrides;
   if (failed(getStridesAndOffset(resultType, resultStrides, resultOffset)))
     return emitError("expected result type to have strided layout but found ")
            << resultType;
 
   // Match offset in result memref type and in static_offsets attribute.
-  int64_t expectedOffset = extractFromI64ArrayAttr(getStaticOffsets()).front();
+  int64_t expectedOffset = getStaticOffsets().front();
   if (!ShapedType::isDynamic(resultOffset) &&
       !ShapedType::isDynamic(expectedOffset) &&
       resultOffset != expectedOffset)
     return emitError("expected result type with offset = ")
            << resultOffset << " instead of " << expectedOffset;
 
   // Match strides in result memref type and in static_strides attribute.
-  for (auto &en : llvm::enumerate(llvm::zip(
-           resultStrides, extractFromI64ArrayAttr(getStaticStrides())))) {
+  for (auto &en :
+       llvm::enumerate(llvm::zip(resultStrides, getStaticStrides()))) {
     int64_t resultStride = std::get<0>(en.value());
     int64_t expectedStride = std::get<1>(en.value());
     if (!ShapedType::isDynamic(resultStride) &&
         !ShapedType::isDynamic(expectedStride) &&
         resultStride != expectedStride)
       return emitError("expected result type with stride = ")
              << expectedStride << " instead of " << resultStride
              << " in dim = " << en.index();
void SubViewOp::build(OpBuilder &b, OperationState &result,
   auto sourceMemRefType = source.getType().cast<MemRefType>();
   // Structuring implementation this way avoids duplication between builders.
   if (!resultType) {
     resultType = SubViewOp::inferResultType(sourceMemRefType, staticOffsets,
                                             staticSizes, staticStrides)
                      .cast<MemRefType>();
   }
   build(b, result, resultType, source, dynamicOffsets, dynamicSizes,
-        dynamicStrides, b.getI64ArrayAttr(staticOffsets),
-        b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
+        dynamicStrides, b.getDenseI64ArrayAttr(staticOffsets),
+        b.getDenseI64ArrayAttr(staticSizes),
+        b.getDenseI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 // Build a SubViewOp with mixed static and dynamic entries and inferred result
 // type.
 void SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
                       ArrayRef<OpFoldResult> offsets,
                       ArrayRef<OpFoldResult> sizes,
return emitError("different memory spaces specified for base memref "
            << baseType << " and subview memref type " << subViewType;
 
   // Verify that the base memref type has a strided layout map.
   if (!isStrided(baseType))
     return emitError("base type ") << baseType << " is not strided";
 
   // Verify result type against inferred type.
   auto expectedType = SubViewOp::inferResultType(
-      baseType, extractFromI64ArrayAttr(getStaticOffsets()),
-      extractFromI64ArrayAttr(getStaticSizes()),
-      extractFromI64ArrayAttr(getStaticStrides()));
+      baseType, getStaticOffsets(), getStaticSizes(), getStaticStrides());
 
   auto result = isRankReducedMemRefType(expectedType.cast<MemRefType>(),
                                         subViewType, getMixedSizes());
   return produceSubViewErrorMsg(result, *this, expectedType);
 }
 
 raw_ostream &mlir::operator<<(raw_ostream &os, const Range &range) {
   return os << "range " << range.offset << ":" << range.size << ":"

mlir/lib/Dialect/MemRef/Transforms/MultiBuffer.cpp

if (!subviewUse) {
       // Save the operand to and replace outside the loop to not invalidate the
       // iterator.
       operandsToReplace.push_back(&use);
       continue;
     }
     builder.setInsertionPoint(subviewUse);
     Type newType = memref::SubViewOp::inferRankReducedResultType(
         subviewUse.getType().getShape(), val.getType().cast<MemRefType>(),
-        extractFromI64ArrayAttr(subviewUse.getStaticOffsets()),
-        extractFromI64ArrayAttr(subviewUse.getStaticSizes()),
-        extractFromI64ArrayAttr(subviewUse.getStaticStrides()));
+        subviewUse.getStaticOffsets(), subviewUse.getStaticSizes(),
+        subviewUse.getStaticStrides());
     Value newSubview = builder.create<memref::SubViewOp>(
         subviewUse->getLoc(), newType.cast<MemRefType>(), val,
         subviewUse.getMixedOffsets(), subviewUse.getMixedSizes(),
         subviewUse.getMixedStrides());
     replaceUsesAndPropagateType(subviewUse, newSubview, builder);
     opToDelete.push_back(use.getOwner());
   }
   for (OpOperand *operand : operandsToReplace)

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

if (!extractOperand || !canFoldIntoProducerOp(tensorCast) ||
         tensorCast.getType().getShape() == tensorCast.getSource()
                                                .getType()
                                                .cast<RankedTensorType>()
                                                .getShape())
       return failure();
 
     SmallVector<OpFoldResult, 4> sizes = extractOperand.getMixedSizes();
     auto dimMask = computeRankReductionMask(
-        extractFromI64ArrayAttr(extractOperand.getStaticSizes()),
-        extractOperand.getType().getShape());
+        extractOperand.getStaticSizes(), extractOperand.getType().getShape());
     size_t dimIndex = 0;
     for (size_t i = 0, e = sizes.size(); i < e; i++) {
       if (dimMask && dimMask->count(i))
         continue;
       int64_t dim = tensorCast.getType().getShape()[dimIndex++];
       if (ShapedType::isDynamic(dim))
         continue;
       sizes[i] = rewriter.getIndexAttr(dim);
void ExtractSliceOp::build(OpBuilder &b, OperationState &result,
   // Structuring implementation this way avoids duplication between builders.
   if (!resultType) {
     resultType =
         ExtractSliceOp::inferResultType(sourceRankedTensorType, staticOffsets,
                                         staticSizes, staticStrides)
             .cast<RankedTensorType>();
   }
   build(b, result, resultType, source, dynamicOffsets, dynamicSizes,
-        dynamicStrides, b.getI64ArrayAttr(staticOffsets),
-        b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
+        dynamicStrides, b.getDenseI64ArrayAttr(staticOffsets),
+        b.getDenseI64ArrayAttr(staticSizes),
+        b.getDenseI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 /// Build an ExtractSliceOp with mixed static and dynamic entries and inferred
 /// result type.
 void ExtractSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                            ArrayRef<OpFoldResult> offsets,
                            ArrayRef<OpFoldResult> sizes,
LogicalResult matchAndRewrite(ExtractSliceOp op,
     if (!controlFn(op))
       return failure();
 
     int64_t count = sourceType.getNumElements();
     if (count == 0)
       return failure();
 
     // Check if there are any dynamic parts, which are not supported.
-    auto offsets = extractFromI64ArrayAttr(op.getStaticOffsets());
+    auto offsets = op.getStaticOffsets();
     if (llvm::is_contained(offsets, ShapedType::kDynamic))
       return failure();
-    auto sizes = extractFromI64ArrayAttr(op.getStaticSizes());
+    auto sizes = op.getStaticSizes();
     if (llvm::is_contained(sizes, ShapedType::kDynamic))
       return failure();
-    auto strides = extractFromI64ArrayAttr(op.getStaticStrides());
+    auto strides = op.getStaticStrides();
     if (llvm::is_contained(strides, ShapedType::kDynamic))
       return failure();
 
     // Compute the stride for each dimension.
     SmallVector<int64_t> counts;
     ArrayRef<int64_t> shape = sourceType.getShape();
     counts.reserve(shape.size());
     for (int64_t v : shape) {
void InsertSliceOp::build(OpBuilder &b, OperationState &result, Value source,
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamic);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamic);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamic);
   build(b, result, dest.getType(), source, dest, dynamicOffsets, dynamicSizes,
-        dynamicStrides, b.getI64ArrayAttr(staticOffsets),
-        b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
+        dynamicStrides, b.getDenseI64ArrayAttr(staticOffsets),
+        b.getDenseI64ArrayAttr(staticSizes),
+        b.getDenseI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 /// Build an InsertSliceOp with mixed static and dynamic entries packed into a
 /// Range vector.
 void InsertSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                           Value dest, ArrayRef<Range> ranges,
                           ArrayRef<NamedAttribute> attrs) {
SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, source, dest, offsetValues, sizeValues, strideValues);
 }
 
 /// Rank-reducing type verification for both InsertSliceOp and
 /// ParallelInsertSliceOp.
-static SliceVerificationResult
-verifyInsertSliceOp(ShapedType srcType, ShapedType dstType,
-                    ArrayAttr staticOffsets, ArrayAttr staticSizes,
-                    ArrayAttr staticStrides,
-                    ShapedType *expectedType = nullptr) {
+static SliceVerificationResult verifyInsertSliceOp(
+    ShapedType srcType, ShapedType dstType, ArrayRef<int64_t> staticOffsets,
+    ArrayRef<int64_t> staticSizes, ArrayRef<int64_t> staticStrides,
   // insert_slice is the inverse of extract_slice, use the same type
   // inference.
   RankedTensorType expected = ExtractSliceOp::inferResultType(
-      dstType, extractFromI64ArrayAttr(staticOffsets),
-      extractFromI64ArrayAttr(staticSizes),
-      extractFromI64ArrayAttr(staticStrides));
+      dstType, staticOffsets, staticSizes, staticStrides);
   if (expectedType)
     *expectedType = expected;
   return isRankReducedType(expected, srcType);
 }
 
 /// Verifier for InsertSliceOp.
 LogicalResult InsertSliceOp::verify() {
   ShapedType expectedType;
ParseResult parseInferType(OpAsmParser &parser,
   if (optOperand)
     typeToInfer = typeToInferFrom;
   return success();
 }
 
 LogicalResult PadOp::verify() {
   auto sourceType = getSource().getType().cast<RankedTensorType>();
   auto resultType = getResult().getType().cast<RankedTensorType>();
-  auto expectedType = PadOp::inferResultType(
-      sourceType, extractFromI64ArrayAttr(getStaticLow()),
-      extractFromI64ArrayAttr(getStaticHigh()));
+  auto expectedType =
+      PadOp::inferResultType(sourceType, getStaticLow(), getStaticHigh());
   for (int i = 0, e = sourceType.getRank(); i < e; ++i) {
     if (resultType.getDimSize(i) == expectedType.getDimSize(i))
       continue;
     if (expectedType.isDynamicDim(i))
       continue;
     return emitError("specified type ")
            << resultType << " does not match the inferred type "
            << expectedType;

 }
 
 void PadOp::build(OpBuilder &b, OperationState &result, Value source,
                   ArrayRef<int64_t> staticLow, ArrayRef<int64_t> staticHigh,
                   ValueRange low, ValueRange high, bool nofold,
                   ArrayRef<NamedAttribute> attrs) {
   auto sourceType = source.getType().cast<RankedTensorType>();
   auto resultType = inferResultType(sourceType, staticLow, staticHigh);
-  build(b, result, resultType, source, low, high, b.getI64ArrayAttr(staticLow),
-        b.getI64ArrayAttr(staticHigh), nofold ? b.getUnitAttr() : UnitAttr());
+  build(b, result, resultType, source, low, high,
+        b.getDenseI64ArrayAttr(staticLow), b.getDenseI64ArrayAttr(staticHigh),
+        nofold ? b.getUnitAttr() : UnitAttr());
   result.addAttributes(attrs);
 }
 
 void PadOp::build(OpBuilder &b, OperationState &result, Value source,
                   ValueRange low, ValueRange high, bool nofold,
                   ArrayRef<NamedAttribute> attrs) {
   auto sourceType = source.getType().cast<RankedTensorType>();
   unsigned rank = sourceType.getRank();
dispatchIndexOpFoldResults(low, dynamicLow, staticLow,
                              ShapedType::kDynamic);
   dispatchIndexOpFoldResults(high, dynamicHigh, staticHigh,
                              ShapedType::kDynamic);
   if (!resultType) {
     resultType = PadOp::inferResultType(sourceType, staticLow, staticHigh);
   }
   assert(resultType.isa<RankedTensorType>());
   build(b, result, resultType, source, dynamicLow, dynamicHigh,
-        b.getI64ArrayAttr(staticLow), b.getI64ArrayAttr(staticHigh),
+        b.getDenseI64ArrayAttr(staticLow), b.getDenseI64ArrayAttr(staticHigh),
         nofold ? b.getUnitAttr() : UnitAttr());
   result.addAttributes(attrs);
 }
 
 void PadOp::build(OpBuilder &b, OperationState &result, Type resultType,
                   Value source, ArrayRef<OpFoldResult> low,
                   ArrayRef<OpFoldResult> high, Value constantPadValue,
                   bool nofold, ArrayRef<NamedAttribute> attrs) {
struct FoldSourceTensorCast : public OpRewritePattern<PadOp> {
   LogicalResult matchAndRewrite(PadOp padTensorOp,
                                 PatternRewriter &rewriter) const override {
     auto castOp = padTensorOp.getSource().getDefiningOp<tensor::CastOp>();
     if (!tensor::canFoldIntoConsumerOp(castOp))
       return failure();
 
     auto newResultType = PadOp::inferResultType(
         castOp.getSource().getType().cast<RankedTensorType>(),
-        extractFromI64ArrayAttr(padTensorOp.getStaticLow()),
-        extractFromI64ArrayAttr(padTensorOp.getStaticHigh()),
+        padTensorOp.getStaticLow(), padTensorOp.getStaticHigh(),
         padTensorOp.getResultType().getShape());
 
     if (newResultType == padTensorOp.getResultType()) {
       rewriter.updateRootInPlace(padTensorOp, [&]() {
         padTensorOp.getSourceMutable().assign(castOp.getSource());
       });
     } else {
       auto newOp = rewriter.create<PadOp>(
void ParallelInsertSliceOp::build(OpBuilder &b, OperationState &result,
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamic);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamic);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamic);
   build(b, result, {}, source, dest, dynamicOffsets, dynamicSizes,
-        dynamicStrides, b.getI64ArrayAttr(staticOffsets),
-        b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
+        dynamicStrides, b.getDenseI64ArrayAttr(staticOffsets),
+        b.getDenseI64ArrayAttr(staticSizes),
+        b.getDenseI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 /// Build an ParallelInsertSliceOp with mixed static and dynamic entries
 /// packed into a Range vector.
 void ParallelInsertSliceOp::build(OpBuilder &b, OperationState &result,
                                   Value source, Value dest,
                                   ArrayRef<Range> ranges,
for (auto i : llvm::seq<int64_t>(0, dimsToTile.size()))
     dimAndTileMapping[dimsToTile[i]] = tiles[i];
   return dimAndTileMapping;
 }
 
 template <typename OpTy>
 static SmallVector<OpFoldResult> getMixedTilesImpl(OpTy op) {
   static_assert(llvm::is_one_of<OpTy, PackOp, UnPackOp>::value,
                 "applies to only pack or unpack operations");
+  Builder builder(op);
   SmallVector<OpFoldResult> mixedInnerTiles;
   unsigned dynamicValIndex = 0;
-  for (Attribute attr : op.getStaticInnerTiles()) {
-    auto tileAttr = attr.cast<IntegerAttr>();
-    if (!ShapedType::isDynamic(tileAttr.getInt()))
-      mixedInnerTiles.push_back(tileAttr);
+  for (int64_t staticTile : op.getStaticInnerTiles()) {
+    if (!ShapedType::isDynamic(staticTile))
+      mixedInnerTiles.push_back(builder.getI64IntegerAttr(staticTile));
     else
       mixedInnerTiles.push_back(op.getInnerTiles()[dynamicValIndex++]);
   }
   return mixedInnerTiles;
 }
 
 template <typename OpTy>
 static SmallVector<int64_t> getStaticTilesImpl(OpTy op) {

mlir/lib/Dialect/Utils/StaticValueUtils.cpp

 /// `IntegerAttr`. No other attribute types are supported.
 SmallVector<Value> getAsValues(OpBuilder &b, Location loc,
                                ArrayRef<OpFoldResult> valueOrAttrVec) {
   return llvm::to_vector<4>(
       llvm::map_range(valueOrAttrVec, [&](OpFoldResult value) -> Value {
         return getValueOrCreateConstantIndexOp(b, loc, value);
       }));
 }
+
+/// Return a vector of OpFoldResults with the same size a staticValues, but all
+/// elements for which ShapedType::isDynamic is true, will be replaced by
+/// dynamicValues.
+SmallVector<OpFoldResult> getMixedValues(ArrayRef<int64_t> staticValues,
+                                         ValueRange dynamicValues, Builder &b) {
+  SmallVector<OpFoldResult> res;
+  res.reserve(staticValues.size());
+  unsigned numDynamic = 0;
+  unsigned count = static_cast<unsigned>(staticValues.size());
+  for (unsigned idx = 0; idx < count; ++idx) {
+    int64_t value = staticValues[idx];
+    res.push_back(ShapedType::isDynamic(value)
+                      ? OpFoldResult{dynamicValues[numDynamic++]}
+                      : OpFoldResult{b.getI64IntegerAttr(staticValues[idx])});
+  }
+  return res;
+}
+
+/// Decompose a vector of mixed static or dynamic values into the corresponding
+/// pair of arrays. This is the inverse function of `getMixedValues`.
+std::pair<ArrayAttr, SmallVector<Value>>
+decomposeMixedValues(Builder &b,
+                     const SmallVectorImpl<OpFoldResult> &mixedValues) {
+  SmallVector<int64_t> staticValues;
+  SmallVector<Value> dynamicValues;
+  for (const auto &it : mixedValues) {
+    if (it.is<Attribute>()) {
+      staticValues.push_back(it.get<Attribute>().cast<IntegerAttr>().getInt());
+    } else {
+      staticValues.push_back(ShapedType::kDynamic);
+      dynamicValues.push_back(it.get<Value>());
+    }
+  }
+  return {b.getI64ArrayAttr(staticValues), dynamicValues};
+}
+
 } // namespace mlir

mlir/lib/Interfaces/ViewLikeInterface.cpp

 //===----------------------------------------------------------------------===//
 
 /// Include the definitions of the loop-like interfaces.
 #include "mlir/Interfaces/ViewLikeInterface.cpp.inc"
 
 LogicalResult mlir::verifyListOfOperandsOrIntegers(Operation *op,
                                                    StringRef name,
                                                    unsigned numElements,
-                                                   ArrayAttr attr,
+                                                   ArrayRef<int64_t> staticVals,
                                                    ValueRange values) {
-  /// Check static and dynamic offsets/sizes/strides does not overflow type.
-  if (attr.size() != numElements)
+  // Check static and dynamic offsets/sizes/strides does not overflow type.
+  if (staticVals.size() != numElements)
     return op->emitError("expected ")
            << numElements << " " << name << " values";
   unsigned expectedNumDynamicEntries =
-      llvm::count_if(attr.getValue(), [&](Attribute attr) {
-        return ShapedType::isDynamic(attr.cast<IntegerAttr>().getInt());
+      llvm::count_if(staticVals, [&](int64_t staticVal) {
+        return ShapedType::isDynamic(staticVal);
       });
   if (values.size() != expectedNumDynamicEntries)
     return op->emitError("expected ")
            << expectedNumDynamicEntries << " dynamic " << name << " values";
   return success();
 }
 
 LogicalResult
if (failed(verifyListOfOperandsOrIntegers(op, "size", maxRanks[1],
     return failure();
   if (failed(verifyListOfOperandsOrIntegers(op, "stride", maxRanks[2],
                                             op.static_strides(), op.strides())))
     return failure();
   return success();
 }
 
 void mlir::printDynamicIndexList(OpAsmPrinter &printer, Operation *op,
-                                 OperandRange values, ArrayAttr integers) {
+                                 OperandRange values,
+                                 ArrayRef<int64_t> integers) {
   printer << '[';
   if (integers.empty()) {
     printer << "]";
     return;
   }
   unsigned idx = 0;
-  llvm::interleaveComma(integers, printer, [&](Attribute a) {
-    int64_t val = a.cast<IntegerAttr>().getInt();
-    if (ShapedType::isDynamic(val))
+  llvm::interleaveComma(integers, printer, [&](int64_t integer) {
+    if (ShapedType::isDynamic(integer))
       printer << values[idx++];
     else
-      printer << val;
+      printer << integer;
   });
   printer << ']';
 }
 
 ParseResult mlir::parseDynamicIndexList(
     OpAsmParser &parser,
     SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
-    ArrayAttr &integers) {
+    DenseI64ArrayAttr &integers) {
   if (failed(parser.parseLSquare()))
     return failure();
   // 0-D.
   if (succeeded(parser.parseOptionalRSquare())) {
-    integers = parser.getBuilder().getArrayAttr({});
+    integers = parser.getBuilder().getDenseI64ArrayAttr({});
     return success();
   }
 
-  SmallVector<int64_t, 4> attrVals;
+  SmallVector<int64_t, 4> integerVals;
   while (true) {
     OpAsmParser::UnresolvedOperand operand;
     auto res = parser.parseOptionalOperand(operand);
     if (res.has_value() && succeeded(res.value())) {
       values.push_back(operand);
-      attrVals.push_back(ShapedType::kDynamic);
+      integerVals.push_back(ShapedType::kDynamic);
     } else {
-      IntegerAttr attr;
-      if (failed(parser.parseAttribute<IntegerAttr>(attr)))
+      int64_t integer;
+      if (failed(parser.parseInteger(integer)))
         return parser.emitError(parser.getNameLoc())
                << "expected SSA value or integer";
-      attrVals.push_back(attr.getInt());
+      integerVals.push_back(integer);
     }
 
     if (succeeded(parser.parseOptionalComma()))
       continue;
     if (failed(parser.parseRSquare()))
       return failure();
     break;
   }
-  integers = parser.getBuilder().getI64ArrayAttr(attrVals);
+  integers = parser.getBuilder().getDenseI64ArrayAttr(integerVals);
   return success();
 }
 
 bool mlir::detail::sameOffsetsSizesAndStrides(
     OffsetSizeAndStrideOpInterface a, OffsetSizeAndStrideOpInterface b,
     llvm::function_ref<bool(OpFoldResult, OpFoldResult)> cmp) {
   if (a.static_offsets().size() != b.static_offsets().size())
     return false;
   if (a.static_sizes().size() != b.static_sizes().size())
     return false;
   if (a.static_strides().size() != b.static_strides().size())
     return false;
   for (auto it : llvm::zip(a.getMixedOffsets(), b.getMixedOffsets()))
     if (!cmp(std::get<0>(it), std::get<1>(it)))
       return false;
   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;
 }
-
-SmallVector<OpFoldResult, 4> mlir::getMixedValues(ArrayAttr staticValues,
-                                                  ValueRange dynamicValues) {
-  SmallVector<OpFoldResult, 4> res;
-  res.reserve(staticValues.size());
-  unsigned numDynamic = 0;
-  unsigned count = static_cast<unsigned>(staticValues.size());
-  for (unsigned idx = 0; idx < count; ++idx) {
-    APInt value = staticValues[idx].cast<IntegerAttr>().getValue();
-    res.push_back(ShapedType::isDynamic(value.getSExtValue())
-                      ? OpFoldResult{dynamicValues[numDynamic++]}
-                      : OpFoldResult{staticValues[idx]});
-  }
-  return res;
-}
-
-std::pair<ArrayAttr, SmallVector<Value>>
-mlir::decomposeMixedValues(Builder &b,
-                           const SmallVectorImpl<OpFoldResult> &mixedValues) {
-  SmallVector<int64_t> staticValues;
-  SmallVector<Value> dynamicValues;
-  for (const auto &it : mixedValues) {
-    if (it.is<Attribute>()) {
-      staticValues.push_back(it.get<Attribute>().cast<IntegerAttr>().getInt());
-    } else {
-      staticValues.push_back(ShapedType::kDynamic);
-      dynamicValues.push_back(it.get<Value>());
-    }
-  }
-  return {b.getI64ArrayAttr(staticValues), dynamicValues};
-}

mlir/python/mlir/dialects/_structured_transform_ops_ext.py

) -> ArrayAttr:
   """
   if values is None:
     return ArrayAttr.get([])
   if isinstance(values, ArrayAttr):
     return values
 
   return ArrayAttr.get([_get_int64_attr(v) for v in values])
 
+def _get_dense_int_array_attr(
+        values: Sequence[int]) -> DenseI64ArrayAttr:
+    """Creates a dense integer array from a sequence of integers.
+    Expects the thread-local MLIR context to have been set by the context 
+    manager.
+    """
+    if values is None:
+        return DenseI64ArrayAttr.get([])
+    return DenseI64ArrayAttr.get(values)
 
 def _get_int_int_array_attr(
     values: Optional[Union[ArrayAttr, Sequence[Union[ArrayAttr,
                                                      IntOrAttrList]]]]
 ) -> ArrayAttr:
   """Creates an array attribute containing array attributes of integers.
 
   If the operand is already an array attribute, forwards it. Otherwise treats
def __init__(self,
 
     static_sizes = []
     dynamic_sizes = []
     if isinstance(sizes, ArrayAttr):
       sizes_attr = sizes
     else:
       for size in sizes:
         if isinstance(size, int):
-          static_sizes.append(IntegerAttr.get(i64_type, size))
-        elif isinstance(size, IntegerAttr):
           static_sizes.append(size)
         else:
-          static_sizes.append(
-              IntegerAttr.get(i64_type, ShapedType.get_dynamic_size()))
+          static_sizes.append(ShapedType.get_dynamic_size())
           dynamic_sizes.append(_get_op_result_or_value(size))
-      sizes_attr = ArrayAttr.get(static_sizes)
+      sizes_attr = DenseI64ArrayAttr.get(static_sizes)
 
     num_loops = sum(
         v if v == 0 else 1 for v in self.__extract_values(sizes_attr))
     super().__init__(
         pdl_operation_type, [pdl_operation_type] * num_loops,
         _get_op_result_or_value(target),
         dynamic_sizes=dynamic_sizes,
         static_sizes=sizes_attr,
-        interchange=_get_int_array_attr(interchange) if interchange else None,
+        interchange=_get_dense_int_array_attr(interchange) if interchange else None,
         loc=loc,
         ip=ip)
 
-  def __extract_values(self, attr: Optional[ArrayAttr]) -> List[int]:
+  def __extract_values(self, attr: Optional[DenseI64ArrayAttr]) -> List[int]:
     if not attr:
       return []
-    return [IntegerAttr(element).value for element in attr]
+    return [element for element in attr]
 
 
 class VectorizeOp:
   """Specialization for VectorizeOp class."""
 
   def __init__(self,
                target: Union[Operation, Value],
                *,

mlir/test/Dialect/Linalg/transform-patterns.mlir

^bb(%a: f32, %b: f32, %c: f32):
       linalg.yield %e: f32
   }
   return
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%arg1: !pdl.operation):
   %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
-  transform.structured.interchange %0 { iterator_interchange = [1, 2, 0]}
+  transform.structured.interchange %0 {iterator_interchange = [1, 2, 0]}
 }
 
 // CHECK-LABEL:  func @permute_generic
 // CHECK:        linalg.generic {
 // CHECK-SAME:   indexing_maps = [#[[$kn]], #[[$nm]], #[[$km]]],
 // CHECK-SAME:   iterator_types = ["parallel", "reduction", "parallel"],
 // CHECK-SAME:   library_call = "linalg_matmul"}
 // CHECK:          memref<?x?xf32, strided<[?, 1], offset: ?>>,
linalg.matvec ins(%A, %x: memref<?x?xf32, strided<[?, 1], offset: ?>>,
                             memref<?xf32, strided<[1], offset: ?>>)
                outs(%y: memref<?xf32, strided<[1], offset: ?>>)
   return
 }
 
 transform.sequence failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matvec"]} in %arg1
-    %1, %loops:2 = transform.structured.tile %0 [5, 6] {interchange = [1, 0]}
+    %1, %loops:2 = transform.structured.tile %0 [5, 6] {interchange = array<i64: 1, 0>}
 }
 
 // CHECK-LABEL: func @matvec_perm
 // CHECK-DAG:     %[[c0:.*]] = arith.constant 0 : index
 // CHECK-DAG:     %[[c5:.*]] = arith.constant 5 : index
 // CHECK-DAG:     %[[c6:.*]] = arith.constant 6 : index
 // CHECK:         scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c6]]
 // CHECK:           scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c5]]
linalg.matmul ins(%A, %B: memref<?x?xf32, strided<[?, 1], offset: ?>>,
                             memref<?x?xf32, strided<[?, 1], offset: ?>>)
                outs(%C : memref<?x?xf32, strided<[?, 1], offset: ?>>)
   return
 }
 
 transform.sequence failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
-    %1, %loops:3 = transform.structured.tile %0 [2000, 3000, 4000] {interchange=[1, 2, 0]}
-    %2, %loops_2:3 = transform.structured.tile %1 [200, 300, 400] {interchange=[1, 0, 2]}
+    %1, %loops:3 = transform.structured.tile %0 [2000, 3000, 4000] {interchange = array<i64: 1, 2, 0>}
+    %2, %loops_2:3 = transform.structured.tile %1 [200, 300, 400] {interchange = array<i64: 1, 0, 2>}
     %3, %loops_3:3 = transform.structured.tile %2 [20, 30, 40]
 }
 
 // CHECK-LABEL: func @matmul_perm
 // CHECK-DAG:     %[[c0:.*]] = arith.constant 0 : index
 // CHECK-DAG:     %[[c20:.*]] = arith.constant 20 : index
 // CHECK-DAG:     %[[c30:.*]] = arith.constant 30 : index
 // CHECK-DAG:     %[[c40:.*]] = arith.constant 40 : index

mlir/test/python/dialects/transform_structured_ext.py

with InsertionPoint(sequence.body):
     split = structured.SplitOp(sequence.bodyTarget, dimension=1, split_point=42)
     structured.SplitOp(
         split.results[0], dimension=3, split_point=split.results[1])
     transform.YieldOp()
   # CHECK-LABEL: TEST: testSplit
   # CHECK: %[[F:.+]], %[[S:.+]] = transform.structured.split %{{.*}} after 42 {dimension = 1
   # CHECK: transform.structured.split %[[F]] after %[[S]] {dimension = 3
 
-
 @run
 def testTileCompact():
   sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE, [], pdl.OperationType.get())
   with InsertionPoint(sequence.body):
     structured.TileOp(sequence.bodyTarget, sizes=[4, 8], interchange=[0, 1])
     transform.YieldOp()
   # CHECK-LABEL: TEST: testTileCompact
   # CHECK: transform.sequence
   # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.tile %{{.*}}[4, 8]
-  # CHECK: interchange = [0, 1]
-
+  # CHECK: interchange = array<i64: 0, 1>
 
 @run
 def testTileAttributes():
   sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE, [], pdl.OperationType.get())
-  attr = ArrayAttr.get(
-      [IntegerAttr.get(IntegerType.get_signless(64), x) for x in [4, 8]])
-  ichange = ArrayAttr.get(
-      [IntegerAttr.get(IntegerType.get_signless(64), x) for x in [0, 1]])
+  attr = DenseI64ArrayAttr.get([4, 8])
+  ichange = DenseI64ArrayAttr.get([0, 1])
   with InsertionPoint(sequence.body):
     structured.TileOp(sequence.bodyTarget, sizes=attr, interchange=ichange)
     transform.YieldOp()
   # CHECK-LABEL: TEST: testTileAttributes
   # CHECK: transform.sequence
   # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.tile %{{.*}}[4, 8]
-  # CHECK: interchange = [0, 1]
-
+  # CHECK: interchange = array<i64: 0, 1>
 
 @run
 def testTileZero():
   sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE, [], pdl.OperationType.get())
   with InsertionPoint(sequence.body):
     structured.TileOp(
         sequence.bodyTarget, sizes=[4, 0, 2, 0], interchange=[0, 1, 2, 3])
     transform.YieldOp()
   # CHECK-LABEL: TEST: testTileZero
   # CHECK: transform.sequence
   # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.tile %{{.*}}[4, 0, 2, 0]
-  # CHECK: interchange = [0, 1, 2, 3]
-
+  # CHECK: interchange = array<i64: 0, 1, 2, 3>
 
 @run
 def testTileDynamic():
   with_pdl = transform.WithPDLPatternsOp(pdl.OperationType.get())
   with InsertionPoint(with_pdl.body):
     sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE, [],
                                     with_pdl.bodyTarget)
     with InsertionPoint(sequence.body):