[mlir] Flipping vector dialect to both prefixed form.

[jpienaar]

Summary

Following
https://discourse.llvm.org/t/psa-ods-generated-accessors-will-change-to-have-a-get-prefix-update-you-apis/4476

Mostly mechanical, avoiding function name conflicts.

[rriddle]

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

72–74

getAsValueRange?

[jpienaar]

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

72–74

Here the storage is an array of Attribute type, so I'd have to getAsValueRange<Attribute, AffineMapAttr> and then map over that to get the AffineMap out before then constructing vector of AffineMap. That decreases the readability for me.

[rriddle]

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

72–74

Is $_self here not an ArrayAttr? If it is, $_self.getAsValueRange<AffineMapAttr>() should do the exact same thing as this map_range.

[jpienaar]

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

72–74

That would be true if this were returning a vector of AffineMapAttr. Here it is a vector of AffineMap, so there needs to be another mapping over the range to getValue on AffineMapAttr.

[jpienaar]

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

72–74

Seems I was making a typo there the whole time (tried a few combos and all failed, then just retried and it worked)

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

 include "mlir/Interfaces/VectorInterfaces.td"
 include "mlir/Interfaces/ViewLikeInterface.td"
 
 def Vector_Dialect : Dialect {
   let name = "vector";
   let cppNamespace = "::mlir::vector";
   let hasConstantMaterializer = 1;
   let dependentDialects = ["arith::ArithmeticDialect"];
+  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 // Base class for Vector dialect ops.
 class Vector_Op<string mnemonic, list<Trait> traits = []> :
     Op<Vector_Dialect, mnemonic, traits>;
 
 // The "kind" of combining function for contractions and reductions.
 def COMBINING_KIND_ADD : BitEnumAttrCaseBit<"ADD", 0, "add">;
def Vector_CombiningKindAttr : DialectAttr<
     "Kind of combining function for contractions and reductions"> {
   let storageType = "::mlir::vector::CombiningKindAttr";
   let returnType = "::mlir::vector::CombiningKind";
   let convertFromStorage = "$_self.getKind()";
   let constBuilderCall =
           "::mlir::vector::CombiningKindAttr::get($0, $_builder.getContext())";
 }
 
+def Vector_AffineMapArrayAttr : TypedArrayAttrBase<AffineMapAttr,
+                                      "AffineMap array attribute"> {
+  let returnType = [{ ::llvm::SmallVector<::mlir::AffineMap, 4> }];
+  let convertFromStorage = [{
+    llvm::to_vector<4>($_self.getAsValueRange<::mlir::AffineMapAttr>());
+  }];
+  let constBuilderCall = "$_builder.getAffineMapArrayAttr($0)";
+}
+
 // TODO: Add an attribute to specify a different algebra with operators other
 // than the current set: {*, +}.
 def Vector_ContractionOp :
   Vector_Op<"contract", [
       NoSideEffect,
       PredOpTrait<"lhs and rhs have same element type", TCopVTEtIsSameAs<0, 1>>,
       PredOpTrait<"third operand acc and result have same element type",
                   TCresVTEtIsSameAsOpBase<0, 2>>,
       DeclareOpInterfaceMethods<VectorUnrollOpInterface, ["getShapeForUnroll"]>
     ]>,
     Arguments<(ins AnyVector:$lhs, AnyVector:$rhs, AnyType:$acc,
                Variadic<VectorOf<[I1]>>:$masks,
-               AffineMapArrayAttr:$indexing_maps, ArrayAttr:$iterator_types,
+               Vector_AffineMapArrayAttr:$indexing_maps,
+         ArrayAttr:$iterator_types,
                DefaultValuedAttr<Vector_CombiningKindAttr,
                                  "CombiningKind::ADD">:$kind)>,
     Results<(outs AnyType)> {
   let summary = "vector contraction operation";
   let description = [{
     Computes the sum of products of vector elements along contracting
     dimension pairs from 2 vectors of rank M and N respectively, adds this
     intermediate result to the accumulator argument of rank K, and returns a
VectorType getLHSVectorMaskType() {
       return getOperand(3).getType().cast<VectorType>();
     }
     VectorType getRHSVectorMaskType() {
       if (llvm::size(masks()) != 2) return VectorType();
       return getOperand(4).getType().cast<VectorType>();
     }
     Type getResultType() { return getResult().getType(); }
     ArrayRef<StringRef> getTraitAttrNames();
-    SmallVector<AffineMap, 4> getIndexingMaps();
     static unsigned getAccOperandIndex() { return 2; }
 
     // Returns the bounds of each dimension in the iteration space spanned
     // by the iterator types of this operation.
     void getIterationBounds(SmallVectorImpl<int64_t> &iterationBounds);
 
     // Returns a list of index maps, where there is a list entry for each
     // op indexing map attribute (i.e. one for each input and output, with
     // the output listed last). Each index map, maps from this operations
     // iteration space, to vector dimensions of the maps input/output.
     void getIterationIndexMap(
       std::vector<DenseMap<int64_t, int64_t>> &iterationIndexMap);
 
     std::vector<std::pair<int64_t, int64_t>> getContractingDimMap();
     std::vector<std::pair<int64_t, int64_t>> getBatchDimMap();
 
-    static constexpr StringRef getKindAttrName() { return "kind"; }
+    static constexpr StringRef getKindAttrStrName() { return "kind"; }
 
     static CombiningKind getDefaultKind() {
       return CombiningKind::ADD;
     }
   }];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
%2 = vector.multi_reduction <add>, %1 [0, 1] :
       vector<4x16xf32> into f32
     ```
   }];
   let builders = [
     OpBuilder<(ins "Value":$source, "ArrayRef<bool>":$reductionMask,
                    "CombiningKind":$kind)>
   ];
   let extraClassDeclaration = [{
-    static StringRef getKindAttrName() { return "kind"; }
-    static StringRef getReductionDimsAttrName() { return "reduction_dims"; }
+    static StringRef getKindAttrStrName() { return "kind"; }
+    static StringRef getReductionDimsAttrStrName() { return "reduction_dims"; }
 
     VectorType getSourceVectorType() {
       return source().getType().cast<VectorType>();
     }
     Type getDestType() {
       return dest().getType();
     }
 
%2 = vector.shuffle %a, %b[3, 2, 1, 0]
                : vector<2xf32>, vector<2xf32>       ; yields vector<4xf32>
     ```
   }];
   let builders = [
     OpBuilder<(ins "Value":$v1, "Value":$v2, "ArrayRef<int64_t>")>
   ];
   let hasFolder = 1;
   let extraClassDeclaration = [{
-    static StringRef getMaskAttrName() { return "mask"; }
+    static StringRef getMaskAttrStrName() { return "mask"; }
     VectorType getV1VectorType() {
       return v1().getType().cast<VectorType>();
     }
     VectorType getV2VectorType() {
       return v2().getType().cast<VectorType>();
     }
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
def Vector_ExtractOp :
   }];
   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 = [{
-    static StringRef getPositionAttrName() { return "position"; }
+    static StringRef getPositionAttrStrName() { return "position"; }
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
   }];
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
def Vector_InsertOp :
 
   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 = [{
-    static StringRef getPositionAttrName() { return "position"; }
+    static StringRef getPositionAttrStrName() { return "position"; }
     Type getSourceType() { return source().getType(); }
     VectorType getDestVectorType() {
       return dest().getType().cast<VectorType>();
     }
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
let assemblyFormat = [{
     $source `,` $dest attr-dict `:` type($source) `into` type($dest)
   }];
 
   let builders = [
     OpBuilder<(ins "Value":$source, "Value":$dest,
       "ArrayRef<int64_t>":$offsets, "ArrayRef<int64_t>":$strides)>
   ];
   let extraClassDeclaration = [{
-    static StringRef getOffsetsAttrName() { return "offsets"; }
-    static StringRef getStridesAttrName() { return "strides"; }
+    static StringRef getOffsetsAttrStrName() { return "offsets"; }
+    static StringRef getStridesAttrStrName() { return "strides"; }
     VectorType getSourceVectorType() {
       return source().getType().cast<VectorType>();
     }
     VectorType getDestVectorType() {
       return dest().getType().cast<VectorType>();
     }
-    bool hasNonUnitStrides() { 
+    bool hasNonUnitStrides() {
       return llvm::any_of(strides(), [](Attribute attr) {
         return attr.cast<IntegerAttr>().getInt() != 1;
       });
     }
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
let extraClassDeclaration = [{
     VectorType getOperandVectorTypeACC() {
       return (llvm::size(acc()) == 0)
         ? VectorType()
         : (*acc().begin()).getType().cast<VectorType>();
     }
     VectorType getVectorType() {
       return getResult().getType().cast<VectorType>();
     }
-    static constexpr StringRef getKindAttrName() {
+    static constexpr StringRef getKindAttrStrName() {
       return "kind";
     }
     static CombiningKind getDefaultKind() {
       return CombiningKind::ADD;
     }
   }];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
let extraClassDeclaration = [{
     /// Returns as integer value the number of input shape operands.
     int64_t getNumInputShapeSizes() { return input_shape().size(); }
 
     /// Returns as integer value the number of output shape operands.
     int64_t getNumOutputShapeSizes() { return output_shape().size(); }
 
     void getFixedVectorSizes(SmallVectorImpl<int64_t> &results);
 
-    static StringRef getFixedVectorSizesAttrName() {
+    static StringRef getFixedVectorSizesAttrStrName() {
       return "fixed_vector_sizes";
     }
-    static StringRef getInputShapeAttrName() { return "input_shape"; }
-    static StringRef getOutputShapeAttrName() { return "output_shape"; }
+    static StringRef getInputShapeAttrStrName() { return "input_shape"; }
+    static StringRef getOutputShapeAttrStrName() { return "output_shape"; }
   }];
 
   let assemblyFormat = [{
     $vector `,` `[` $input_shape `]` `,` `[` $output_shape `]` `,`
     $fixed_vector_sizes attr-dict `:` type($vector) `to` type($result)
   }];
   let hasVerifier = 1;
 }
%1 = vector.extract_strided_slice %0[0:2:1][2:4:1]
       vector<4x8x16xf32> to vector<2x4x16xf32>
     ```
   }];
   let builders = [
     OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$offsets,
       "ArrayRef<int64_t>":$sizes, "ArrayRef<int64_t>":$strides)>
   ];
   let extraClassDeclaration = [{
-    static StringRef getOffsetsAttrName() { return "offsets"; }
-    static StringRef getSizesAttrName() { return "sizes"; }
-    static StringRef getStridesAttrName() { return "strides"; }
+    static StringRef getOffsetsAttrStrName() { return "offsets"; }
+    static StringRef getSizesAttrStrName() { return "sizes"; }
+    static StringRef getStridesAttrStrName() { return "strides"; }
     VectorType getVectorType(){ return vector().getType().cast<VectorType>(); }
     void getOffsets(SmallVectorImpl<int64_t> &results);
-    bool hasNonUnitStrides() { 
+    bool hasNonUnitStrides() {
       return llvm::any_of(strides(), [](Attribute attr) {
         return attr.cast<IntegerAttr>().getInt() != 1;
       });
     }
   }];
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
print %1
             0 | 1    1    0
       rows  1 | 1    1    0
             2 | 1    1    0
             3 | 0    0    0
     ```
   }];
 
   let extraClassDeclaration = [{
-    static StringRef getMaskDimSizesAttrName() { return "mask_dim_sizes"; }
+    static StringRef getMaskDimSizesAttrStrName() { return "mask_dim_sizes"; }
   }];
   let assemblyFormat = "$mask_dim_sizes attr-dict `:` type(results)";
   let hasVerifier = 1;
 }
 
 def Vector_CreateMaskOp :
   Vector_Op<"create_mask", [NoSideEffect]>,
     Arguments<(ins Variadic<Index>:$operands)>,
def Vector_TransposeOp :
   let extraClassDeclaration = [{
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
     VectorType getResultType() {
       return result().getType().cast<VectorType>();
     }
     void getTransp(SmallVectorImpl<int64_t> &results);
-    static StringRef getTranspAttrName() { return "transp"; }
+    static StringRef getTranspAttrStrName() { return "transp"; }
   }];
   let assemblyFormat = [{
     $vector `,` $transp attr-dict `:` type($vector) `to` type($result)
   }];
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
def Vector_ScanOp :
   }];
   let builders = [
     OpBuilder<(ins "Value":$source, "Value":$initial_value,
                    "CombiningKind":$kind,
                    CArg<"int64_t", "0">:$reduction_dim,
                    CArg<"bool", "true">:$inclusive)>
   ];
   let extraClassDeclaration = [{
-    static StringRef getKindAttrName() { return "kind"; }
-    static StringRef getReductionDimAttrName() { return "reduction_dim"; }
+    static StringRef getKindAttrStrName() { return "kind"; }
+    static StringRef getReductionDimAttrStrName() { return "reduction_dim"; }
     VectorType getSourceType() {
       return source().getType().cast<VectorType>();
     }
     VectorType getDestType() {
       return dest().getType().cast<VectorType>();
     }
     VectorType getAccumulatorType() {
       return accumulated_value().getType().cast<VectorType>();

mlir/include/mlir/Interfaces/VectorInterfaces.td

let description = [{
     Encodes properties of a transfer read or write operation.
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     StaticInterfaceMethod<
       /*desc=*/"Return the `in_bounds` attribute name.",
       /*retTy=*/"::mlir::StringRef",
-      /*methodName=*/"getInBoundsAttrName",
+      /*methodName=*/"getInBoundsAttrStrName",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/ [{ return "in_bounds"; }]
     >,
     StaticInterfaceMethod<
       /*desc=*/"Return the `permutation_map` attribute name.",
       /*retTy=*/"::mlir::StringRef",
-      /*methodName=*/"getPermutationMapAttrName",
+      /*methodName=*/"getPermutationMapAttrStrName",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/ [{ return "permutation_map"; }]
     >,
     InterfaceMethod<
       /*desc=*/[{ Return `true` if dimension `dim` is in-bounds. Return `false`
                  otherwise. }],
       /*retTy=*/"bool",

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

static void hoistReadWrite(HoistableRead read, HoistableWrite write,
   // update on the tensor operands.
   if (write.insertSliceOp) {
     newForOp.getResult(initArgNumber)
         .replaceAllUsesWith(write.insertSliceOp.getResult());
     write.transferWriteOp.sourceMutable().assign(read.extractSliceOp.result());
     write.insertSliceOp.destMutable().assign(read.extractSliceOp.source());
   } else {
     newForOp.getResult(initArgNumber)
-        .replaceAllUsesWith(write.transferWriteOp.getResult(0));
+        .replaceAllUsesWith(write.transferWriteOp.getResult());
     write.transferWriteOp.sourceMutable().assign(
         newForOp.getResult(initArgNumber));
   }
 
   // Always update with the newly yield tensor and vector.
   write.transferWriteOp.vectorMutable().assign(newForOp.getResults().back());
 }
 

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

auto targetType = MultiDimReductionOp::inferDestType(
       sourceVectorType.getShape(), reductionMask,
       sourceVectorType.getElementType());
   result.addTypes(targetType);
 
   SmallVector<int64_t> reductionDims;
   for (const auto &en : llvm::enumerate(reductionMask))
     if (en.value())
       reductionDims.push_back(en.index());
-  result.addAttribute(getReductionDimsAttrName(),
+  result.addAttribute(getReductionDimsAttrStrName(),
                       builder.getI64ArrayAttr(reductionDims));
-  result.addAttribute(getKindAttrName(),
+  result.addAttribute(getKindAttrStrName(),
                       CombiningKindAttr::get(kind, builder.getContext()));
 }
 
 LogicalResult MultiDimReductionOp::verify() {
   auto reductionMask = getReductionMask();
   auto targetType = MultiDimReductionOp::inferDestType(
       getSourceVectorType().getShape(), reductionMask,
       getSourceVectorType().getElementType());

 //===----------------------------------------------------------------------===//
 
 void vector::ContractionOp::build(OpBuilder &builder, OperationState &result,
                                   Value lhs, Value rhs, Value acc,
                                   ArrayRef<ArrayRef<AffineExpr>> indexingExprs,
                                   ArrayRef<StringRef> iteratorTypes) {
   result.addOperands({lhs, rhs, acc});
   result.addTypes(acc.getType());
-  result.addAttribute(getIndexingMapsAttrName(),
+  result.addAttribute(::mlir::getIndexingMapsAttrName(),
                       builder.getAffineMapArrayAttr(
                           AffineMap::inferFromExprList(indexingExprs)));
-  result.addAttribute(getIteratorTypesAttrName(),
+  result.addAttribute(::mlir::getIteratorTypesAttrName(),
                       builder.getStrArrayAttr(iteratorTypes));
 }
 
 void vector::ContractionOp::build(OpBuilder &builder, OperationState &result,
                                   Value lhs, Value rhs, Value acc,
                                   ArrayAttr indexingMaps,
                                   ArrayAttr iteratorTypes) {
   build(builder, result, lhs, rhs, acc, indexingMaps, iteratorTypes,
         ContractionOp::getDefaultKind());
 }
 
 void vector::ContractionOp::build(OpBuilder &builder, OperationState &result,
                                   Value lhs, Value rhs, Value acc,
                                   ArrayAttr indexingMaps,
                                   ArrayAttr iteratorTypes, CombiningKind kind) {
   result.addOperands({lhs, rhs, acc});
   result.addTypes(acc.getType());
-  result.addAttribute(getIndexingMapsAttrName(), indexingMaps);
-  result.addAttribute(getIteratorTypesAttrName(), iteratorTypes);
-  result.addAttribute(ContractionOp::getKindAttrName(),
+  result.addAttribute(::mlir::getIndexingMapsAttrName(), indexingMaps);
+  result.addAttribute(::mlir::getIteratorTypesAttrName(), iteratorTypes);
+  result.addAttribute(ContractionOp::getKindAttrStrName(),
                       CombiningKindAttr::get(kind, builder.getContext()));
 }
 
 ParseResult ContractionOp::parse(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::OperandType lhsInfo;
   OpAsmParser::OperandType rhsInfo;
   OpAsmParser::OperandType accInfo;
   SmallVector<OpAsmParser::OperandType, 2> masksInfo;
if (parser.parseAttribute(dictAttr, "_", result.attributes) ||
       parser.parseKeywordType("into", resultType) ||
       parser.resolveOperand(lhsInfo, types[0], result.operands) ||
       parser.resolveOperand(rhsInfo, types[1], result.operands) ||
       parser.resolveOperand(accInfo, resultType, result.operands) ||
       parser.addTypeToList(resultType, result.types))
     return failure();
   result.attributes.assign(dictAttr.getValue().begin(),
                            dictAttr.getValue().end());
-  if (!result.attributes.get(ContractionOp::getKindAttrName())) {
-    result.addAttribute(ContractionOp::getKindAttrName(),
+  if (!result.attributes.get(ContractionOp::getKindAttrStrName())) {
+    result.addAttribute(ContractionOp::getKindAttrStrName(),
                         CombiningKindAttr::get(ContractionOp::getDefaultKind(),
                                                result.getContext()));
   }
   if (masksInfo.empty())
     return success();
   if (masksInfo.size() != 2)
     return parser.emitError(parser.getNameLoc(),
                             "expected zero or exactly 2 vector mask operands");
if (indexing_maps().size() != 3)
     return emitOpError("expected an indexing map for each vector operand");
 
   // Verify that each index map has 'numIterators' inputs, no symbols, and
   // that the number of map outputs equals the rank of its associated
   // vector operand.
   unsigned numIterators = iterator_types().getValue().size();
   for (const auto &it : llvm::enumerate(indexing_maps())) {
     auto index = it.index();
-    auto map = it.value().cast<AffineMapAttr>().getValue();
+    auto map = it.value();
     if (map.getNumSymbols() != 0)
       return emitOpError("expected indexing map ")
              << index << " to have no symbols";
     auto vectorType = getOperand(index).getType().dyn_cast<VectorType>();
     unsigned rank = vectorType ? vectorType.getShape().size() : 0;
     // Verify that the map has the right number of inputs, outputs, and indices.
     // This also correctly accounts for (..) -> () for rank-0 results.
     if (map.getNumDims() != numIterators)
LogicalResult ContractionOp::verify() {
   auto elementType = vectorType ? vectorType.getElementType() : resType;
   if (!isSupportedCombiningKind(kind(), elementType))
     return emitOpError("unsupported contraction type");
 
   return success();
 }
 
 ArrayRef<StringRef> ContractionOp::getTraitAttrNames() {
-  static constexpr StringRef names[3] = {getIndexingMapsAttrName(),
-                                         getIteratorTypesAttrName(),
-                                         ContractionOp::getKindAttrName()};
+  static constexpr StringRef names[3] = {::mlir::getIndexingMapsAttrName(),
+                                         ::mlir::getIteratorTypesAttrName(),
+                                         ContractionOp::getKindAttrStrName()};
   return llvm::makeArrayRef(names);
 }
 
 static int64_t getResultIndex(AffineMap map, AffineExpr targetExpr) {
   for (int64_t i = 0, e = map.getNumResults(); i < e; ++i)
     if (targetExpr == map.getResult(i))
       return i;
   return -1;
for (const auto &it : llvm::enumerate(iterator_types())) {
     assert(resDimIndex >= 0);
     assert(resVectorType != nullptr);
     iterationBounds.push_back(resVectorType.getShape()[resDimIndex]);
   }
 }
 
 void ContractionOp::getIterationIndexMap(
     std::vector<DenseMap<int64_t, int64_t>> &iterationIndexMap) {
-  unsigned numMaps = indexing_maps().getValue().size();
+  unsigned numMaps = indexing_maps().size();
   iterationIndexMap.resize(numMaps);
   for (const auto &it : llvm::enumerate(indexing_maps())) {
     auto index = it.index();
-    auto map = it.value().cast<AffineMapAttr>().getValue();
+    auto map = it.value();
     for (unsigned i = 0, e = map.getNumResults(); i < e; ++i) {
       auto dim = map.getResult(i).cast<AffineDimExpr>();
       iterationIndexMap[index][dim.getPosition()] = i;
     }
   }
 }
 
 std::vector<std::pair<int64_t, int64_t>> ContractionOp::getContractingDimMap() {
   SmallVector<AffineMap, 4> indexingMaps(getIndexingMaps());
   return getDimMap(indexingMaps, iterator_types(),
                    getReductionIteratorTypeName(), getContext());
 }
 
 std::vector<std::pair<int64_t, int64_t>> ContractionOp::getBatchDimMap() {
   SmallVector<AffineMap, 4> indexingMaps(getIndexingMaps());
   return getDimMap(indexingMaps, iterator_types(),
                    getParallelIteratorTypeName(), getContext());
 }
 
-SmallVector<AffineMap, 4> ContractionOp::getIndexingMaps() {
-  return llvm::to_vector<4>(
-      llvm::map_range(indexing_maps().getValue(), [](Attribute mapAttr) {
-        return mapAttr.cast<AffineMapAttr>().getValue();
-      }));
-}
-
 Optional<SmallVector<int64_t, 4>> ContractionOp::getShapeForUnroll() {
   SmallVector<int64_t, 4> shape;
   getIterationBounds(shape);
   return shape;
 }
 
 /// Return a fused vector::ContractionOp which represents a patterns such as:
 ///

 }
 
 void vector::ExtractOp::build(OpBuilder &builder, OperationState &result,
                               Value source, ArrayRef<int64_t> position) {
   result.addOperands(source);
   auto positionAttr = getVectorSubscriptAttr(builder, position);
   result.addTypes(inferExtractOpResultType(source.getType().cast<VectorType>(),
                                            positionAttr));
-  result.addAttribute(getPositionAttrName(), positionAttr);
+  result.addAttribute(getPositionAttrStrName(), positionAttr);
 }
 
 // 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 pos.getDefiningOp<arith::ConstantIndexOp>().value();
while (ExtractOp nextOp = currentOp.vector().getDefiningOp<ExtractOp>()) {
     currentOp = nextOp;
     auto extrPos = extractVector<int64_t>(currentOp.position());
     globalPosition.append(extrPos.rbegin(), extrPos.rend());
   }
   extractOp.setOperand(currentOp.vector());
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
   std::reverse(globalPosition.begin(), globalPosition.end());
-  extractOp->setAttr(ExtractOp::getPositionAttrName(),
+  extractOp->setAttr(ExtractOp::getPositionAttrStrName(),
                      b.getI64ArrayAttr(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.
if (extractResultRank < broadcastSrcRank) {
     auto extractPos = extractVector<int64_t>(extractOp.position());
     unsigned rankDiff = broadcastSrcRank - extractResultRank;
     extractPos.erase(
         extractPos.begin(),
         std::next(extractPos.begin(), extractPos.size() - rankDiff));
     extractOp.setOperand(source);
     // OpBuilder is only used as a helper to build an I64ArrayAttr.
     OpBuilder b(extractOp.getContext());
-    extractOp->setAttr(ExtractOp::getPositionAttrName(),
+    extractOp->setAttr(ExtractOp::getPositionAttrStrName(),
                        b.getI64ArrayAttr(extractPos));
     return extractOp.getResult();
   }
   return Value();
 }
 
 // Fold extractOp with source coming from ShapeCast op.
 static Value foldExtractFromShapeCast(ExtractOp extractOp) {
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(newStrides, position);
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
-  extractOp->setAttr(ExtractOp::getPositionAttrName(),
+  extractOp->setAttr(ExtractOp::getPositionAttrStrName(),
                      b.getI64ArrayAttr(newPosition));
   extractOp.setOperand(shapeCastOp.source());
   return extractOp.getResult();
 }
 
 /// Fold an ExtractOp from ExtractStridedSliceOp.
 static Value foldExtractFromExtractStrided(ExtractOp extractOp) {
   auto extractStridedSliceOp =
if (destinationRank >
     return Value();
   auto extractedPos = extractVector<int64_t>(extractOp.position());
   assert(extractedPos.size() >= sliceOffsets.size());
   for (size_t i = 0, e = sliceOffsets.size(); i < e; i++)
     extractedPos[i] = extractedPos[i] + sliceOffsets[i];
   extractOp.vectorMutable().assign(extractStridedSliceOp.vector());
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
-  extractOp->setAttr(ExtractOp::getPositionAttrName(),
+  extractOp->setAttr(ExtractOp::getPositionAttrStrName(),
                      b.getI64ArrayAttr(extractedPos));
   return extractOp.getResult();
 }
 
 /// Fold extract_op fed from a chain of insertStridedSlice ops.
 static Value foldExtractStridedOpFromInsertChain(ExtractOp op) {
   int64_t destinationRank = op.getType().isa<VectorType>()
                                 ? op.getType().cast<VectorType>().getRank()
if (!disjoint) {
         if (insertOp.getSourceVectorType().getDimSize(i + srcRankDiff) !=
             insertOp.getDestVectorType().getDimSize(i + srcRankDiff +
                                                     insertRankDiff))
           return Value();
       }
       op.vectorMutable().assign(insertOp.source());
       // OpBuilder is only used as a helper to build an I64ArrayAttr.
       OpBuilder b(op.getContext());
-      op->setAttr(ExtractOp::getPositionAttrName(),
+      op->setAttr(ExtractOp::getPositionAttrStrName(),
                   b.getI64ArrayAttr(offsetDiffs));
       return op.getResult();
     }
     // If the chunk extracted is disjoint from the chunk inserted, keep
     // looking in the insert chain.
     insertOp = insertOp.dest().getDefiningOp<InsertStridedSliceOp>();
   }
   return Value();

 void ShuffleOp::build(OpBuilder &builder, OperationState &result, Value v1,
                       Value v2, ArrayRef<int64_t> mask) {
   result.addOperands({v1, v2});
   auto maskAttr = getVectorSubscriptAttr(builder, mask);
   auto v1Type = v1.getType().cast<VectorType>();
   auto shape = llvm::to_vector<4>(v1Type.getShape());
   shape[0] = mask.size();
   result.addTypes(VectorType::get(shape, v1Type.getElementType()));
-  result.addAttribute(getMaskAttrName(), maskAttr);
+  result.addAttribute(getMaskAttrStrName(), maskAttr);
 }
 
 void ShuffleOp::print(OpAsmPrinter &p) {
   p << " " << v1() << ", " << v2() << " " << mask();
   p.printOptionalAttrDict((*this)->getAttrs(), {ShuffleOp::getMaskAttrName()});
   p << " : " << v1().getType() << ", " << v2().getType();
 }
 

 }
 
 ParseResult ShuffleOp::parse(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::OperandType v1, v2;
   Attribute attr;
   VectorType v1Type, v2Type;
   if (parser.parseOperand(v1) || parser.parseComma() ||
       parser.parseOperand(v2) ||
-      parser.parseAttribute(attr, ShuffleOp::getMaskAttrName(),
+      parser.parseAttribute(attr, ShuffleOp::getMaskAttrStrName(),
                             result.attributes) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(v1Type) || parser.parseComma() ||
       parser.parseType(v2Type) ||
       parser.resolveOperand(v1, v1Type, result.operands) ||
       parser.resolveOperand(v2, v2Type, result.operands))
     return failure();
   // Construct resulting type: leading dimension matches mask length,

 // 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(getPositionAttrName(), positionAttr);
+  result.addAttribute(getPositionAttrStrName(), 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 pos.getDefiningOp<arith::ConstantIndexOp>().value();

 void InsertStridedSliceOp::build(OpBuilder &builder, OperationState &result,
                                  Value source, Value dest,
                                  ArrayRef<int64_t> offsets,
                                  ArrayRef<int64_t> strides) {
   result.addOperands({source, dest});
   auto offsetsAttr = getVectorSubscriptAttr(builder, offsets);
   auto stridesAttr = getVectorSubscriptAttr(builder, strides);
   result.addTypes(dest.getType());
-  result.addAttribute(getOffsetsAttrName(), offsetsAttr);
-  result.addAttribute(getStridesAttrName(), stridesAttr);
+  result.addAttribute(getOffsetsAttrStrName(), offsetsAttr);
+  result.addAttribute(getStridesAttrStrName(), stridesAttr);
 }
 
 // TODO: Should be moved to Tablegen Confined attributes.
 template <typename OpType>
 static LogicalResult isIntegerArrayAttrSmallerThanShape(OpType op,
                                                         ArrayAttr arrayAttr,
                                                         ArrayRef<int64_t> shape,
                                                         StringRef attrName) {
ParseResult OuterProductOp::parse(OpAsmParser &parser, OperationState &result) {
   if (!vLHS)
     return parser.emitError(parser.getNameLoc(),
                             "expected vector type for operand #1");
   VectorType resType =
       vRHS ? VectorType::get({vLHS.getDimSize(0), vRHS.getDimSize(0)},
                              vLHS.getElementType())
            : VectorType::get({vLHS.getDimSize(0)}, vLHS.getElementType());
 
-  if (!result.attributes.get(OuterProductOp::getKindAttrName())) {
+  if (!result.attributes.get(OuterProductOp::getKindAttrStrName())) {
     result.attributes.append(
-        OuterProductOp::getKindAttrName(),
+        OuterProductOp::getKindAttrStrName(),
         CombiningKindAttr::get(OuterProductOp::getDefaultKind(),
                                result.getContext()));
   }
 
   return failure(
       parser.resolveOperand(operandsInfo[0], tLHS, result.operands) ||
       parser.resolveOperand(operandsInfo[1], tRHS, result.operands) ||
       (operandsInfo.size() > 2 &&
void ExtractStridedSliceOp::build(OpBuilder &builder, OperationState &result,
                                   ArrayRef<int64_t> strides) {
   result.addOperands(source);
   auto offsetsAttr = getVectorSubscriptAttr(builder, offsets);
   auto sizesAttr = getVectorSubscriptAttr(builder, sizes);
   auto stridesAttr = getVectorSubscriptAttr(builder, strides);
   result.addTypes(
       inferStridedSliceOpResultType(source.getType().cast<VectorType>(),
                                     offsetsAttr, sizesAttr, stridesAttr));
-  result.addAttribute(getOffsetsAttrName(), offsetsAttr);
-  result.addAttribute(getSizesAttrName(), sizesAttr);
-  result.addAttribute(getStridesAttrName(), stridesAttr);
+  result.addAttribute(getOffsetsAttrStrName(), offsetsAttr);
+  result.addAttribute(getSizesAttrStrName(), sizesAttr);
+  result.addAttribute(getStridesAttrStrName(), stridesAttr);
 }
 
 LogicalResult ExtractStridedSliceOp::verify() {
   auto type = getVectorType();
   auto offsets = offsetsAttr();
   auto sizes = sizesAttr();
   auto strides = stridesAttr();
   if (offsets.size() != sizes.size() || offsets.size() != strides.size())
for (unsigned dim = 0, e = extractOffsets.size(); dim < e; ++dim) {
       disjoint = true;
       break;
     }
     // The extract element chunk is a subset of the insert element.
     if (!disjoint && !patialoverlap) {
       op.setOperand(insertOp.source());
       // OpBuilder is only used as a helper to build an I64ArrayAttr.
       OpBuilder b(op.getContext());
-      op->setAttr(ExtractStridedSliceOp::getOffsetsAttrName(),
+      op->setAttr(ExtractStridedSliceOp::getOffsetsAttrStrName(),
                   b.getI64ArrayAttr(offsetDiffs));
       return success();
     }
     // If the chunk extracted is disjoint from the chunk inserted, keep looking
     // in the insert chain.
     if (disjoint)
       insertOp = insertOp.dest().getDefiningOp<InsertStridedSliceOp>();
     else {
verifyTransferOp(VectorTransferOpInterface op, ShapedType shapedType,
 
   return success();
 }
 
 static void printTransferAttrs(OpAsmPrinter &p, VectorTransferOpInterface op) {
   SmallVector<StringRef, 3> elidedAttrs;
   elidedAttrs.push_back(TransferReadOp::getOperandSegmentSizeAttr());
   if (op.permutation_map().isMinorIdentity())
-    elidedAttrs.push_back(op.getPermutationMapAttrName());
+    elidedAttrs.push_back(op.getPermutationMapAttrStrName());
   bool elideInBounds = true;
   if (auto inBounds = op.in_bounds()) {
     for (auto attr : *inBounds) {
       if (attr.template cast<BoolAttr>().getValue()) {
         elideInBounds = false;
         break;
       }
     }
   }
   if (elideInBounds)
-    elidedAttrs.push_back(op.getInBoundsAttrName());
+    elidedAttrs.push_back(op.getInBoundsAttrStrName());
   p.printOptionalAttrDict(op->getAttrs(), elidedAttrs);
 }
 
 void TransferReadOp::print(OpAsmPrinter &p) {
   p << " " << source() << "[" << indices() << "], " << padding();
   if (mask())
     p << ", " << mask();
   printTransferAttrs(p, *this);
if (types.size() != 2)
     return parser.emitError(typesLoc, "requires two types");
   auto indexType = builder.getIndexType();
   auto shapedType = types[0].dyn_cast<ShapedType>();
   if (!shapedType || !shapedType.isa<MemRefType, RankedTensorType>())
     return parser.emitError(typesLoc, "requires memref or ranked tensor type");
   VectorType vectorType = types[1].dyn_cast<VectorType>();
   if (!vectorType)
     return parser.emitError(typesLoc, "requires vector type");
-  auto permutationAttrName = TransferReadOp::getPermutationMapAttrName();
+  auto permutationAttrName = TransferReadOp::getPermutationMapAttrStrName();
   Attribute mapAttr = result.attributes.get(permutationAttrName);
   if (!mapAttr) {
     auto permMap = getTransferMinorIdentityMap(shapedType, vectorType);
     // Update `mapAttr` that is used later to determine mask type.
     mapAttr = AffineMapAttr::get(permMap);
     result.attributes.set(permutationAttrName, mapAttr);
   }
   if (parser.resolveOperand(sourceInfo, shapedType, result.operands) ||
for (unsigned i = 0; i < op.getTransferRank(); ++i) {
     newInBounds.push_back(inBounds);
     // We commit the pattern if it is "more inbounds".
     changed |= inBounds;
   }
   if (!changed)
     return failure();
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(op.getContext());
-  op->setAttr(TransferOp::getInBoundsAttrName(),
+  op->setAttr(TransferOp::getInBoundsAttrStrName(),
               b.getBoolArrayAttr(newInBounds));
   return success();
 }
 
 ///  ```
 ///  %w0 = vector.transfer_write %v0, %arg0[%c1, %c0] {in_bounds = [true, true]}
 ///    : vector<1x4xf32>, tensor<4x4xf32>
 ///  %0 = vector.transfer_read %w0[%c1, %c0], %cf0 {in_bounds = [true, true]}
if (types.size() != 2)
     return parser.emitError(typesLoc, "requires two types");
   auto indexType = builder.getIndexType();
   VectorType vectorType = types[0].dyn_cast<VectorType>();
   if (!vectorType)
     return parser.emitError(typesLoc, "requires vector type");
   ShapedType shapedType = types[1].dyn_cast<ShapedType>();
   if (!shapedType || !shapedType.isa<MemRefType, RankedTensorType>())
     return parser.emitError(typesLoc, "requires memref or ranked tensor type");
-  auto permutationAttrName = TransferWriteOp::getPermutationMapAttrName();
+  auto permutationAttrName = TransferWriteOp::getPermutationMapAttrStrName();
   auto attr = result.attributes.get(permutationAttrName);
   if (!attr) {
     auto permMap = getTransferMinorIdentityMap(shapedType, vectorType);
     result.attributes.set(permutationAttrName, AffineMapAttr::get(permMap));
   }
   if (parser.resolveOperand(vectorInfo, vectorType, result.operands) ||
       parser.resolveOperand(sourceInfo, shapedType, result.operands) ||
       parser.resolveOperands(indexInfo, indexType, result.operands))
void vector::TransposeOp::build(OpBuilder &builder, OperationState &result,
                                 Value vector, ArrayRef<int64_t> transp) {
   VectorType vt = vector.getType().cast<VectorType>();
   SmallVector<int64_t, 4> transposedShape(vt.getRank());
   for (unsigned i = 0; i < transp.size(); ++i)
     transposedShape[i] = vt.getShape()[transp[i]];
 
   result.addOperands(vector);
   result.addTypes(VectorType::get(transposedShape, vt.getElementType()));
-  result.addAttribute(getTranspAttrName(), builder.getI64ArrayAttr(transp));
+  result.addAttribute(getTranspAttrStrName(), builder.getI64ArrayAttr(transp));
 }
 
 // Eliminates transpose operations, which produce values identical to their
 // input values. This happens when the dimensions of the input vector remain in
 // their original order after the transpose operation.
 OpFoldResult vector::TransposeOp::fold(ArrayRef<Attribute> operands) {
   SmallVector<int64_t, 4> transp;
   getTransp(transp);

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

LogicalResult mlir::vector::splitFullAndPartialTransfer(
     RewriterBase &b, VectorTransferOpInterface xferOp,
     VectorTransformsOptions options, scf::IfOp *ifOp) {
   if (options.vectorTransferSplit == VectorTransferSplit::None)
     return failure();
 
   SmallVector<bool, 4> bools(xferOp.getTransferRank(), true);
   auto inBoundsAttr = b.getBoolArrayAttr(bools);
   if (options.vectorTransferSplit == VectorTransferSplit::ForceInBounds) {
-    xferOp->setAttr(xferOp.getInBoundsAttrName(), inBoundsAttr);
+    xferOp->setAttr(xferOp.getInBoundsAttrStrName(), inBoundsAttr);
     return success();
   }
 
   // Assert preconditions. Additionally, keep the variables in an inner scope to
   // ensure they aren't used in the wrong scopes further down.
   {
     assert(succeeded(splitFullAndPartialTransferPrecondition(xferOp)) &&
            "Expected splitFullAndPartialTransferPrecondition to hold");
scf::IfOp fullPartialIfOp =
                                           alloc);
     if (ifOp)
       *ifOp = fullPartialIfOp;
 
     // Set existing read op to in-bounds, it always reads from a full buffer.
     for (unsigned i = 0, e = returnTypes.size(); i != e; ++i)
       xferReadOp.setOperand(i, fullPartialIfOp.getResult(i));
 
-    xferOp->setAttr(xferOp.getInBoundsAttrName(), inBoundsAttr);
+    xferOp->setAttr(xferOp.getInBoundsAttrStrName(), inBoundsAttr);
 
     return success();
   }
 
   auto xferWriteOp = cast<vector::TransferWriteOp>(xferOp.getOperation());
 
   // Decide which location to write the entire vector to.
   auto memrefAndIndices = getLocationToWriteFullVec(

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

ContractionOpToMatmulOpLowering::matchAndRewrite(vector::ContractionOp op,
   // Perform lhs + rhs transpositions to conform to matmul row-major semantics.
   // Bail out if the contraction cannot be put in this form.
   MLIRContext *ctx = op.getContext();
   Location loc = op.getLoc();
   AffineExpr m, n, k;
   bindDims(rew.getContext(), m, n, k);
   // LHS must be A(m, k) or A(k, m).
   Value lhs = op.lhs();
-  auto lhsMap = op.indexing_maps()[0].cast<AffineMapAttr>().getValue();
+  auto lhsMap = op.indexing_maps()[0];
   if (lhsMap == AffineMap::get(3, 0, {k, m}, ctx))
     lhs = rew.create<vector::TransposeOp>(loc, lhs, ArrayRef<int64_t>{1, 0});
   else if (lhsMap != AffineMap::get(3, 0, {m, k}, ctx))
     return failure();
 
   // RHS must be B(k, n) or B(n, k).
   Value rhs = op.rhs();
-  auto rhsMap = op.indexing_maps()[1].cast<AffineMapAttr>().getValue();
+  auto rhsMap = op.indexing_maps()[1];
   if (rhsMap == AffineMap::get(3, 0, {n, k}, ctx))
     rhs = rew.create<vector::TransposeOp>(loc, rhs, ArrayRef<int64_t>{1, 0});
   else if (rhsMap != AffineMap::get(3, 0, {k, n}, ctx))
     return failure();
 
   // At this point lhs and rhs are in row-major.
   VectorType lhsType = lhs.getType().cast<VectorType>();
   VectorType rhsType = rhs.getType().cast<VectorType>();
Value mul = rew.create<vector::MatmulOp>(loc, lhs, rhs, lhsRows, lhsColumns,
                                            rhsColumns);
   mul = rew.create<vector::ShapeCastOp>(
       loc,
       VectorType::get({lhsRows, rhsColumns},
                       getElementTypeOrSelf(op.acc().getType())),
       mul);
 
   // ACC must be C(m, n) or C(n, m).
-  auto accMap = op.indexing_maps()[2].cast<AffineMapAttr>().getValue();
+  auto accMap = op.indexing_maps()[2];
   if (accMap == AffineMap::get(3, 0, {n, m}, ctx))
     mul = rew.create<vector::TransposeOp>(loc, mul, ArrayRef<int64_t>{1, 0});
   else if (accMap != AffineMap::get(3, 0, {m, n}, ctx))
     llvm_unreachable("invalid contraction semantics");
 
   Value res =
       elementType.isa<IntegerType>()
           ? static_cast<Value>(rew.create<arith::AddIOp>(loc, op.acc(), mul))