[mlir][vector] Use DenseI64ArrayAttr for ExtractOp/InsertOp positions

[springerm]

Summary

DenseI64ArrayAttr provides a better API than I64ArrayAttr. E.g., accessors returning ArrayRef<int64_t> (instead of ArrayAttr) are generated.

[nicolasvasilache]

Great, thanks much for the cleanup!

[dcaballe]

I'm currently working on extending ExtractOp/InsertOp to support Value indices. I should be able to have something this week. Is this change blocking you? If not, it would help if we can revert it and wait for my change so that I don't have to deal with all the conflicts, as I'm touching the exact same lines and more. Do you think that would be feasible?

[springerm]

Can you explain a bit how you are planning to change these ops? I think it was on purpose that these ops only support static indices. How does this lower to LLVM? There are comments such as this, which sounds like it may not be possible to lower such ops to LLVM without bigger changes:

In VectorToSCF.h
[...]
/// This is consistent with the lack of an LLVM instruction to dynamically
/// index into an aggregate (see the Vector dialect lowering to LLVM deep dive).

(Also see https://mlir.llvm.org/docs/Dialects/Vector/#deeperdive.)

Also, how are vectors different from tensors after this change? At the moment, one main difference is that tensors can be indexed dynamically (vector cannot).

If we actually need Value indices, can we make these mixed static/dynamic? Like tensor.extract_slice, tensor.insert_slice, memref.subview, etc. These accept a mix of SSA values and int64_t. This composes better with the remaining OpFoldResult/getMixedSizes/OpBuilder::createOrFold/affine::makeComposedFoldedAffineApply/... APIs that we have throughout MLIR. If we have only Value indices, we have to create many arith.constant ops. E.g., this is happening at moment when unrolling n-D vector transfers with VectorToSCF because many vector ops do not yet support "mixed" indices.

We can add a new interface called MixedIndicesOpInterface to ViewLikeInterfaces.td that is like OffsetSizeAndStrideOpInterface but has only one offsets/indices, but no sizes or strides. This change here would actually be the first step towards that direction, because the static offsets should be a DenseI64ArrayAttr.

[dcaballe]

In D156684#4547806, @springerm wrote:

Can you explain a bit how you are planning to change these ops?

The following links should give you enough context about the motivation:

https://discourse.llvm.org/t/rfc-psa-remove-vector-extractelement-and-vector-insertelement-ops-in-favor-of-vector-extract-and-vector-insert-ops/71116/5
https://reviews.llvm.org/D155034

I think it was on purpose that these ops only support static indices. How does this lower to LLVM? There are comments such as this, which sounds like it may not be possible to lower such ops to LLVM without bigger changes:

LLVM shouldn't be a limitation for what we can model at MLIR level, esp. now that we have "real" 2D vector operations in MLIR, such as SME.

Also, how are vectors different from tensors after this change? At the moment, one main difference is that tensors can be indexed dynamically (vector cannot).

We can insert/extract elements from dynamic positions even in LLVM, right? https://llvm.org/docs/LangRef.html#extractvalue-instruction

If we actually need Value indices, can we make these mixed static/dynamic? Like tensor.extract_slice, tensor.insert_slice, memref.subview, etc. These accept a mix of SSA values and int64_t. This composes better with the remaining OpFoldResult/getMixedSizes/OpBuilder::createOrFold/affine::makeComposedFoldedAffineApply/... APIs that we have throughout MLIR. If we have only Value indices, we have to create many arith.constant ops. E.g., this is happening at moment when unrolling n-D vector transfers with VectorToSCF because many vector ops do not yet support "mixed" indices.

We can add a new interface called MixedIndicesOpInterface to ViewLikeInterfaces.td that is like OffsetSizeAndStrideOpInterface but has only one offsets/indices, but no sizes or strides. This change here would actually be the first step towards that direction, because the static offsets should be a DenseI64ArrayAttr.

Yeah, using mixed static/dynamic indices was pointed out in the review and I have all of that implemented locally. I don't have the interface refactoring, though, which is something we can introduce after the fact. However, if you think you have cycles to help with the interface refactoring I would be more than happy to refactor what I have on top of that :).

Hopefully it makes more sense now!

[springerm]

We can insert/extract elements from dynamic positions even in LLVM, right? https://llvm.org/docs/LangRef.html#extractvalue-instruction

This instruction won't work for LLVM vectors:

The ‘extractvalue’ instruction extracts the value of a member field from an aggregate value.
[...]
Aggregate Types are a subset of derived types that can contain multiple member types. Arrays and structs are aggregate types. Vectors are not considered to be aggregate types.

Also, the indices must be static:

The other operands are constant indices to specify which value to extract in a similar manner as indices in a ‘getelementptr’ instruction.

In D155034 (mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp), you are currently using convertConstantsToInts, so there is an implicit assumption that all indices are static when lowering to LLVM.

Yeah, using mixed static/dynamic indices was pointed out in the review and I have all of that implemented locally. I don't have the interface refactoring, though, which is something we can introduce after the fact. However, if you think you have cycles to help with the interface refactoring I would be more than happy to refactor what I have on top of that :).

I can add that tomorrow.

[dcaballe]

Sorry, I sent you the wrong link. This is it: https://llvm.org/docs/LangRef.html#extractelement-instruction
From which I wanted to point to: The second operand is an index indicating the position from which to extract the element. The index may be a variable of any integer type, and will be treated as an unsigned integer.

D155034 is not up-to-date. I have a version locally that works with variable indices.

The LLVM lowering expects constant indices, which is fine. We will reject those ops without constant indices when it comes to lowering to LLVM but we will have a single op to represent vector extraction regardless of the number of vector dimensions. We currently have duplicated patterns in MLIR, for vector.extract and for vector.extractelement, which is a pain.

Thanks for helping with this!

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

def Vector_ExtractElementOp :
   let hasFolder = 1;
 }
 
 def Vector_ExtractOp :
   Vector_Op<"extract", [Pure,
      PredOpTrait<"operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      InferTypeOpAdaptorWithIsCompatible]>,
-    Arguments<(ins AnyVectorOfAnyRank:$vector, I64ArrayAttr:$position)>,
+    Arguments<(ins AnyVectorOfAnyRank:$vector, DenseI64ArrayAttr:$position)>,
     Results<(outs AnyType)> {
   let summary = "extract operation";
   let description = [{
     Takes an n-D vector and a k-D position and extracts the (n-k)-D vector at
     the proper position. Degenerates to an element type if n-k is zero.
 
     Example:
 
     ```mlir
     %1 = vector.extract %0[3]: vector<4x8x16xf32>
     %2 = vector.extract %0[3, 3, 3]: vector<4x8x16xf32>
     %3 = vector.extract %1[]: vector<f32>
     ```
   }];
   let builders = [
-    OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$position)>,
     // Convenience builder which assumes the values in `position` are defined by
     // ConstantIndexOp.
     OpBuilder<(ins "Value":$source, "ValueRange":$position)>
   ];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
       return ::llvm::cast<VectorType>(getVector().getType());
     }
def Vector_InsertElementOp :
   let hasFolder = 1;
 }
 
 def Vector_InsertOp :
   Vector_Op<"insert", [Pure,
      PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      AllTypesMatch<["dest", "res"]>]>,
-     Arguments<(ins AnyType:$source, AnyVectorOfAnyRank:$dest, I64ArrayAttr:$position)>,
+     Arguments<(ins AnyType:$source, AnyVectorOfAnyRank:$dest, DenseI64ArrayAttr:$position)>,
      Results<(outs AnyVectorOfAnyRank:$res)> {
   let summary = "insert operation";
   let description = [{
     Takes an n-D source vector, an (n+k)-D destination vector and a k-D position
     and inserts the n-D source into the (n+k)-D destination at the proper
     position. Degenerates to a scalar or a 0-d vector source type when n = 0.
 
     Example:
 
     ```mlir
     %2 = vector.insert %0, %1[3] : vector<8x16xf32> into vector<4x8x16xf32>
     %5 = vector.insert %3, %4[3, 3, 3] : f32 into vector<4x8x16xf32>
     %8 = vector.insert %6, %7[] : f32 into vector<f32>
     %11 = vector.insert %9, %10[3, 3, 3] : vector<f32> into vector<4x8x16xf32>
     ```
   }];
   let assemblyFormat = [{
     $source `,` $dest $position attr-dict `:` type($source) `into` type($dest)
   }];
 
   let builders = [
-    OpBuilder<(ins "Value":$source, "Value":$dest,
-      "ArrayRef<int64_t>":$position)>,
     // Convenience builder which assumes all values are constant indices.
     OpBuilder<(ins "Value":$source, "Value":$dest, "ValueRange":$position)>
   ];
   let extraClassDeclaration = [{
     Type getSourceType() { return getSource().getType(); }
     VectorType getDestVectorType() {
       return ::llvm::cast<VectorType>(getDest().getType());
     }

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

for (int i = 0; i < vectorType.getShape()[0]; i++) {
           loc, rewriter.getIndexType(),
           rewriter.getIndexAttr(i * regInfo->elementsPerRegister));
       SmallVector<Value, 4> newIndices;
       getXferIndices<vector::TransferReadOp>(
           rewriter, op, *coords, {laneId, logicalValueId}, newIndices);
 
       Value el = rewriter.create<vector::LoadOp>(loc, loadedElType,
                                                  op.getSource(), newIndices);
-      result = rewriter.create<vector::InsertOp>(loc, el, result,
-                                                 rewriter.getI64ArrayAttr(i));
+      result = rewriter.create<vector::InsertOp>(loc, el, result, i);
     }
   } else {
     if (auto vecType = dyn_cast<VectorType>(loadedElType)) {
       loadedElType = vecType.getElementType();
     }
     for (int i = 0; i < vectorType.getShape()[0]; i++) {
       for (unsigned innerIdx = 0; innerIdx < vectorType.getShape()[1];
            innerIdx++) {
 
         Value logicalValueId = rewriter.create<arith::ConstantOp>(
             loc, rewriter.getIndexType(),
             rewriter.getIndexAttr(i * regInfo->elementsPerRegister + innerIdx));
         FailureOr<AffineMap> coords = nvgpu::getLaneIdAndValueIdToOperandCoord(
             rewriter, op.getLoc(), *warpMatrixInfo);
         if (failed(coords))
           return rewriter.notifyMatchFailure(op, "no coords");
 
         SmallVector<Value, 4> newIndices;
         getXferIndices<vector::TransferReadOp>(
             rewriter, op, *coords, {laneId, logicalValueId}, newIndices);
         Value el = rewriter.create<memref::LoadOp>(op.getLoc(), loadedElType,
                                                    op.getSource(), newIndices);
         result = rewriter.create<vector::InsertOp>(
-            op.getLoc(), el, result, rewriter.getI64ArrayAttr({i, innerIdx}));
+            op.getLoc(), el, result, ArrayRef<int64_t>{i, innerIdx});
       }
     }
   }
 
   valueMapping[op.getResult()] = result;
   return success();
 }
 

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

public:
   using ConvertOpToLLVMPattern<vector::ExtractOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(vector::ExtractOp extractOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = extractOp->getLoc();
     auto resultType = extractOp.getResult().getType();
     auto llvmResultType = typeConverter->convertType(resultType);
-    auto positionArrayAttr = extractOp.getPosition();
+    ArrayRef<int64_t> positionArray = extractOp.getPosition();
 
     // Bail if result type cannot be lowered.
     if (!llvmResultType)
       return failure();
 
     // Extract entire vector. Should be handled by folder, but just to be safe.
-    if (positionArrayAttr.empty()) {
+    if (positionArray.empty()) {
       rewriter.replaceOp(extractOp, adaptor.getVector());
       return success();
     }
 
     // One-shot extraction of vector from array (only requires extractvalue).
     if (isa<VectorType>(resultType)) {
-      SmallVector<int64_t> indices;
-      for (auto idx : positionArrayAttr.getAsRange<IntegerAttr>())
-        indices.push_back(idx.getInt());
       Value extracted = rewriter.create<LLVM::ExtractValueOp>(
-          loc, adaptor.getVector(), indices);
+          loc, adaptor.getVector(), positionArray);
       rewriter.replaceOp(extractOp, extracted);
       return success();
     }
 
     // Potential extraction of 1-D vector from array.
     Value extracted = adaptor.getVector();
-    auto positionAttrs = positionArrayAttr.getValue();
-    if (positionAttrs.size() > 1) {
-      SmallVector<int64_t> nMinusOnePosition;
-      for (auto idx : positionAttrs.drop_back())
-        nMinusOnePosition.push_back(cast<IntegerAttr>(idx).getInt());
-      extracted = rewriter.create<LLVM::ExtractValueOp>(loc, extracted,
-                                                        nMinusOnePosition);
+    if (positionArray.size() > 1) {
+      extracted = rewriter.create<LLVM::ExtractValueOp>(
+          loc, extracted, positionArray.drop_back());
     }
 
     // Remaining extraction of element from 1-D LLVM vector
-    auto position = cast<IntegerAttr>(positionAttrs.back());
     auto i64Type = IntegerType::get(rewriter.getContext(), 64);
-    auto constant = rewriter.create<LLVM::ConstantOp>(loc, i64Type, position);
+    auto constant =
+        rewriter.create<LLVM::ConstantOp>(loc, i64Type, positionArray.back());
     extracted =
         rewriter.create<LLVM::ExtractElementOp>(loc, extracted, constant);
     rewriter.replaceOp(extractOp, extracted);
 
     return success();
   }
 };
 
public:
 
   LogicalResult
   matchAndRewrite(vector::InsertOp insertOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = insertOp->getLoc();
     auto sourceType = insertOp.getSourceType();
     auto destVectorType = insertOp.getDestVectorType();
     auto llvmResultType = typeConverter->convertType(destVectorType);
-    auto positionArrayAttr = insertOp.getPosition();
+    ArrayRef<int64_t> positionArray = insertOp.getPosition();
 
     // Bail if result type cannot be lowered.
     if (!llvmResultType)
       return failure();
 
     // Overwrite entire vector with value. Should be handled by folder, but
     // just to be safe.
-    if (positionArrayAttr.empty()) {
+    if (positionArray.empty()) {
       rewriter.replaceOp(insertOp, adaptor.getSource());
       return success();
     }
 
     // One-shot insertion of a vector into an array (only requires insertvalue).
     if (isa<VectorType>(sourceType)) {
       Value inserted = rewriter.create<LLVM::InsertValueOp>(
-          loc, adaptor.getDest(), adaptor.getSource(),
-          LLVM::convertArrayToIndices(positionArrayAttr));
+          loc, adaptor.getDest(), adaptor.getSource(), positionArray);
       rewriter.replaceOp(insertOp, inserted);
       return success();
     }
 
     // Potential extraction of 1-D vector from array.
     Value extracted = adaptor.getDest();
-    auto positionAttrs = positionArrayAttr.getValue();
-    auto position = cast<IntegerAttr>(positionAttrs.back());
     auto oneDVectorType = destVectorType;
-    if (positionAttrs.size() > 1) {
+    if (positionArray.size() > 1) {
       oneDVectorType = reducedVectorTypeBack(destVectorType);
       extracted = rewriter.create<LLVM::ExtractValueOp>(
-          loc, extracted,
-          LLVM::convertArrayToIndices(positionAttrs.drop_back()));
+          loc, extracted, positionArray.drop_back());
     }
 
     // Insertion of an element into a 1-D LLVM vector.
     auto i64Type = IntegerType::get(rewriter.getContext(), 64);
-    auto constant = rewriter.create<LLVM::ConstantOp>(loc, i64Type, position);
+    auto constant =
+        rewriter.create<LLVM::ConstantOp>(loc, i64Type, positionArray.back());
     Value inserted = rewriter.create<LLVM::InsertElementOp>(
         loc, typeConverter->convertType(oneDVectorType), extracted,
         adaptor.getSource(), constant);
 
     // Potential insertion of resulting 1-D vector into array.
-    if (positionAttrs.size() > 1) {
+    if (positionArray.size() > 1) {
       inserted = rewriter.create<LLVM::InsertValueOp>(
-          loc, adaptor.getDest(), inserted,
-          LLVM::convertArrayToIndices(positionAttrs.drop_back()));
+          loc, adaptor.getDest(), inserted, positionArray.drop_back());
     }
 
     rewriter.replaceOp(insertOp, inserted);
     return success();
   }
 };
 
 /// Lower vector.scalable.insert ops to LLVM vector.insert

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

vector::InsertOp getInsertOp(TransferReadOp xferOp) const {
 
     return vector::InsertOp();
   }
 
   /// If the result of the TransferReadOp has exactly one user, which is a
   /// vector::InsertOp, return that operation's indices.
   void getInsertionIndices(TransferReadOp xferOp,
                            SmallVector<int64_t, 8> &indices) const {
-    if (auto insertOp = getInsertOp(xferOp)) {
-      for (Attribute attr : insertOp.getPosition())
-        indices.push_back(dyn_cast<IntegerAttr>(attr).getInt());
-    }
+    if (auto insertOp = getInsertOp(xferOp))
+      indices.assign(insertOp.getPosition().begin(),
+                     insertOp.getPosition().end());
   }
 
   /// Rewrite the op: Unpack one dimension. Can handle masks, out-of-bounds
   /// accesses, and broadcasts and transposes in permutation maps.
   LogicalResult matchAndRewrite(TransferReadOp xferOp,
                                 PatternRewriter &rewriter) const override {
     if (xferOp.getVectorType().getRank() <= options.targetRank)
       return failure();
if (auto *op = xferOp.getVector().getDefiningOp())
       return dyn_cast<vector::ExtractOp>(op);
     return vector::ExtractOp();
   }
 
   /// If the input of the given TransferWriteOp is an ExtractOp, return its
   /// indices.
   void getExtractionIndices(TransferWriteOp xferOp,
                             SmallVector<int64_t, 8> &indices) const {
-    if (auto extractOp = getExtractOp(xferOp)) {
-      for (Attribute attr : extractOp.getPosition())
-        indices.push_back(dyn_cast<IntegerAttr>(attr).getInt());
-    }
+    if (auto extractOp = getExtractOp(xferOp))
+      indices.assign(extractOp.getPosition().begin(),
+                     extractOp.getPosition().end());
   }
 
   /// Rewrite the op: Unpack one dimension. Can handle masks, out-of-bounds
   /// accesses, and broadcasts and transposes in permutation maps.
   LogicalResult matchAndRewrite(TransferWriteOp xferOp,
                                 PatternRewriter &rewriter) const override {
     if (xferOp.getVectorType().getRank() <= options.targetRank)
       return failure();

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

matchAndRewrite(vector::ExtractOp extractOp, OpAdaptor adaptor,
     if (!dstType)
       return failure();
 
     if (isa<spirv::ScalarType>(adaptor.getVector().getType())) {
       rewriter.replaceOp(extractOp, adaptor.getVector());
       return success();
     }
 
-    int32_t id = getFirstIntValue(extractOp.getPosition());
+    int32_t id = extractOp.getPosition()[0];
     rewriter.replaceOpWithNewOp<spirv::CompositeExtractOp>(
         extractOp, adaptor.getVector(), id);
     return success();
   }
 };
 
 struct VectorExtractStridedSliceOpConvert final
     : public OpConversionPattern<vector::ExtractStridedSliceOp> {
matchAndRewrite(vector::InsertOp insertOp, OpAdaptor adaptor,
 
     // Special case for inserting scalar values into size-1 vectors.
     if (insertOp.getSourceType().isIntOrFloat() &&
         insertOp.getDestVectorType().getNumElements() == 1) {
       rewriter.replaceOp(insertOp, adaptor.getSource());
       return success();
     }
 
-    int32_t id = getFirstIntValue(insertOp.getPosition());
+    int32_t id = insertOp.getPosition()[0];
     rewriter.replaceOpWithNewOp<spirv::CompositeInsertOp>(
         insertOp, adaptor.getSource(), adaptor.getDest(), id);
     return success();
   }
 };
 
 struct VectorExtractElementOpConvert final
     : public OpConversionPattern<vector::ExtractElementOp> {

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

if (auto dstVecType = dyn_cast<VectorType>(reductionOp.getDestType())) {
             VectorType::get(dstVecType.getShape(), rewriter.getI1Type());
         mask = rewriter.create<vector::ShapeCastOp>(loc, newMaskType, mask);
       }
       cast = rewriter.create<vector::ShapeCastOp>(
           loc, reductionOp.getDestType(), reductionOp.getSource());
     } else {
       // This means we are reducing all the dimensions, and all reduction
       // dimensions are of size 1. So a simple extraction would do.
-      auto zeroAttr =
-          rewriter.getI64ArrayAttr(SmallVector<int64_t>(shape.size(), 0));
+      SmallVector<int64_t> zeroAttr(shape.size(), 0);
       if (mask)
         mask = rewriter.create<vector::ExtractOp>(loc, rewriter.getI1Type(),
                                                   mask, zeroAttr);
       cast = rewriter.create<vector::ExtractOp>(
           loc, reductionOp.getDestType(), reductionOp.getSource(), zeroAttr);
     }
 
     Value result = vector::makeArithReduction(
LogicalResult matchAndRewrite(ReductionOp reductionOp,
     Location loc = reductionOp.getLoc();
     Value result;
     if (vectorType.getRank() == 0) {
       if (mask)
         mask = rewriter.create<ExtractElementOp>(loc, mask);
       result = rewriter.create<ExtractElementOp>(loc, reductionOp.getVector());
     } else {
       if (mask) {
-        mask = rewriter.create<ExtractOp>(loc, rewriter.getI1Type(), mask,
-                                          rewriter.getI64ArrayAttr(0));
+        mask = rewriter.create<ExtractOp>(loc, rewriter.getI1Type(), mask, 0);
       }
       result = rewriter.create<ExtractOp>(loc, reductionOp.getType(),
-                                          reductionOp.getVector(),
-                                          rewriter.getI64ArrayAttr(0));
+                                          reductionOp.getVector(), 0);
     }
 
     if (Value acc = reductionOp.getAcc())
       result = vector::makeArithReduction(rewriter, loc, reductionOp.getKind(),
                                           result, acc, mask);
 
     rewriter.replaceOp(rootOp, result);
     return success();
OpFoldResult vector::ExtractElementOp::fold(FoldAdaptor adaptor) {
 
   return srcElements[posIdx];
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractOp
 //===----------------------------------------------------------------------===//
 
-void vector::ExtractOp::build(OpBuilder &builder, OperationState &result,
-                              Value source, ArrayRef<int64_t> position) {
-  build(builder, result, source, getVectorSubscriptAttr(builder, position));
-}
-
 // Convenience builder which assumes the values are constant indices.
 void vector::ExtractOp::build(OpBuilder &builder, OperationState &result,
                               Value source, ValueRange position) {
-  SmallVector<int64_t, 4> positionConstants =
-      llvm::to_vector<4>(llvm::map_range(position, [](Value pos) {
-        return getConstantIntValue(pos).value();
-      }));
+  SmallVector<int64_t> positionConstants = llvm::to_vector(llvm::map_range(
+      position, [](Value pos) { return getConstantIntValue(pos).value(); }));
   build(builder, result, source, positionConstants);
 }
 
 LogicalResult
 ExtractOp::inferReturnTypes(MLIRContext *, std::optional<Location>,
                             ExtractOp::Adaptor adaptor,
                             SmallVectorImpl<Type> &inferredReturnTypes) {
   auto vectorType = llvm::cast<VectorType>(adaptor.getVector().getType());
bool ExtractOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   };
   if (l.size() == 1 && r.size() == 1 &&
       (isCompatible(l, r) || isCompatible(r, l)))
     return true;
   return l == r;
 }
 
 LogicalResult vector::ExtractOp::verify() {
-  auto positionAttr = getPosition().getValue();
-  if (positionAttr.size() >
-      static_cast<unsigned>(getSourceVectorType().getRank()))
+  ArrayRef<int64_t> position = getPosition();
+  if (position.size() > static_cast<unsigned>(getSourceVectorType().getRank()))
     return emitOpError(
         "expected position attribute of rank no greater than vector rank");
-  for (const auto &en : llvm::enumerate(positionAttr)) {
-    auto attr = llvm::dyn_cast<IntegerAttr>(en.value());
-    if (!attr || attr.getInt() < 0 ||
-        attr.getInt() >= getSourceVectorType().getDimSize(en.index()))
+  for (const auto &en : llvm::enumerate(position)) {
+    if (en.value() < 0 ||
+        en.value() >= getSourceVectorType().getDimSize(en.index()))
       return emitOpError("expected position attribute #")
              << (en.index() + 1)
              << " to be a non-negative integer smaller than the corresponding "
                 "vector dimension";
   }
   return success();
 }
 
 template <typename IntType>
 static SmallVector<IntType> extractVector(ArrayAttr arrayAttr) {
   return llvm::to_vector<4>(llvm::map_range(
       arrayAttr.getAsRange<IntegerAttr>(),
       [](IntegerAttr attr) { return static_cast<IntType>(attr.getInt()); }));
 }
 
 /// Fold the result of chains of ExtractOp in place by simply concatenating the
 /// positions.
 static LogicalResult foldExtractOpFromExtractChain(ExtractOp extractOp) {
   if (!extractOp.getVector().getDefiningOp<ExtractOp>())
     return failure();
 
   SmallVector<int64_t, 4> globalPosition;
   ExtractOp currentOp = extractOp;
-  auto extrPos = extractVector<int64_t>(currentOp.getPosition());
+  ArrayRef<int64_t> extrPos = currentOp.getPosition();
   globalPosition.append(extrPos.rbegin(), extrPos.rend());
   while (ExtractOp nextOp = currentOp.getVector().getDefiningOp<ExtractOp>()) {
     currentOp = nextOp;
-    auto extrPos = extractVector<int64_t>(currentOp.getPosition());
+    ArrayRef<int64_t> extrPos = currentOp.getPosition();
     globalPosition.append(extrPos.rbegin(), extrPos.rend());
   }
   extractOp.setOperand(currentOp.getVector());
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
   std::reverse(globalPosition.begin(), globalPosition.end());
-  extractOp.setPositionAttr(b.getI64ArrayAttr(globalPosition));
+  extractOp.setPosition(globalPosition);
   return success();
 }
 
 namespace {
 /// Fold an ExtractOp that is fed by a chain of InsertOps and TransposeOps.
 /// Walk back a chain of InsertOp/TransposeOp until we hit a match.
 /// Compose TransposeOp permutations as we walk back.
 /// This helper class keeps an updated extraction position `extractPosition`

 ExtractFromInsertTransposeChainState::ExtractFromInsertTransposeChainState(
     ExtractOp e)
     : extractOp(e), vectorRank(extractOp.getSourceVectorType().getRank()),
       extractedRank(extractOp.getPosition().size()) {
   assert(vectorRank >= extractedRank && "extracted pos overflow");
   sentinels.reserve(vectorRank - extractedRank);
   for (int64_t i = 0, e = vectorRank - extractedRank; i < e; ++i)
     sentinels.push_back(-(i + 1));
-  extractPosition = extractVector<int64_t>(extractOp.getPosition());
+  extractPosition.assign(extractOp.getPosition().begin(),
+                         extractOp.getPosition().end());
   llvm::append_range(extractPosition, sentinels);
 }
 
 // Case 1. If we hit a transpose, just compose the map and iterate.
 // Invariant: insert + transpose do not change rank, we can always compose.
 LogicalResult ExtractFromInsertTransposeChainState::handleTransposeOp() {
   if (!nextTransposeOp)
     return failure();
   auto permutation = extractVector<unsigned>(nextTransposeOp.getTransp());
   AffineMap m = inversePermutation(
       AffineMap::getPermutationMap(permutation, extractOp.getContext()));
   extractPosition = applyPermutationMap(m, ArrayRef(extractPosition));
   return success();
 }
 
 // Case 2: the insert position matches extractPosition exactly, early return.
 LogicalResult
 ExtractFromInsertTransposeChainState::handleInsertOpWithMatchingPos(
     Value &res) {
-  auto insertedPos = extractVector<int64_t>(nextInsertOp.getPosition());
-  if (ArrayRef(insertedPos) !=
-      llvm::ArrayRef(extractPosition).take_front(extractedRank))
+  ArrayRef<int64_t> insertedPos = nextInsertOp.getPosition();
+  if (insertedPos != llvm::ArrayRef(extractPosition).take_front(extractedRank))
     return failure();
   // Case 2.a. early-exit fold.
   res = nextInsertOp.getSource();
   // Case 2.b. if internal transposition is present, canFold will be false.
   return success(canFold());
 }
 
 /// Case 3: if inserted position is a prefix of extractPosition,
 /// extract a portion of the source of the insertion.
 /// This method updates the internal state.
 LogicalResult
 ExtractFromInsertTransposeChainState::handleInsertOpWithPrefixPos(Value &res) {
-  auto insertedPos = extractVector<int64_t>(nextInsertOp.getPosition());
+  ArrayRef<int64_t> insertedPos = nextInsertOp.getPosition();
   if (!isContainedWithin(insertedPos, extractPosition))
     return failure();
   // Set leading dims to zero.
   std::fill_n(extractPosition.begin(), insertedPos.size(), 0);
   // Drop extra leading dims.
   extractPosition.erase(extractPosition.begin(),
                         extractPosition.begin() + insertedPos.size());
   extractedRank = extractPosition.size() - sentinels.size();

 Value ExtractFromInsertTransposeChainState::tryToFoldExtractOpInPlace(
     Value source) {
   // If we can't fold (either internal transposition, or nothing to fold), bail.
   bool nothingToFold = (source == extractOp.getVector());
   if (nothingToFold || !canFold())
     return Value();
   // Otherwise, fold by updating the op inplace and return its result.
   OpBuilder b(extractOp.getContext());
-  extractOp->setAttr(
-      extractOp.getPositionAttrName(),
-      b.getI64ArrayAttr(ArrayRef(extractPosition).take_front(extractedRank)));
+  extractOp.setPosition(ArrayRef(extractPosition).take_front(extractedRank));
   extractOp.getVectorMutable().assign(source);
   return extractOp.getResult();
 }
 
 /// Iterate over producing insert and transpose ops until we find a fold.
 Value ExtractFromInsertTransposeChainState::fold() {
   Value valueToExtractFrom = extractOp.getVector();
   updateStateForNextIteration(valueToExtractFrom);
while (nextInsertOp || nextTransposeOp) {
 
     // Case 3: if the inserted position is a prefix of extractPosition, we can
     // just extract a portion of the source of the insert.
     if (succeeded(handleInsertOpWithPrefixPos(result)))
       return tryToFoldExtractOpInPlace(result);
 
     // Case 4: extractPositionRef intersects insertedPosRef on non-sentinel
     // values. This is a more difficult case and we bail.
-    auto insertedPos = extractVector<int64_t>(nextInsertOp.getPosition());
+    ArrayRef<int64_t> insertedPos = nextInsertOp.getPosition();
     if (isContainedWithin(extractPosition, insertedPos) ||
         intersectsWhereNonNegative(extractPosition, insertedPos))
       return Value();
 
     // Case 5: No intersection, we forward the extract to insertOp.dest().
     valueToExtractFrom = nextInsertOp.getDest();
     updateStateForNextIteration(valueToExtractFrom);
   }
static Value foldExtractFromBroadcast(ExtractOp extractOp) {
 
   auto broadcastOp = cast<vector::BroadcastOp>(defOp);
   int64_t rankDiff = broadcastSrcRank - extractResultRank;
   // Detect all the positions that come from "dim-1" broadcasting.
   // These dimensions correspond to "dim-1" broadcasted dims; set the mathching
   // extract position to `0` when extracting from the source operand.
   llvm::SetVector<int64_t> broadcastedUnitDims =
       broadcastOp.computeBroadcastedUnitDims();
-  auto extractPos = extractVector<int64_t>(extractOp.getPosition());
+  SmallVector<int64_t> extractPos(extractOp.getPosition());
   for (int64_t i = rankDiff, e = extractPos.size(); i < e; ++i)
     if (broadcastedUnitDims.contains(i))
       extractPos[i] = 0;
   // `rankDiff` leading dimensions correspond to new broadcasted dims, drop the
   // matching extract position when extracting from the source operand.
   extractPos.erase(extractPos.begin(),
                    std::next(extractPos.begin(), extractPos.size() - rankDiff));
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
   extractOp.setOperand(source);
-  extractOp.setPositionAttr(b.getI64ArrayAttr(extractPos));
+  extractOp.setPosition(extractPos);
   return extractOp.getResult();
 }
 
 // Fold extractOp with source coming from ShapeCast op.
 static Value foldExtractFromShapeCast(ExtractOp extractOp) {
   auto shapeCastOp = extractOp.getVector().getDefiningOp<vector::ShapeCastOp>();
   if (!shapeCastOp)
     return Value();
for (int64_t i = 0; i < destinationRank; i++) {
       // TODO: This case could be support in a canonicalization pattern.
       if (getDimReverse(shapeCastOp.getSourceVectorType(), i) !=
           getDimReverse(destinationType, i))
         return Value();
     }
   }
   // Extract the strides associated with the extract op vector source. Then use
   // this to calculate a linearized position for the extract.
-  auto extractedPos = extractVector<int64_t>(extractOp.getPosition());
+  SmallVector<int64_t> extractedPos(extractOp.getPosition());
   std::reverse(extractedPos.begin(), extractedPos.end());
   SmallVector<int64_t, 4> strides;
   int64_t stride = 1;
   for (int64_t i = 0, e = extractedPos.size(); i < e; i++) {
     strides.push_back(stride);
     stride *=
         getDimReverse(extractOp.getSourceVectorType(), i + destinationRank);
   }
for (int64_t i = 0; i < numDimension; i++) {
     newStrides.push_back(stride);
     stride *=
         getDimReverse(shapeCastOp.getSourceVectorType(), i + destinationRank);
   }
   std::reverse(newStrides.begin(), newStrides.end());
   SmallVector<int64_t, 4> newPosition = delinearize(position, newStrides);
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
-  extractOp.setPositionAttr(b.getI64ArrayAttr(newPosition));
+  extractOp.setPosition(newPosition);
   extractOp.setOperand(shapeCastOp.getSource());
   return extractOp.getResult();
 }
 
 /// Fold an ExtractOp from ExtractStridedSliceOp.
 static Value foldExtractFromExtractStrided(ExtractOp extractOp) {
   auto extractStridedSliceOp =
       extractOp.getVector().getDefiningOp<vector::ExtractStridedSliceOp>();
static Value foldExtractFromExtractStrided(ExtractOp extractOp) {
   unsigned destinationRank = 0;
   if (auto vecType = llvm::dyn_cast<VectorType>(extractOp.getType()))
     destinationRank = vecType.getRank();
   // The dimensions of the result need to be untouched by the
   // extractStridedSlice op.
   if (destinationRank > extractStridedSliceOp.getSourceVectorType().getRank() -
                             sliceOffsets.size())
     return Value();
-  auto extractedPos = extractVector<int64_t>(extractOp.getPosition());
+  SmallVector<int64_t> extractedPos(extractOp.getPosition());
   assert(extractedPos.size() >= sliceOffsets.size());
   for (size_t i = 0, e = sliceOffsets.size(); i < e; i++)
     extractedPos[i] = extractedPos[i] + sliceOffsets[i];
   extractOp.getVectorMutable().assign(extractStridedSliceOp.getVector());
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
-  extractOp.setPositionAttr(b.getI64ArrayAttr(extractedPos));
+  extractOp.setPosition(extractedPos);
   return extractOp.getResult();
 }
 
 /// Fold extract_op fed from a chain of insertStridedSlice ops.
 static Value foldExtractStridedOpFromInsertChain(ExtractOp extractOp) {
   int64_t destinationRank =
       llvm::isa<VectorType>(extractOp.getType())
           ? llvm::cast<VectorType>(extractOp.getType()).getRank()
           : 0;
   auto insertOp = extractOp.getVector().getDefiningOp<InsertStridedSliceOp>();
   if (!insertOp)
     return Value();
 
   // 0-D vectors not supported.
   assert(!hasZeroDimVectors(extractOp) && "0-D vectors not supported");
   if (hasZeroDimVectors(insertOp))
     return Value();
 
   while (insertOp) {
     int64_t insertRankDiff = insertOp.getDestVectorType().getRank() -
                              insertOp.getSourceVectorType().getRank();
     if (destinationRank > insertOp.getSourceVectorType().getRank())
       return Value();
     auto insertOffsets = extractVector<int64_t>(insertOp.getOffsets());
-    auto extractOffsets = extractVector<int64_t>(extractOp.getPosition());
+    ArrayRef<int64_t> extractOffsets = extractOp.getPosition();
 
     if (llvm::any_of(insertOp.getStrides(), [](Attribute attr) {
           return llvm::cast<IntegerAttr>(attr).getInt() != 1;
         }))
       return Value();
     bool disjoint = false;
     SmallVector<int64_t, 4> offsetDiffs;
     for (unsigned dim = 0, e = extractOffsets.size(); dim < e; ++dim) {
if (!disjoint) {
         if (insertOp.getSourceVectorType().getDimSize(i + srcRankDiff) !=
             insertOp.getDestVectorType().getDimSize(i + srcRankDiff +
                                                     insertRankDiff))
           return Value();
       }
       extractOp.getVectorMutable().assign(insertOp.getSource());
       // OpBuilder is only used as a helper to build an I64ArrayAttr.
       OpBuilder b(extractOp.getContext());
-      extractOp.setPositionAttr(b.getI64ArrayAttr(offsetDiffs));
+      extractOp.setPosition(offsetDiffs);
       return extractOp.getResult();
     }
     // If the chunk extracted is disjoint from the chunk inserted, keep
     // looking in the insert chain.
     insertOp = insertOp.getDest().getDefiningOp<InsertStridedSliceOp>();
   }
   return Value();
 }
LogicalResult matchAndRewrite(ExtractOp extractOp,
     // The splat case is handled by `ExtractOpSplatConstantFolder`.
     auto dense = llvm::dyn_cast<DenseElementsAttr>(vectorCst);
     if (!dense || dense.isSplat())
       return failure();
 
     // Calculate the linearized position of the continuous chunk of elements to
     // extract.
     llvm::SmallVector<int64_t> completePositions(vecTy.getRank(), 0);
-    copy(getI64SubArray(extractOp.getPosition()), completePositions.begin());
+    copy(extractOp.getPosition(), completePositions.begin());
     int64_t elemBeginPosition =
         linearize(completePositions, computeStrides(vecTy.getShape()));
     auto denseValuesBegin = dense.value_begin<TypedAttr>() + elemBeginPosition;
 
     TypedAttr newAttr;
     if (auto resVecTy = llvm::dyn_cast<VectorType>(extractOp.getType())) {
       SmallVector<Attribute> elementValues(
           denseValuesBegin, denseValuesBegin + resVecTy.getNumElements());
OpFoldResult vector::InsertElementOp::fold(FoldAdaptor adaptor) {
 
   return DenseElementsAttr::get(getDestVectorType(), results);
 }
 
 //===----------------------------------------------------------------------===//
 // InsertOp
 //===----------------------------------------------------------------------===//
 
-void InsertOp::build(OpBuilder &builder, OperationState &result, Value source,
-                     Value dest, ArrayRef<int64_t> position) {
-  result.addOperands({source, dest});
-  auto positionAttr = getVectorSubscriptAttr(builder, position);
-  result.addTypes(dest.getType());
-  result.addAttribute(InsertOp::getPositionAttrName(result.name), positionAttr);
-}
-
 // Convenience builder which assumes the values are constant indices.
 void InsertOp::build(OpBuilder &builder, OperationState &result, Value source,
                      Value dest, ValueRange position) {
   SmallVector<int64_t, 4> positionConstants =
       llvm::to_vector<4>(llvm::map_range(position, [](Value pos) {
         return getConstantIntValue(pos).value();
       }));
   build(builder, result, source, dest, positionConstants);
 }
 
 LogicalResult InsertOp::verify() {
-  auto positionAttr = getPosition().getValue();
+  ArrayRef<int64_t> position = getPosition();
   auto destVectorType = getDestVectorType();
-  if (positionAttr.size() > static_cast<unsigned>(destVectorType.getRank()))
+  if (position.size() > static_cast<unsigned>(destVectorType.getRank()))
     return emitOpError(
         "expected position attribute of rank no greater than dest vector rank");
   auto srcVectorType = llvm::dyn_cast<VectorType>(getSourceType());
   if (srcVectorType &&
-      (static_cast<unsigned>(srcVectorType.getRank()) + positionAttr.size() !=
+      (static_cast<unsigned>(srcVectorType.getRank()) + position.size() !=
        static_cast<unsigned>(destVectorType.getRank())))
     return emitOpError("expected position attribute rank + source rank to "
                        "match dest vector rank");
   if (!srcVectorType &&
-      (positionAttr.size() != static_cast<unsigned>(destVectorType.getRank())))
+      (position.size() != static_cast<unsigned>(destVectorType.getRank())))
     return emitOpError(
         "expected position attribute rank to match the dest vector rank");
-  for (const auto &en : llvm::enumerate(positionAttr)) {
-    auto attr = llvm::dyn_cast<IntegerAttr>(en.value());
-    if (!attr || attr.getInt() < 0 ||
-        attr.getInt() >= destVectorType.getDimSize(en.index()))
+  for (const auto &en : llvm::enumerate(position)) {
+    int64_t attr = en.value();
+    if (attr < 0 || attr >= destVectorType.getDimSize(en.index()))
       return emitOpError("expected position attribute #")
              << (en.index() + 1)
              << " to be a non-negative integer smaller than the corresponding "
                 "dest vector dimension";
   }
   return success();
 }
 
LogicalResult matchAndRewrite(InsertOp op,
     Value sourceValue = op.getSource();
     Attribute sourceCst;
     if (!matchPattern(sourceValue, m_Constant(&sourceCst)))
       return failure();
 
     // Calculate the linearized position of the continuous chunk of elements to
     // insert.
     llvm::SmallVector<int64_t> completePositions(destTy.getRank(), 0);
-    copy(getI64SubArray(op.getPosition()), completePositions.begin());
+    copy(op.getPosition(), completePositions.begin());
     int64_t insertBeginPosition =
         linearize(completePositions, computeStrides(destTy.getShape()));
 
     SmallVector<Attribute> insertedValues;
     if (auto denseSource = llvm::dyn_cast<DenseElementsAttr>(sourceCst))
       llvm::append_range(insertedValues, denseSource.getValues<Attribute>());
     else
       insertedValues.push_back(sourceCst);

mlir/lib/Dialect/Vector/Transforms/LowerVectorContract.cpp

 // TODO
 static Value reshapeLoad(Location loc, Value val, VectorType type,
                          int64_t index, int64_t pos,
                          PatternRewriter &rewriter) {
   if (index == -1)
     return val;
   Type lowType = VectorType::Builder(type).dropDim(0);
   // At extraction dimension?
-  if (index == 0) {
-    auto posAttr = rewriter.getI64ArrayAttr(pos);
-    return rewriter.create<vector::ExtractOp>(loc, lowType, val, posAttr);
-  }
+  if (index == 0)
+    return rewriter.create<vector::ExtractOp>(loc, lowType, val, pos);
   // Unroll leading dimensions.
   VectorType vType = cast<VectorType>(lowType);
   Type resType = VectorType::Builder(type).dropDim(index);
   auto resVectorType = cast<VectorType>(resType);
   Value result = rewriter.create<arith::ConstantOp>(
       loc, resVectorType, rewriter.getZeroAttr(resVectorType));
   for (int64_t d = 0, e = resVectorType.getDimSize(0); d < e; d++) {
-    auto posAttr = rewriter.getI64ArrayAttr(d);
-    Value ext = rewriter.create<vector::ExtractOp>(loc, vType, val, posAttr);
+    Value ext = rewriter.create<vector::ExtractOp>(loc, vType, val, d);
     Value load = reshapeLoad(loc, ext, vType, index - 1, pos, rewriter);
-    result = rewriter.create<vector::InsertOp>(loc, resVectorType, load, result,
-                                               posAttr);
+    result =
+        rewriter.create<vector::InsertOp>(loc, resVectorType, load, result, d);
   }
   return result;
 }
 
 // Helper method to possibly drop a dimension in a store.
 // TODO
 static Value reshapeStore(Location loc, Value val, Value result,
                           VectorType type, int64_t index, int64_t pos,
                           PatternRewriter &rewriter) {
   // Unmodified?
   if (index == -1)
     return val;
   // At insertion dimension?
-  if (index == 0) {
-    auto posAttr = rewriter.getI64ArrayAttr(pos);
-    return rewriter.create<vector::InsertOp>(loc, type, val, result, posAttr);
-  }
+  if (index == 0)
+    return rewriter.create<vector::InsertOp>(loc, type, val, result, pos);
   // Unroll leading dimensions.
   Type lowType = VectorType::Builder(type).dropDim(0);
   VectorType vType = cast<VectorType>(lowType);
   Type insType = VectorType::Builder(vType).dropDim(0);
   for (int64_t d = 0, e = type.getDimSize(0); d < e; d++) {
-    auto posAttr = rewriter.getI64ArrayAttr(d);
-    Value ext = rewriter.create<vector::ExtractOp>(loc, vType, result, posAttr);
-    Value ins = rewriter.create<vector::ExtractOp>(loc, insType, val, posAttr);
+    Value ext = rewriter.create<vector::ExtractOp>(loc, vType, result, d);
+    Value ins = rewriter.create<vector::ExtractOp>(loc, insType, val, d);
     Value sto = reshapeStore(loc, ins, ext, vType, index - 1, pos, rewriter);
-    result = rewriter.create<vector::InsertOp>(loc, type, sto, result, posAttr);
+    result = rewriter.create<vector::InsertOp>(loc, type, sto, result, d);
   }
   return result;
 }
 
 /// Helper to create arithmetic operation associated with a kind of contraction.
 static std::optional<Value>
 createContractArithOp(Location loc, Value x, Value y, Value acc,
                       vector::CombiningKind kind, PatternRewriter &rewriter,
if (!rhsDims.empty()) {
           VectorType::get(rhsDims, contractOp.getRhsType().getElementType());
       newRhs = rewriter.create<vector::BroadcastOp>(loc, expandedType, newRhs);
     }
     bool isInt = contractOp.getLhsType().getElementType().isIntOrIndex();
     newLhs = rewriter.create<vector::TransposeOp>(loc, newLhs, lhsTranspose);
     newRhs = rewriter.create<vector::TransposeOp>(loc, newRhs, rhsTranspose);
     SmallVector<int64_t> lhsOffsets(lhsReductionDims.size(), 0);
     SmallVector<int64_t> rhsOffsets(rhsReductionDims.size(), 0);
-    newLhs = rewriter.create<vector::ExtractOp>(
-        loc, newLhs, rewriter.getI64ArrayAttr(lhsOffsets));
-    newRhs = rewriter.create<vector::ExtractOp>(
-        loc, newRhs, rewriter.getI64ArrayAttr(rhsOffsets));
+    newLhs = rewriter.create<vector::ExtractOp>(loc, newLhs, lhsOffsets);
+    newRhs = rewriter.create<vector::ExtractOp>(loc, newRhs, rhsOffsets);
     std::optional<Value> result =
         createContractArithOp(loc, newLhs, newRhs, contractOp.getAcc(),
                               contractOp.getKind(), rewriter, isInt);
     rewriter.replaceOp(contractOp, {*result});
     return success();
   }
 
 private:
if (!rhsType) {
         return failure();
       rewriter.replaceOp(rootOp, *mult);
       return success();
     }
 
     Value result = rewriter.create<arith::ConstantOp>(
         loc, resType, rewriter.getZeroAttr(resType));
     for (int64_t d = 0, e = resType.getDimSize(0); d < e; ++d) {
-      auto pos = rewriter.getI64ArrayAttr(d);
-      Value x = rewriter.create<vector::ExtractOp>(loc, op.getLhs(), pos);
+      Value x = rewriter.create<vector::ExtractOp>(loc, op.getLhs(), d);
       Value a = rewriter.create<vector::BroadcastOp>(loc, rhsType, x);
       Value r = nullptr;
       if (acc)
-        r = rewriter.create<vector::ExtractOp>(loc, acc, pos);
+        r = rewriter.create<vector::ExtractOp>(loc, acc, d);
       Value extrMask;
       if (mask)
-        extrMask = rewriter.create<vector::ExtractOp>(loc, mask, pos);
+        extrMask = rewriter.create<vector::ExtractOp>(loc, mask, d);
 
       std::optional<Value> m = createContractArithOp(
           loc, a, op.getRhs(), r, kind, rewriter, isInt, extrMask);
       if (!m.has_value())
         return failure();
-      result = rewriter.create<vector::InsertOp>(loc, resType, *m, result, pos);
+      result = rewriter.create<vector::InsertOp>(loc, resType, *m, result, d);
     }
 
     rewriter.replaceOp(rootOp, result);
     return success();
   }
 };
 
 /// Progressively lower a `vector.contract %a, %b, %c` with row-major matmul

mlir/lib/Dialect/Vector/Transforms/LowerVectorMask.cpp

LogicalResult matchAndRewrite(vector::CreateMaskOp op,
     Value result = rewriter.create<arith::ConstantOp>(
         loc, dstType, rewriter.getZeroAttr(dstType));
     for (int64_t d = 0; d < dim; d++) {
       Value bnd =
           rewriter.create<arith::ConstantOp>(loc, rewriter.getIndexAttr(d));
       Value val = rewriter.create<arith::CmpIOp>(loc, arith::CmpIPredicate::slt,
                                                  bnd, idx);
       Value sel = rewriter.create<arith::SelectOp>(loc, val, trueVal, falseVal);
-      auto pos = rewriter.getI64ArrayAttr(d);
-      result =
-          rewriter.create<vector::InsertOp>(loc, dstType, sel, result, pos);
+      result = rewriter.create<vector::InsertOp>(loc, dstType, sel, result, d);
     }
     rewriter.replaceOp(op, result);
     return success();
   }
 };
 
 /// Progressive lowering of ConstantMaskOp.
 /// One:
VectorType lowType =
         VectorType::get(dstType.getShape().drop_front(), eltType);
     SmallVector<int64_t> newDimSizes;
     for (int64_t r = 1; r < rank; r++)
       newDimSizes.push_back(cast<IntegerAttr>(dimSizes[r]).getInt());
     Value trueVal = rewriter.create<vector::ConstantMaskOp>(
         loc, lowType, rewriter.getI64ArrayAttr(newDimSizes));
     Value result = rewriter.create<arith::ConstantOp>(
         loc, dstType, rewriter.getZeroAttr(dstType));
-    for (int64_t d = 0; d < trueDim; d++) {
-      auto pos = rewriter.getI64ArrayAttr(d);
+    for (int64_t d = 0; d < trueDim; d++)
       result =
-          rewriter.create<vector::InsertOp>(loc, dstType, trueVal, result, pos);
-    }
+          rewriter.create<vector::InsertOp>(loc, dstType, trueVal, result, d);
     rewriter.replaceOp(op, result);
     return success();
   }
 };
 } // namespace
 
 void mlir::vector::populateVectorMaskOpLoweringPatterns(
     RewritePatternSet &patterns, PatternBenefit benefit) {

mlir/lib/Dialect/Vector/Transforms/VectorDistribute.cpp

LogicalResult matchAndRewrite(WarpExecuteOnLane0Op warpOp,
 
     // "vector.extract %v[] : vector<...xf32>" can be canonicalized to %v.
     if (extractOp.getPosition().empty())
       return failure();
 
     // Rewrite vector.extract with 1d source to vector.extractelement.
     if (extractSrcType.getRank() == 1) {
       assert(extractOp.getPosition().size() == 1 && "expected 1 index");
-      int64_t pos = cast<IntegerAttr>(extractOp.getPosition()[0]).getInt();
+      int64_t pos = extractOp.getPosition()[0];
       rewriter.setInsertionPoint(extractOp);
       rewriter.replaceOpWithNewOp<vector::ExtractElementOp>(
           extractOp, extractOp.getVector(),
           rewriter.create<arith::ConstantIndexOp>(loc, pos));
       return success();
     }
 
     // All following cases are 2d or higher dimensional source vectors.
LogicalResult matchAndRewrite(WarpExecuteOnLane0Op warpOp,
 
     // "vector.insert %v, %v[] : ..." can be canonicalized to %v.
     if (insertOp.getPosition().empty())
       return failure();
 
     // Rewrite vector.insert with 1d dest to vector.insertelement.
     if (insertOp.getDestVectorType().getRank() == 1) {
       assert(insertOp.getPosition().size() == 1 && "expected 1 index");
-      int64_t pos = cast<IntegerAttr>(insertOp.getPosition()[0]).getInt();
+      int64_t pos = insertOp.getPosition()[0];
       rewriter.setInsertionPoint(insertOp);
       rewriter.replaceOpWithNewOp<vector::InsertElementOp>(
           insertOp, insertOp.getSource(), insertOp.getDest(),
           rewriter.create<arith::ConstantIndexOp>(loc, pos));
       return success();
     }
 
     if (warpOp.getResult(operandNumber).getType() == operand->get().getType()) {
LogicalResult matchAndRewrite(WarpExecuteOnLane0Op warpOp,
     Value newResult;
     if (distrSrcDim >= 0) {
       // Every lane inserts a small piece.
       newResult = rewriter.create<vector::InsertOp>(
           loc, distributedSrc, distributedDest, insertOp.getPosition());
     } else {
       // One lane inserts the entire source vector.
       int64_t elementsPerLane = distrDestType.getDimSize(distrDestDim);
-      SmallVector<int64_t> newPos = llvm::to_vector(
-          llvm::map_range(insertOp.getPosition(), [](Attribute attr) {
-            return cast<IntegerAttr>(attr).getInt();
-          }));
+      SmallVector<int64_t> newPos(insertOp.getPosition());
       // tid of inserting lane: pos / elementsPerLane
       Value insertingLane = rewriter.create<arith::ConstantIndexOp>(
           loc, newPos[distrDestDim] / elementsPerLane);
       Value isInsertingLane = rewriter.create<arith::CmpIOp>(
           loc, arith::CmpIPredicate::eq, newWarpOp.getLaneid(), insertingLane);
       // Insert position: pos % elementsPerLane
       newPos[distrDestDim] %= elementsPerLane;
       auto insertingBuilder = [&](OpBuilder &builder, Location loc) {

mlir/lib/Dialect/Vector/Transforms/VectorDropLeadUnitDim.cpp

LogicalResult matchAndRewrite(vector::InsertOp insertOp,
     }
     Value newDstVector = rewriter.create<vector::ExtractOp>(
         loc, insertOp.getDest(), splatZero(dstDropCount));
 
     // New position rank needs to be computed in two steps: (1) if destination
     // type has leading unit dims, we also trim the position array accordingly,
     // then (2) if source type also has leading unit dims, we need to append
     // zeroes to the position array accordingly.
-    unsigned oldPosRank = insertOp.getPosition().getValue().size();
+    unsigned oldPosRank = insertOp.getPosition().size();
     unsigned newPosRank = std::max<int64_t>(0, oldPosRank - dstDropCount);
-    SmallVector<Attribute> newPositions = llvm::to_vector(
-        insertOp.getPosition().getValue().take_back(newPosRank));
-    newPositions.resize(newDstType.getRank() - newSrcRank,
-                        rewriter.getI64IntegerAttr(0));
+    SmallVector<int64_t> newPositions =
+        llvm::to_vector(insertOp.getPosition().take_back(newPosRank));
+    newPositions.resize(newDstType.getRank() - newSrcRank, 0);
 
     auto newInsertOp = rewriter.create<vector::InsertOp>(
-        loc, newDstType, newSrcVector, newDstVector,
-        rewriter.getArrayAttr(newPositions));
+        loc, newDstType, newSrcVector, newDstVector, newPositions);
 
     rewriter.replaceOpWithNewOp<vector::BroadcastOp>(insertOp, oldDstType,
                                                      newInsertOp);
 
     return success();
   }
 };
 

mlir/lib/Dialect/Vector/Transforms/VectorTransferOpTransforms.cpp

class RewriteScalarExtractOfTransferRead
 
   void rewrite(vector::ExtractOp extractOp,
                PatternRewriter &rewriter) const override {
     // Construct scalar load.
     auto xferOp = extractOp.getVector().getDefiningOp<vector::TransferReadOp>();
     SmallVector<Value> newIndices(xferOp.getIndices().begin(),
                                   xferOp.getIndices().end());
     for (const auto &it : llvm::enumerate(extractOp.getPosition())) {
-      int64_t offset = cast<IntegerAttr>(it.value()).getInt();
+      int64_t offset = it.value();
       int64_t idx =
           newIndices.size() - extractOp.getPosition().size() + it.index();
       OpFoldResult ofr = affine::makeComposedFoldedAffineApply(
           rewriter, extractOp.getLoc(),
           rewriter.getAffineSymbolExpr(0) + offset, {newIndices[idx]});
       if (ofr.is<Value>()) {
         newIndices[idx] = ofr.get<Value>();
       } else {

mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp

LogicalResult matchAndRewrite(vector::ExtractOp extractOp,
     // Only support casting to a larger number of elements or now.
     // E.g., vector<4xf32> -> vector<8xf16>.
     if (castSrcType.getNumElements() > castDstType.getNumElements())
       return failure();
 
     unsigned expandRatio =
         castDstType.getNumElements() / castSrcType.getNumElements();
 
-    auto getFirstIntValue = [](ArrayAttr attr) -> uint64_t {
-      return (*attr.getAsValueRange<IntegerAttr>().begin()).getZExtValue();
-    };
-
-    uint64_t index = getFirstIntValue(extractOp.getPosition());
+    uint64_t index = extractOp.getPosition()[0];
 
     // Get the single scalar (as a vector) in the source value that packs the
     // desired scalar. E.g. extract vector<1xf32> from vector<4xf32>
     VectorType oneScalarType =
         VectorType::get({1}, castSrcType.getElementType());
     Value packedValue = rewriter.create<vector::ExtractOp>(
         extractOp.getLoc(), oneScalarType, castOp.getSource(),
-        rewriter.getI64ArrayAttr(index / expandRatio));
+        index / expandRatio);
 
     // Cast it to a vector with the desired scalar's type.
     // E.g. f32 -> vector<2xf16>
     VectorType packedType =
         VectorType::get({expandRatio}, castDstType.getElementType());
     Value castedValue = rewriter.create<vector::BitCastOp>(
         extractOp.getLoc(), packedType, packedValue);
 
     // Finally extract the desired scalar.
     rewriter.replaceOpWithNewOp<vector::ExtractOp>(
-        extractOp, extractOp.getType(), castedValue,
-        rewriter.getI64ArrayAttr(index % expandRatio));
+        extractOp, extractOp.getType(), castedValue, index % expandRatio);
 
     return success();
   }
 };
 
 // Shuffles vector.bitcast op after vector.extract_strided_slice op.
 //
 // This transforms IR like:

mlir/test/Conversion/VectorToSPIRV/vector-to-spirv.mlir

 
 // -----
 
 // CHECK-LABEL: @extract
 //  CHECK-SAME: %[[ARG:.+]]: vector<2xf32>
 //       CHECK:   spirv.CompositeExtract %[[ARG]][0 : i32] : vector<2xf32>
 //       CHECK:   spirv.CompositeExtract %[[ARG]][1 : i32] : vector<2xf32>
 func.func @extract(%arg0 : vector<2xf32>) -> (vector<1xf32>, f32) {
-  %0 = "vector.extract"(%arg0) {position = [0]} : (vector<2xf32>) -> vector<1xf32>
-  %1 = "vector.extract"(%arg0) {position = [1]} : (vector<2xf32>) -> f32
+  %0 = "vector.extract"(%arg0) <{position = array<i64: 0>}> : (vector<2xf32>) -> vector<1xf32>
+  %1 = "vector.extract"(%arg0) <{position = array<i64: 1>}> : (vector<2xf32>) -> f32
   return %0, %1: vector<1xf32>, f32
 }
 
 // -----
 
 // CHECK-LABEL: @extract_size1_vector
 //  CHECK-SAME: %[[ARG0:.+]]: vector<1xf32>
 //       CHECK:   %[[R:.+]] = builtin.unrealized_conversion_cast %[[ARG0]]

mlir/test/Dialect/Vector/invalid.mlir

func.func @extract_position_rank_overflow(%arg0: vector<4x8x16xf32>) {
   // expected-error@+1 {{expected position attribute of rank no greater than vector rank}}
   %1 = vector.extract %arg0[0, 0, 0, 0] : vector<4x8x16xf32>
 }
 
 // -----
 
 func.func @extract_position_rank_overflow_generic(%arg0: vector<4x8x16xf32>) {
   // expected-error@+1 {{expected position attribute of rank no greater than vector rank}}
-  %1 = "vector.extract" (%arg0) { position = [0, 0, 0, 0] } : (vector<4x8x16xf32>) -> (vector<16xf32>)
+  %1 = "vector.extract" (%arg0) <{position = array<i64: 0, 0, 0, 0>}> : (vector<4x8x16xf32>) -> (vector<16xf32>)
 }
 
 // -----
 
 func.func @extract_position_overflow(%arg0: vector<4x8x16xf32>) {
   // expected-error@+1 {{expected position attribute #2 to be a non-negative integer smaller than the corresponding vector dimension}}
   %1 = vector.extract %arg0[0, 43, 0] : vector<4x8x16xf32>
 }