[mlir] Flip LinAlg dialect to _Both

[jpienaar]

Summary

This one required more changes than ideal due to overlapping generated name
with different return types. Changed getIndexingMaps to getIndexingMapsArray to
move it out of the way/highlight that it returns (more expensively) a
SmallVector and uses the prefixed name for the Attribute.

[aartbik]

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

153 ↗

(On Diff #445183)

This file is being refactored out of Linalg, see https://reviews.llvm.org/D129910

[jpienaar]

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

153 ↗

(On Diff #445183)

SG, luckily change is minimal, so easy to move (I could rename this independent of accessor prefixing too, but the only reason for review is to make folks aware of the rename and in case there is feedback for better name, unfortunately interfaces end up coupling changes).

[nicolasvasilache]

Thanks much for doing this @jpienaar , this is much better!

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

using RegionBuilderFunType = llvm::function_ref<
       void(ImplicitLocOpBuilder &b, Block &, ArrayRef<NamedAttribute>)>;
     RegionBuilderFunType getRegionBuilder(StringRef name) {
       return namedStructuredOpRegionBuilders.lookup(name);
     }
     private:
       llvm::StringMap<RegionBuilderFunType> namedStructuredOpRegionBuilders;
   }];
 
-  // TODO: This has overlapping accessors with generated when switched to
-  // prefixed. Fix and update to _Both & then _Prefixed.
-  let emitAccessorPrefix = kEmitAccessorPrefix_Raw;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 // Define the function attribute enums matching the OpDSL functions.
 def UnaryFn : I32EnumAttr<"UnaryFn", "", [
   I32EnumAttrCase<"exp", 0>,
   I32EnumAttrCase<"log", 1>,
   I32EnumAttrCase<"abs", 2>,
   I32EnumAttrCase<"ceil", 3>,

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

let methods = [
     /*desc=*/[{
       Returns whether the given op has indexing maps that correspond to a
       row-major matmul operation.
     }],
     /*retTy=*/"bool",
     /*methodName=*/"isRowMajorMatmul",
     /*args=*/(ins),
     /*methodBody=*/[{
-        return mlir::isRowMajorMatmul($_op.indexing_maps());
+        return mlir::isRowMajorMatmul($_op.getIndexingMaps());
     }]>,
     InterfaceMethod<
     /*desc=*/[{
       Returns whether the given op has indexing maps that correspond to a
       column-major matmul operation.
     }],
     /*retTy=*/"bool",
     /*methodName=*/"isColumnMajorMatmul",
     /*args=*/(ins),
     /*methodBody=*/[{
-        return mlir::isColumnMajorMatmul($_op.indexing_maps());
+        return mlir::isColumnMajorMatmul($_op.getIndexingMaps());
     }]>,
     InterfaceMethod<
     /*desc=*/[{
       Returns whether the given op has indexing maps that correspond to a
       row-major batch matmul operation.
     }],
     /*retTy=*/"bool",
     /*methodName=*/"isRowMajorBatchMatmul",
     /*args=*/(ins),
     /*methodBody=*/[{
-        return mlir::isRowMajorBatchMatmul($_op.indexing_maps());
+        return mlir::isRowMajorBatchMatmul($_op.getIndexingMaps());
     }]>,
   ];
 }
 
 def LinalgConvolutionOpInterface : OpInterface<"ConvolutionOpInterface"> {
   let description = [{
     A convolution is defined in general terms:
     1. Has an `image` and a `filter` operand.
InterfaceMethod<
       }],
       /*retTy=*/"AffineMap",
       /*methodName=*/"getTiedIndexingMap",
       /*args=*/(ins "OpOperand*":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opOperand->getOwner() == this->getOperation());
         auto indexingMaps =
-          $_op.indexing_maps().template getAsValueRange<AffineMapAttr>();
+          $_op.getIndexingMaps().template getAsValueRange<AffineMapAttr>();
         return *(indexingMaps.begin() + opOperand->getOperandNumber());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the indexing map for a `result`.
       }],
       /*retTy=*/"AffineMap",
       /*methodName=*/"getTiedIndexingMapForResult",
       /*args=*/(ins "OpResult":$result),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(result.getOwner() == this->getOperation());
         auto indexingMaps =
-          $_op.indexing_maps().template getAsValueRange<AffineMapAttr>();
+          $_op.getIndexingMaps().template getAsValueRange<AffineMapAttr>();
           return *(indexingMaps.begin() + getNumInputs() +
               result.getResultNumber());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the result tied to `opOperand`.
       }],
InterfaceMethod<
       /*methodBody=*/"",
       /*defaultImplementation=*/[{ return success(); }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the indexing maps attribute within the current operation.
       }],
       /*retTy=*/"ArrayAttr",
-      /*methodName=*/"indexing_maps"
+      /*methodName=*/"getIndexingMaps"
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the indexing maps within the current operation.
       }],
       /*retTy=*/"SmallVector<AffineMap>",
-      /*methodName=*/"getIndexingMaps",
+      /*methodName=*/"getIndexingMapsArray",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        auto range = $_op.indexing_maps()
+        auto range = $_op.getIndexingMaps()
           .template getAsValueRange<AffineMapAttr>();
         return {range.begin(), range.end()};
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return true if any of the operands has a dynamic shape.
       }],
InterfaceMethod<
         traversal order for which we can still easily compute hyperrectangular
         loop bounds and subviews.
       }],
       /*retTy=*/"AffineMap",
       /*methodName=*/"getLoopsToShapesMap",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        auto r = $_op.indexing_maps().template getAsRange<AffineMapAttr>();
-        auto maps = llvm::to_vector<8>(
-            llvm::map_range(r, [](AffineMapAttr a) { return a.getValue(); }));
+        auto maps =  $_op.getIndexingMapsArray();
         return concatAffineMaps(maps);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Hook to provide a custom AffineMap used to construct the
         hyperrectangular loop iteration space given all the operand subshapes.
         This is used to answer the question:
InterfaceMethod<
       /*desc=*/[{
         Return true if all the indexing maps are projected permutations.
         Otherwise return false.
       }],
       /*retTy=*/"bool",
       /*methodName=*/"hasOnlyProjectedPermutations",
       (ins),
       [{
-        return llvm::all_of($_op.getIndexingMaps(),
+        return llvm::all_of($_op.getIndexingMapsArray(),
                             [](AffineMap map) { return map.isProjectedPermutation(); });
       }]
     >
   ];
 
   let extraClassDeclaration = [{
     /// Return the flat list of all operand dimension sizes in the order they
     /// appear in the operands.

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

def Linalg_InitTensorOp : Linalg_Op<"init_tensor",
   let results = (outs AnyTensor:$result);
 
   let assemblyFormat = [{
     custom<OperandsOrIntegersSizesList>($sizes, $static_sizes) attr-dict
     `:` type($result)
   }];
 
   let extraClassDeclaration = [{
-    static StringRef getStaticSizesAttrName() {
+    static StringRef getStaticSizesAttrStrName() {
       return "static_sizes";
     }
 
     RankedTensorType getType() {
       return getResult().getType().cast<RankedTensorType>(); }
 
     // Infer the shape of the result tensor given the static shapes
     // and element type of the result tensor.

mlir/include/mlir/Dialect/Utils/StructuredOpsUtils.h

struct Red : public IteratorType {
     Red() : IteratorType(getReductionIteratorTypeName()) {}
   };
   struct Win : public IteratorType {
     Win() : IteratorType(getWindowIteratorTypeName()) {}
   };
 
   StructuredGenerator(OpBuilder &builder, StructuredOpInterface op)
       : builder(builder), ctx(op.getContext()), loc(op.getLoc()),
-        iterators(op.getIteratorTypes()), maps(op.getIndexingMaps()), op(op) {}
+        iterators(op.getIteratorTypes()), maps(op.getIndexingMapsArray()),
+        op(op) {}
 
   bool iters(ArrayRef<IteratorType> its) {
     if (its.size() != iterators.size())
       return false;
     for (int i = 0, e = its.size(); i != e; ++i) {
       if (!its[i].isOfType(iterators[i]))
         return false;
     }

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

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,
-               Vector_AffineMapArrayAttr:$indexing_maps,
+               ArrayAttr:$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
let extraClassDeclaration = [{
     VectorType getRHSVectorMaskType() {
       if (llvm::size(getMasks()) != 2) return VectorType();
       return getOperand(4).getType().cast<VectorType>();
     }
     Type getResultType() { return getResult().getType(); }
     ArrayRef<StringRef> getTraitAttrNames();
     static unsigned getAccOperandIndex() { return 2; }
 
+    llvm::SmallVector<::mlir::AffineMap, 4> getIndexingMapsArray() {
+      return llvm::to_vector<4>(getIndexingMaps().getAsValueRange<::mlir::AffineMapAttr>());
+    }
+
     // 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.

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp

SingleWorkgroupReduction::matchAsPerformingReduction(
   // Make sure the original output has one element.
   if (!originalOutputType.hasStaticShape() ||
       originalOutputType.getNumElements() != 1)
     return llvm::None;
 
   if (!genericOp.hasSingleReductionLoop())
     return llvm::None;
 
-  if (genericOp.indexing_maps().getValue().size() != 2)
+  auto indexingMaps = genericOp.getIndexingMapsArray();
+  if (indexingMaps.size() != 2)
     return llvm::None;
 
   // TODO: create utility functions for these checks in Linalg
   // and use them.
-  auto inputMap = genericOp.indexing_maps().getValue()[0].cast<AffineMapAttr>();
-  auto outputMap =
-      genericOp.indexing_maps().getValue()[1].cast<AffineMapAttr>();
+  auto inputMap = indexingMaps[0];
+  auto outputMap = indexingMaps[1];
   // The indexing map for the input should be `(i) -> (i)`.
-  if (inputMap.getValue() !=
-      AffineMap::get(1, 0, getAffineDimExpr(0, op->getContext())))
+  if (inputMap != AffineMap::get(1, 0, getAffineDimExpr(0, op->getContext())))
     return llvm::None;
   // The indexing map for the input should be `(i) -> (0)`.
-  if (outputMap.getValue() !=
+  if (outputMap !=
       AffineMap::get(1, 0, getAffineConstantExpr(0, op->getContext())))
     return llvm::None;
 
   return linalg::RegionMatcher::matchAsScalarBinaryOp(genericOp);
 }
 
 LogicalResult SingleWorkgroupReduction::matchAndRewrite(
     linalg::GenericOp genericOp, OpAdaptor adaptor,

mlir/lib/Conversion/VectorToGPU/NvGpuSupport.cpp

PrepareContractToGPUMMASync::matchAndRewrite(vector::ContractionOp op,
   using MapList = ArrayRef<ArrayRef<AffineExpr>>;
   auto infer = [](MapList m) { return AffineMap::inferFromExprList(m); };
   AffineExpr m;
   AffineExpr n;
   AffineExpr k;
   bindDims(rewriter.getContext(), m, n, k);
   static constexpr std::array<int64_t, 2> perm = {1, 0};
   auto iteratorTypes = op.getIteratorTypes().getValue();
-  SmallVector<AffineMap, 4> maps = op.getIndexingMaps();
+  SmallVector<AffineMap, 4> maps = op.getIndexingMapsArray();
   if (iteratorTypes.size() != 3)
     return failure();
   if (!(isParallelIterator(iteratorTypes[0]) &&
         isParallelIterator(iteratorTypes[1]) &&
         isReductionIterator(iteratorTypes[2])))
     return failure();
 
   // The canonical form is "TNT" = A row-major, B col-major, C row-major.

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

static bool contractSupportsMMAMatrixType(vector::ContractionOp contract,
   if (!(isParallelIterator(iteratorTypes[0]) &&
         isParallelIterator(iteratorTypes[1]) &&
         isReductionIterator(iteratorTypes[2])))
     return false;
 
   // The contract needs to represent a matmul to be able to convert to
   // MMAMatrix matmul.
   if (!useNvGpu &&
-      contract.getIndexingMaps() != infer({{m, k}, {k, n}, {m, n}}))
+      contract.getIndexingMapsArray() != infer({{m, k}, {k, n}, {m, n}}))
     return false;
-  if (useNvGpu && contract.getIndexingMaps() != infer({{m, k}, {n, k}, {m, n}}))
+  if (useNvGpu &&
+      contract.getIndexingMapsArray() != infer({{m, k}, {n, k}, {m, n}}))
     return false;
 
   return true;
 }
 
 // Return the stide for the dimension 0 of |type| if it is a memref and has a
 // constant stride.
 static llvm::Optional<int64_t>
LogicalResult matchAndRewrite(vector::ContractionOp op,
 
     // Set up the parallel/reduction structure in right form.
     using MapList = ArrayRef<ArrayRef<AffineExpr>>;
     auto infer = [](MapList m) { return AffineMap::inferFromExprList(m); };
     AffineExpr m, n, k;
     bindDims(rewriter.getContext(), m, n, k);
     static constexpr std::array<int64_t, 2> perm = {1, 0};
     auto iteratorTypes = op.getIteratorTypes().getValue();
-    SmallVector<AffineMap, 4> maps = op.getIndexingMaps();
+    SmallVector<AffineMap, 4> maps = op.getIndexingMapsArray();
     if (!(isParallelIterator(iteratorTypes[0]) &&
           isParallelIterator(iteratorTypes[1]) &&
           isReductionIterator(iteratorTypes[2])))
       return failure();
     //
     // Two outer parallel, one inner reduction (matmat flavor).
     //
     if (maps == infer({{m, k}, {k, n}, {m, n}})) {

mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp

enum class MatchContractionResult {
   NotAddMul
 };
 static MatchContractionResult isContractionInterfaceImpl(Operation *op) {
   auto linalgOp = dyn_cast<linalg::LinalgOp>(op);
   if (!linalgOp)
     return MatchContractionResult::NotLinalgOp;
   if (linalgOp.getNumInputs() != 2 || linalgOp.getNumOutputs() != 1)
     return MatchContractionResult::WrongNumOperands;
-  auto mapRange = linalgOp.indexing_maps().getAsValueRange<AffineMapAttr>();
+  auto mapRange = linalgOp.getIndexingMapsArray();
   if (linalgOp.getNumReductionLoops() == 0)
     return MatchContractionResult::NoReduction;
   if (llvm::any_of(mapRange,
                    [](AffineMap m) { return !m.isProjectedPermutation(); }))
     return MatchContractionResult::NotProjectedPermutations;
   // TODO: more fields than add/mul.
   if (!isAddMul<arith::AddFOp, arith::MulFOp>(linalgOp->getRegion(0).front()) &&
       !isAddMul<arith::AddIOp, arith::MulIOp>(linalgOp->getRegion(0).front()) &&

 
 static MatchConvolutionResult isConvolutionInterfaceImpl(Operation *op) {
   auto linalgOp = dyn_cast<linalg::LinalgOp>(op);
   if (!linalgOp)
     return MatchConvolutionResult::NotLinalgOp;
   if (linalgOp.getNumInputs() < 2 || linalgOp.getNumOutputs() != 1)
     return MatchConvolutionResult::WrongNumOperands;
 
-  auto indexingMaps = linalgOp.getIndexingMaps();
+  auto indexingMaps = linalgOp.getIndexingMapsArray();
 
   // Check the input indexing map has the right form.
   ConvAccessExprWalker inputExprWalker;
   if (llvm::any_of(indexingMaps[0].getResults(),
                    [&inputExprWalker](AffineExpr expr) {
                      return failed(inputExprWalker.visit(expr));
                    })) {
     return MatchConvolutionResult::WrongInputIndexingMap;
LogicalResult mlir::linalg::detail::verifyStructuredOpInterface(Operation *op) {
 
   // Before checking indexing maps, we need to make sure the attributes
   // referenced by it are valid.
   if (linalgOp.hasDynamicIndexingMaps())
     if (failed(linalgOp.verifyIndexingMapRequiredAttributes()))
       return failure();
 
   // All input/output operands must be indexed.
-  if (static_cast<int64_t>(linalgOp.indexing_maps().size()) !=
+  if (static_cast<int64_t>(linalgOp.getIndexingMapsArray().size()) !=
       linalgOp.getNumInputsAndOutputs())
     return op->emitOpError("expected the number of indexing_map (")
-           << linalgOp.indexing_maps().size()
+           << linalgOp.getIndexingMapsArray().size()
            << ") to be equal to the number of input/output operands ("
            << linalgOp.getNumInputsAndOutputs() << ")";
 
   for (OpOperand *opOperand : linalgOp.getInputAndOutputOperands()) {
     AffineMap indexingMap = linalgOp.getTiedIndexingMap(opOperand);
 
     // Symbols disallowed.
     if (indexingMap.getNumSymbols() != 0)

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

 /// 2) The body contains just a yield operation with the yielded values being
 ///    the arguments corresponding to the operands.
 struct EraseIdentityGenericOp : public OpRewritePattern<GenericOp> {
   using OpRewritePattern<GenericOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(GenericOp genericOp,
                                 PatternRewriter &rewriter) const override {
     // Check all indexing maps are identity.
-    if (llvm::any_of(genericOp.getIndexingMaps(),
+    if (llvm::any_of(genericOp.getIndexingMapsArray(),
                      [](AffineMap map) { return !map.isIdentity(); }))
       return failure();
 
     // Check that the body of the linalg operation is just a linalg.yield
     // operation.
     Block &body = genericOp.region().front();
     if (!llvm::hasSingleElement(body))
       return failure();
struct InferStaticShapeOfOperands : public OpInterfaceRewritePattern<LinalgOp> {
   using OpInterfaceRewritePattern<LinalgOp>::OpInterfaceRewritePattern;
 
   LogicalResult matchAndRewrite(LinalgOp linalgOp,
                                 PatternRewriter &rewriter) const override {
     if (!linalgOp.hasTensorSemantics())
       return failure();
 
     // Maps must be projected permutations.
-    if (llvm::any_of(linalgOp.getIndexingMaps(), [](AffineMap map) {
+    if (llvm::any_of(linalgOp.getIndexingMapsArray(), [](AffineMap map) {
           return !map.isProjectedPermutation();
         }))
       return failure();
 
     // Maps affine dim expressions to the static size of that dimension.
     llvm::DenseMap<AffineExpr, int64_t> affineExprToSize;
     Location loc = linalgOp.getLoc();
 

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

LogicalResult matchAndRewrite(GenericOp genericOp,
     if (!elementType.isIntOrFloat())
       return failure();
 
     // Require all indexing maps to be permutations for now. This is common and
     // it simplifies input/output access greatly: we can do the data shuffling
     // entirely in the compiler, without needing to turn all indices into
     // Values, and then do affine apply on them, and then match back the
     // constant again.
-    if (!llvm::all_of(genericOp.getIndexingMaps(),
+    if (!llvm::all_of(genericOp.getIndexingMapsArray(),
                       [](AffineMap map) { return map.isPermutation(); }))
       return failure();
 
     for (OpOperand *operand : genericOp.getOutputOperands()) {
       if (genericOp.payloadUsesValueFromOperand(operand))
         return failure();
     }
 
auto getDimPositions = [](AffineMap map) {
       for (AffineExpr result : map.getResults()) {
         dims.push_back(result.cast<AffineDimExpr>().getPosition());
       }
       return dims;
     };
 
     SmallVector<SmallVector<unsigned>> inputDims;
     for (int i = 0; i < numInputs; ++i)
-      inputDims.push_back(getDimPositions(genericOp.getIndexingMaps()[i]));
-    auto outputDims = getDimPositions(genericOp.getIndexingMaps().back());
+      inputDims.push_back(getDimPositions(genericOp.getIndexingMapsArray()[i]));
+    auto outputDims = getDimPositions(genericOp.getIndexingMapsArray().back());
     auto outputShape = outputType.getShape();
 
     // Allocate small vectors for index delinearization. Initial values do not
     // matter here as they will be overwritten later.
     SmallVector<uint64_t> indices(loopBounds.size(), 0);
     SmallVector<uint64_t> dstIndices(loopBounds.size(), 0);
     SmallVector<SmallVector<uint64_t>> srcIndices(
         numInputs, SmallVector<uint64_t>(loopBounds.size(), 0));

 };
 
 // Folds linalg.generic ops that are actually transposes on constant values.
 struct FoldConstantTranspose : public FoldConstantBase<FoldConstantTranspose> {
   using FoldConstantBase::FoldConstantBase;
 
   bool matchIndexingMaps(GenericOp genericOp) const {
     // We should have one input and one output.
-    return genericOp.getIndexingMaps().size() == 2;
+    return genericOp.getIndexingMapsArray().size() == 2;
   }
 
   RegionComputationFn getRegionComputeFn(GenericOp genericOp) const {
     // Make sure the region only contains a yield op.
     Block &body = genericOp.region().front();
     if (!llvm::hasSingleElement(body))
       return nullptr;
     auto yieldOp = dyn_cast<linalg::YieldOp>(body.getTerminator());

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

 }
 
 GenericOp
 DecomposeLinalgOp::createPeeledGenericOp(GenericOp genericOp,
                                          PatternRewriter &rewriter) const {
   Block *body = genericOp.getBody();
   Operation *peeledScalarOperation = &(*body->begin());
   SmallVector<AffineMap> peeledGenericOpIndexingMaps =
-      genericOp.getIndexingMaps();
+      genericOp.getIndexingMapsArray();
 
   /// Compute the loop ranges for operation. This is the shape of the result of
   /// the generic op for the peeled operation.
   Location loc = genericOp.getLoc();
   SmallVector<OpFoldResult> domain = getGenericOpLoopRange(rewriter, genericOp);
   SmallVector<Value> newInitValues;
   SmallVector<Type> newResultTypes;
 

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

 }
 
 namespace {
 /// Pattern to fold unit-trip count loops in GenericOps.
 struct FoldUnitDimLoops : public OpRewritePattern<GenericOp> {
   using OpRewritePattern<GenericOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(GenericOp genericOp,
                                 PatternRewriter &rewriter) const override {
-    SmallVector<AffineMap, 4> indexingMaps = genericOp.getIndexingMaps();
+    SmallVector<AffineMap, 4> indexingMaps = genericOp.getIndexingMapsArray();
     if (indexingMaps.empty())
       return failure();
 
     // Check if any of the iteration dimensions are unit-trip count. They will
     // end up being unit-trip count if they are used to index into a unit-dim
     // tensor/memref.
     AffineMap invertedMap = inversePermutation(concatAffineMaps(indexingMaps));
     if (!invertedMap)

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

if ((consumer.getNumReductionLoops())) {
 
     auto addToCoveredDims = [&](AffineMap map) {
       for (auto result : map.getResults())
         if (auto dimExpr = result.dyn_cast<AffineDimExpr>())
           coveredDims[dimExpr.getPosition()] = true;
     };
 
     for (auto pair :
-         llvm::zip(consumer->getOperands(), consumer.getIndexingMaps())) {
+         llvm::zip(consumer->getOperands(), consumer.getIndexingMapsArray())) {
       Value operand = std::get<0>(pair);
       if (operand == consumerOpOperand->get())
         continue;
       AffineMap operandMap = std::get<1>(pair);
       addToCoveredDims(operandMap);
     }
 
     for (OpOperand *operand : producer.getInputOperands()) {
if (failed(expansionInfo.compute(
                       : collapsingReshapeOp.getReassociationMaps(),
           expandedType.getShape(), collapsedType.getShape(), rewriter)))
     return llvm::None;
 
   if (failed(isGenericOpExpandable(genericOp, expansionInfo, rewriter)))
     return llvm::None;
 
   SmallVector<AffineMap, 4> expandedOpIndexingMaps = llvm::to_vector<4>(
-      llvm::map_range(genericOp.getIndexingMaps(), [&](AffineMap m) {
+      llvm::map_range(genericOp.getIndexingMapsArray(), [&](AffineMap m) {
         return getIndexingMapInExpandedOp(rewriter, m, expansionInfo);
       }));
 
   SmallVector<Value> expandedOpOperands;
   expandedOpOperands.reserve(genericOp.getNumInputs());
   for (OpOperand *opOperand : genericOp.getInputOperands()) {
     if (opOperand == fusableOpOperand) {
       expandedOpOperands.push_back(isExpanding ? expandingReshapeOp.getSrc()

 // space are collapsable and empty vector is returned.
 static SmallVector<ReassociationIndices>
 getCollapsableIterationSpaceDims(GenericOp genericOp, OpOperand *fusableOperand,
                                  ArrayRef<ReassociationIndices> reassociation) {
   // Some basic checks for this fusion to be valid.
   if (!genericOp.hasTensorSemantics() || genericOp.getNumOutputs() != 1)
     return {};
 
-  if (!llvm::all_of(genericOp.getIndexingMaps(), [](AffineMap map) {
+  if (!llvm::all_of(genericOp.getIndexingMapsArray(), [](AffineMap map) {
         return map.isProjectedPermutation();
       })) {
     return {};
   }
 
   // Compute all the loops with the reduction iterator types.
   SmallVector<int64_t> reductionDims;
   for (const auto &iteratorType : llvm::enumerate(genericOp.iterator_types())) {
if (isReductionIterator(startIteratorType)) {
         }
         break;
       }
       if (!isContiguous)
         continue;
     }
 
     // Check that the sequence is preserved in all indexing maps.
-    if (llvm::any_of(genericOp.getIndexingMaps(), [&](AffineMap indexingMap) {
-          return !isDimSequencePreserved(indexingMap, foldedIterationSpaceDims);
+    if (llvm::any_of(genericOp.getIndexingMapsArray(),
+                     [&](AffineMap indexingMap) {
+                       return !isDimSequencePreserved(indexingMap,
+                                                      foldedIterationSpaceDims);
                      }))
       continue;
 
     processedIterationDims.insert(foldedIterationSpaceDims.begin(),
                                   foldedIterationSpaceDims.end());
     iterationSpaceReassociation.emplace_back(
         std::move(foldedIterationSpaceDims));
   }
 
static FailureOr<SmallVector<Value>> collapseGenericOpIterationDims(
   }
 
   // Get the iterator types for the operand.
   SmallVector<StringRef> iteratorTypes = getCollapsedOpIteratorTypes(
       genericOp.iterator_types().getValue(), collapsingInfo);
 
   // Get the indexing maps.
   auto indexingMaps = llvm::to_vector(
-      llvm::map_range(genericOp.getIndexingMaps(), [&](AffineMap map) {
+      llvm::map_range(genericOp.getIndexingMapsArray(), [&](AffineMap map) {
         return getCollapsedOpIndexingMap(map, collapsingInfo);
       }));
 
   Location loc = genericOp->getLoc();
 
   // Get the input operands.
   auto inputOperands = llvm::to_vector(
       llvm::map_range(genericOp.getInputOperands(), [&](OpOperand *opOperand) {

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

 
 FailureOr<GenericOp> mlir::linalg::generalizeNamedOp(RewriterBase &rewriter,
                                                      LinalgOp linalgOp) {
   if (failed(generalizeNamedOpPrecondition(linalgOp)))
     return rewriter.notifyMatchFailure(linalgOp, "preconditions not met");
 
   SmallVector<Value> inputOperands = linalgOp.getInputOperands();
   SmallVector<Value> outputOperands = linalgOp.getOutputOperands();
-  SmallVector<AffineMap> indexingMaps = linalgOp.getIndexingMaps();
+  SmallVector<AffineMap> indexingMaps = linalgOp.getIndexingMapsArray();
   SmallVector<StringRef> iterators = llvm::to_vector<4>(
       linalgOp.iterator_types().getAsValueRange<StringAttr>());
   SmallVector<RankedTensorType> resultTypes = linalgOp.getOutputTensorTypes();
   SmallVector<Type> types(resultTypes.begin(), resultTypes.end());
 
   // All named ops have a region attached that can be inlined.
   assert(linalgOp->getNumRegions() == 1 &&
          "expect named op to have one region attached");

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

 struct InputAndOutputIndices {
   SmallVector<Value> inputs;
   SmallVector<Value> outputs;
 };
 template <typename SingleInputPoolingOp>
 static InputAndOutputIndices
 getInputAndOutputIndices(OpBuilder &b, Location loc, ArrayRef<Value> allIvs,
                          SingleInputPoolingOp op) {
-  auto mapsRange = op.indexing_maps().template getAsRange<AffineMapAttr>();
+  auto mapsRange = op.getIndexingMapsArray();
   auto maps = llvm::to_vector<8>(
       llvm::map_range(mapsRange, [](AffineMapAttr a) { return a.getValue(); }));
   return InputAndOutputIndices{
       makeCanonicalAffineApplies(b, loc, maps[0], allIvs),
       makeCanonicalAffineApplies(b, loc, maps[2], allIvs)};
 }
 
 /// Emits the MLIR for the scalar part of the generic op by:

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

for (Range range : ranges) {
     steps.emplace_back(range.stride);
   }
 }
 
 namespace mlir {
 namespace linalg {
 
 bool allIndexingsAreProjectedPermutation(LinalgOp op) {
-  return llvm::all_of(op.getIndexingMaps(), [](AffineMap m) {
+  return llvm::all_of(op.getIndexingMapsArray(), [](AffineMap m) {
     return m.isProjectedPermutation(/*allowZeroInResults=*/true);
   });
 }
 
 bool hasOnlyScalarElementwiseOp(Region &r) {
   if (!llvm::hasSingleElement(r))
     return false;
   for (Operation &op : r.front()) {

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp

LogicalResult matchAndRewrite(GenericOp op,
     if (!isEmptyInit(op.getOutputOperand(0)) ||
         !isEmptyInit(prod.getOutputOperand(0)) || !isSampling(op) ||
         !isSumOfMul(prod))
       return failure();
     // Modify operand structure of producer and consumer.
     Location loc = prod.getLoc();
     SmallVector<Value> inputOps = prod.getInputOperands();
     SmallVector<Value> outputOps = op.getOutputOperands();
-    SmallVector<AffineMap> fusedIndexMaps = prod.getIndexingMaps();
+    SmallVector<AffineMap> fusedIndexMaps = prod.getIndexingMapsArray();
     inputOps.push_back(op.getInputOperand(1 - other)->get());
     fusedIndexMaps.push_back(fusedIndexMaps.back()); // mimic other
     // Fuse producer and consumer into a new generic op.
     auto fusedOp = rewriter.create<GenericOp>(
         loc, op.getResult(0).getType(), inputOps, outputOps,
         rewriter.getAffineMapArrayAttr(fusedIndexMaps), prod.iterator_types(),
         /*doc=*/nullptr, /*library_call=*/nullptr);
     Block &prodBlock = prod.region().front();

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

if (expectedResultDims.empty()) {
     auto accVectorType = accType.dyn_cast<VectorType>();
     if (!resVectorType || !accVectorType)
       return op.emitOpError("invalid accumulator/result vector shape");
 
     // Infer expected result vector type. Lhs + rhs map and lhs + rhs vector
     // types fully define the result vector type. This assumes the affine maps
     // are well-formed, which must have been verified already.
     MLIRContext *ctx = op.getContext();
-    AffineMap lhsMap = op.getIndexingMaps()[0];
-    AffineMap rhsMap = op.getIndexingMaps()[1];
+    AffineMap lhsMap = op.getIndexingMapsArray()[0];
+    AffineMap rhsMap = op.getIndexingMapsArray()[1];
     if (getUnusedDimsBitVector({lhsMap, rhsMap}).any())
       return op.emitOpError(
           "expected all dimensions to be either a LHS or a RHS dimension");
     SmallVector<AffineExpr, 4> extents(lhsMap.getNumInputs());
     for (auto pair :
          {std::make_pair(lhsType, lhsMap), std::make_pair(rhsType, rhsMap)}) {
       VectorType v = pair.first;
       auto map = pair.second;
       for (unsigned idx = 0, e = v.getRank(); idx < e; ++idx) {
         unsigned pos = map.getDimPosition(idx);
         if (!extents[pos])
           extents[pos] = getAffineConstantExpr(v.getShape()[idx], ctx);
       }
     }
     if (!llvm::all_of(extents, [](AffineExpr e) { return e; }))
       return op.emitOpError("expected all dimensions to get an extent as "
                             "either a LHS or a RHS dimension");
 
-    AffineMap resMap = op.getIndexingMaps()[2];
+    AffineMap resMap = op.getIndexingMapsArray()[2];
     auto extentsMap = AffineMap::get(/*dimCount=*/extents.size(),
                                      /*symCount=*/0, extents, ctx);
     // Compose the resMap with the extentsMap, which is a constant map.
     AffineMap expectedMap = simplifyAffineMap(resMap.compose(extentsMap));
     assert(llvm::all_of(
                expectedMap.getResults(),
                [](AffineExpr e) { return e.isa<AffineConstantExpr>(); }) &&
            "expected constant extent along all dimensions.");

 
 LogicalResult ContractionOp::verify() {
   auto lhsType = getLhsType();
   auto rhsType = getRhsType();
   auto accType = getAccType();
   auto resType = getResultType();
 
   // Verify that an indexing map was specified for each vector operand.
-  if (getIndexingMaps().size() != 3)
+  if (getIndexingMapsArray().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 = getIteratorTypes().getValue().size();
-  for (const auto &it : llvm::enumerate(getIndexingMaps())) {
+  for (const auto &it : llvm::enumerate(getIndexingMapsArray())) {
     auto index = it.index();
     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.
getDimMap(ArrayRef<AffineMap> indexingMaps, ArrayAttr iteratorTypes,
   }
   return dimMap;
 }
 
 void ContractionOp::getIterationBounds(
     SmallVectorImpl<int64_t> &iterationBounds) {
   auto lhsShape = getLhsType().getShape();
   auto resVectorType = getResultType().dyn_cast<VectorType>();
-  SmallVector<AffineMap, 4> indexingMaps(getIndexingMaps());
+  SmallVector<AffineMap, 4> indexingMaps(getIndexingMapsArray());
   SmallVector<int64_t, 2> iterationShape;
   for (const auto &it : llvm::enumerate(getIteratorTypes())) {
     // Search lhs/rhs map results for 'targetExpr'.
     auto targetExpr = getAffineDimExpr(it.index(), getContext());
     auto iteratorTypeName = it.value().cast<StringAttr>().getValue();
     if (iteratorTypeName == getReductionIteratorTypeName()) {
       // Get reduction dim size from lhs shape (same size in rhsShape).
       int64_t lhsDimIndex = getResultIndex(indexingMaps[0], targetExpr);
       assert(lhsDimIndex >= 0);
       iterationBounds.push_back(lhsShape[lhsDimIndex]);
       continue;
     }
     // Get parallel dimension size from result shape.
     int64_t resDimIndex = getResultIndex(indexingMaps[2], targetExpr);
     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 = getIndexingMaps().size();
+  unsigned numMaps = getIndexingMapsArray().size();
   iterationIndexMap.resize(numMaps);
-  for (const auto &it : llvm::enumerate(getIndexingMaps())) {
+  for (const auto &it : llvm::enumerate(getIndexingMapsArray())) {
     auto index = it.index();
     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());
+  SmallVector<AffineMap, 4> indexingMaps(getIndexingMapsArray());
   return getDimMap(indexingMaps, getIteratorTypes(),
                    getReductionIteratorTypeName(), getContext());
 }
 
 std::vector<std::pair<int64_t, int64_t>> ContractionOp::getBatchDimMap() {
-  SmallVector<AffineMap, 4> indexingMaps(getIndexingMaps());
+  SmallVector<AffineMap, 4> indexingMaps(getIndexingMapsArray());
   return getDimMap(indexingMaps, getIteratorTypes(),
                    getParallelIteratorTypeName(), getContext());
 }
 
 Optional<SmallVector<int64_t, 4>> ContractionOp::getShapeForUnroll() {
   SmallVector<int64_t, 4> shape;
   getIterationBounds(shape);
   return shape;

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

LogicalResult matchAndRewrite(vector::ContractionOp contractOp,
     if (llvm::size(contractOp.getMasks()) != 0)
       return failure();
     if (oldAccType.getShape()[0] != 1)
       return failure();
     // currently we support only dropping one dim but the pattern can be applied
     // greedily to drop more.
     int64_t dropDim = 1;
 
-    auto oldIndexingMaps = contractOp.getIndexingMaps();
+    auto oldIndexingMaps = contractOp.getIndexingMapsArray();
     SmallVector<AffineMap> newIndexingMaps;
 
     auto oldIteratorTypes = contractOp.getIteratorTypes();
     SmallVector<Attribute> newIteratorTypes;
 
     int64_t dimToDrop = oldIndexingMaps[2].getDimPosition(0);
 
     if (!isParallelIterator(oldIteratorTypes[dimToDrop]))

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

LogicalResult matchAndRewrite(vector::ContractionOp contractOp,
     if (failed(filter(contractOp)))
       return failure();
 
     if (vectorTransformOptions.vectorContractLowering !=
         vector::VectorContractLowering::ParallelArith)
       return failure();
     ArrayRef<int64_t> lhsShape = contractOp.getLhsType().getShape();
     ArrayRef<int64_t> rhsShape = contractOp.getRhsType().getShape();
-    AffineMap lhsMap = contractOp.getIndexingMaps()[0];
-    AffineMap rhsMap = contractOp.getIndexingMaps()[1];
+    AffineMap lhsMap = contractOp.getIndexingMapsArray()[0];
+    AffineMap rhsMap = contractOp.getIndexingMapsArray()[1];
     SmallVector<int64_t> lhsReductionDims =
         getReductionIndex(lhsMap, contractOp.getIteratorTypes());
     SmallVector<int64_t> rhsReductionDims =
         getReductionIndex(rhsMap, contractOp.getIteratorTypes());
     // All the reduction dimensions must be a size 1.
     for (int64_t dim : lhsReductionDims) {
       if (lhsShape[dim] != 1)
         return failure();
     }
     for (int64_t dim : rhsReductionDims) {
       if (rhsShape[dim] != 1)
         return failure();
     }
-    AffineMap accMap = contractOp.getIndexingMaps()[2];
+    AffineMap accMap = contractOp.getIndexingMapsArray()[2];
     unsigned numParallelDims = accMap.getNumResults();
     unsigned numLhsDimToBroadcast =
         numParallelDims - (lhsMap.getNumResults() - lhsReductionDims.size());
     unsigned numRhsDimToBroadcast =
         numParallelDims - (rhsMap.getNumResults() - rhsReductionDims.size());
     SmallVector<int64_t> lhsDims;
     SmallVector<int64_t> lhsTranspose;
     SmallVector<int64_t> rhsDims;

 ///  ```
 struct CombineContractTranspose
     : public OpRewritePattern<vector::ContractionOp> {
   using OpRewritePattern<vector::ContractionOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::ContractionOp contractOp,
                                 PatternRewriter &rewriter) const override {
     SmallVector<AffineMap, 4> maps =
-        llvm::to_vector<4>(contractOp.getIndexingMaps());
+        llvm::to_vector<4>(contractOp.getIndexingMapsArray());
     Value lhs = contractOp.getLhs();
     Value rhs = contractOp.getRhs();
     size_t index = 0;
     bool changed = false;
     for (Value *operand : {&lhs, &rhs}) {
       AffineMap &map = maps[index++];
       auto transposeOp = operand->getDefiningOp<vector::TransposeOp>();
       if (!transposeOp)

 ///  ```
 struct CombineContractBroadcast
     : public OpRewritePattern<vector::ContractionOp> {
   using OpRewritePattern<vector::ContractionOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::ContractionOp contractOp,
                                 PatternRewriter &rewriter) const override {
     SmallVector<AffineMap, 4> maps =
-        llvm::to_vector<4>(contractOp.getIndexingMaps());
+        llvm::to_vector<4>(contractOp.getIndexingMapsArray());
     Value lhs = contractOp.getLhs();
     Value rhs = contractOp.getRhs();
     size_t index = 0;
     bool changed = false;
     for (Value *operand : {&lhs, &rhs}) {
       AffineMap &map = maps[index++];
       auto broadcast = operand->getDefiningOp<vector::BroadcastOp>();
       if (!broadcast)
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.getLhs();
-  auto lhsMap = op.getIndexingMaps()[0];
+  auto lhsMap = op.getIndexingMapsArray()[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.getRhs();
-  auto rhsMap = op.getIndexingMaps()[1];
+  auto rhsMap = op.getIndexingMapsArray()[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.getAcc().getType())),
       mul);
 
   // ACC must be C(m, n) or C(n, m).
-  auto accMap = op.getIndexingMaps()[2];
+  auto accMap = op.getIndexingMapsArray()[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.getAcc(), mul))
ContractionOpToDotLowering::matchAndRewrite(vector::ContractionOp op,
   static constexpr std::array<int64_t, 2> perm = {1, 0};
   Location loc = op.getLoc();
   Value lhs = op.getLhs(), rhs = op.getRhs();
 
   using MapList = ArrayRef<ArrayRef<AffineExpr>>;
   auto infer = [](MapList m) { return AffineMap::inferFromExprList(m); };
   AffineExpr m, n, k;
   bindDims(rewriter.getContext(), m, n, k);
-  SmallVector<AffineMap, 4> maps = op.getIndexingMaps();
+  SmallVector<AffineMap, 4> maps = op.getIndexingMapsArray();
   //
   // In the following we wish to make the reduction dimension innermost so we
   // can load vectors and just fmul + reduce into a scalar.
   //
   if (isParallelIterator(iteratorTypes[0]) &&
       isParallelIterator(iteratorTypes[1]) &&
       isReductionIterator(iteratorTypes[2])) {
     //

 FailureOr<Value>
 ContractionOpLowering::lowerParallel(vector::ContractionOp op, int64_t lhsIndex,
                                      int64_t rhsIndex,
                                      PatternRewriter &rewriter) const {
   VectorType lhsType = op.getLhsType();
   VectorType rhsType = op.getRhsType();
   VectorType resType = op.getResultType().cast<VectorType>();
   // Find the iterator type index and result index.
-  SmallVector<AffineMap, 4> iMap = op.getIndexingMaps();
+  SmallVector<AffineMap, 4> iMap = op.getIndexingMapsArray();
   int64_t iterIndex = -1;
   int64_t dimSize = -1;
   if (lhsIndex >= 0) {
     iterIndex = iMap[0].getDimPosition(lhsIndex);
     if (rhsIndex >= 0 && iterIndex != iMap[1].getDimPosition(rhsIndex))
       return rewriter.notifyMatchFailure(op, [&](Diagnostic &diag) {
         diag << "expected lhsIndex=" << lhsIndex << " and rhsIndex=" << rhsIndex
              << " to map to the same dimension";
ContractionOpLowering::lowerReduction(vector::ContractionOp op,
   VectorType rhsType = op.getRhsType();
   Type resType = op.getResultType();
   if (resType.isa<VectorType>())
     return rewriter.notifyMatchFailure(op,
                                        "did not expect a VectorType result");
   bool isInt = resType.isa<IntegerType>();
   // Use iterator index 0.
   int64_t iterIndex = 0;
-  SmallVector<AffineMap, 4> iMap = op.getIndexingMaps();
+  SmallVector<AffineMap, 4> iMap = op.getIndexingMapsArray();
   Optional<int64_t> lookupLhs = getResultIndex(iMap[0], iterIndex);
   Optional<int64_t> lookupRhs = getResultIndex(iMap[1], iterIndex);
   if (!lookupLhs.has_value())
     return rewriter.notifyMatchFailure(op, [&](Diagnostic &diag) {
       diag << "expected iterIndex=" << iterIndex << "to map to a LHS dimension";
     });
   if (!lookupRhs.has_value())
     return rewriter.notifyMatchFailure(op, [&](Diagnostic &diag) {

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

LogicalResult matchAndRewrite(vector::ContractionOp contractOp,
     auto targetShape = getTargetShape(options, contractOp);
     if (!targetShape)
       return failure();
     auto dstVecType = contractOp.getResultType().cast<VectorType>();
     SmallVector<int64_t, 4> originalSize = *contractOp.getShapeForUnroll();
 
     Location loc = contractOp.getLoc();
     unsigned accIndex = vector::ContractionOp::getAccOperandIndex();
-    AffineMap dstAffineMap = contractOp.getIndexingMaps()[accIndex];
+    AffineMap dstAffineMap = contractOp.getIndexingMapsArray()[accIndex];
     llvm::MapVector<
         SmallVector<int64_t>, Value,
         llvm::DenseMap<SmallVector<int64_t>, unsigned, OffsetMapInfo>>
         accCache;
 
     SmallVector<int64_t> loopOrder = getUnrollOrder(
         contractOp.getIteratorTypes().size(), contractOp, options);
     DecomposeShapeIterator indexToOffsets(originalSize, *targetShape,
for (int64_t i = 0; i < sliceCount; i++) {
         SmallVector<int64_t> operandShape = applyPermutationMap(
             permutationMap, ArrayRef<int64_t>(*targetShape));
         SmallVector<int64_t, 4> operandStrides(operandOffets.size(), 1);
         slicesOperands[index] = rewriter.create<vector::ExtractStridedSliceOp>(
             loc, operand, operandOffets, operandShape, operandStrides);
       };
 
       // Extract the new lhs operand.
-      AffineMap lhsPermutationMap = contractOp.getIndexingMaps()[0];
+      AffineMap lhsPermutationMap = contractOp.getIndexingMapsArray()[0];
       SmallVector<int64_t> lhsOffets =
           applyPermutationMap(lhsPermutationMap, ArrayRef<int64_t>(offsets));
       extractOperand(0, contractOp.getLhs(), lhsPermutationMap, lhsOffets);
       // If there is a mask associated to lhs, extract it as well.
       if (slicesOperands.size() > 3)
         extractOperand(3, contractOp.getMasks()[0], lhsPermutationMap,
                        lhsOffets);
 
       // Extract the new rhs operand.
-      AffineMap rhsPermutationMap = contractOp.getIndexingMaps()[1];
+      AffineMap rhsPermutationMap = contractOp.getIndexingMapsArray()[1];
       SmallVector<int64_t> rhsOffets =
           applyPermutationMap(rhsPermutationMap, ArrayRef<int64_t>(offsets));
       extractOperand(1, contractOp.getRhs(), rhsPermutationMap, rhsOffets);
       // If there is a mask associated to rhs, extract it as well.
       if (slicesOperands.size() > 4)
         extractOperand(4, contractOp.getMasks()[1], rhsPermutationMap,
                        rhsOffets);
 
-      AffineMap accPermutationMap = contractOp.getIndexingMaps()[2];
+      AffineMap accPermutationMap = contractOp.getIndexingMapsArray()[2];
       SmallVector<int64_t> accOffets =
           applyPermutationMap(accPermutationMap, ArrayRef<int64_t>(offsets));
       // If a version of the accumulator has already been computed, use it
       // otherwise extract the first version from the original operand.
       auto accIt = accCache.find(accOffets);
       if (accIt != accCache.end())
         slicesOperands[2] = accIt->second;
       else
struct ContractExtractPattern : public OpRewritePattern<vector::ExtractMapOp> {
   LogicalResult matchAndRewrite(vector::ExtractMapOp extract,
                                 PatternRewriter &rewriter) const override {
     Operation *definedOp = extract.getVector().getDefiningOp();
     auto contract = dyn_cast_or_null<vector::ContractionOp>(definedOp);
     if (!contract)
       return failure();
     Location loc = contract.getLoc();
     unsigned accIndex = vector::ContractionOp::getAccOperandIndex();
-    AffineMap affineMap = contract.getIndexingMaps()[accIndex];
+    AffineMap affineMap = contract.getIndexingMapsArray()[accIndex];
     // Create a map of the dimensions distributed based on the acc affine map.
     // Only parallel dimensions are being distributed, reduction dimensions are
     // untouched.
     DenseMap<int64_t, int64_t> map;
     for (unsigned i : llvm::seq(unsigned(0), affineMap.getNumResults()))
       map[affineMap.getDimPosition(i)] = extract.getResultType().getDimSize(i);
     SmallVector<Value, 4> extractOperands;
-    for (const auto &it : llvm::enumerate(contract.getIndexingMaps())) {
+    for (const auto &it : llvm::enumerate(contract.getIndexingMapsArray())) {
       // For each operands calculate the new vector type after distribution.
       Value operand = contract->getOperand(it.index());
       auto vecType = operand.getType().cast<VectorType>();
       SmallVector<int64_t> operandShape(vecType.getShape().begin(),
                                         vecType.getShape().end());
       for (unsigned i : llvm::seq(unsigned(0), it.value().getNumResults())) {
         unsigned dim = it.value().getDimPosition(i);
         auto distributedDim = map.find(dim);

mlir/test/lib/Dialect/Test/TestOps.td

let extraClassDeclaration = [{
     getRegionBuilder() {
       return &regionBuilder;
     }
 
     mlir::ArrayAttr iterator_types() {
       return getOperation()->getAttrOfType<mlir::ArrayAttr>("iterator_types");
     }
 
-    mlir::ArrayAttr indexing_maps() {
+    mlir::ArrayAttr getIndexingMaps() {
       return getOperation()->getAttrOfType<mlir::ArrayAttr>("indexing_maps");
     }
 
     std::string getLibraryCallName() {
       return "";
     }
 
     // To conform with interface requirement on operand naming.
let extraClassDeclaration = [{
     getRegionBuilder() {
       return &regionBuilder;
     }
 
     mlir::ArrayAttr iterator_types() {
       return getOperation()->getAttrOfType<mlir::ArrayAttr>("iterator_types");
     }
 
-    mlir::ArrayAttr indexing_maps() {
+    mlir::ArrayAttr getIndexingMaps() {
       return getOperation()->getAttrOfType<mlir::ArrayAttr>("indexing_maps");
     }
 
     std::string getLibraryCallName() {
       return "";
     }
 
     // To conform with interface requirement on operand naming.

mlir/test/mlir-linalg-ods-gen/test-linalg-ods-yaml-gen.yaml

 #  ODS-NEXT:  LogicalResult verifyIndexingMapRequiredAttributes();
 
 #       IMPL:  getSymbolBindings(Test2Op self)
 #       IMPL:  cst2 = self.strides().getValues<int64_t>()[0];
 #  IMPL-NEXT:  getAffineConstantExpr(cst2, context)
 #       IMPL:  cst3 = self.strides().getValues<int64_t>()[1];
 #  IMPL-NEXT:  getAffineConstantExpr(cst3, context)
 
-#       IMPL:  Test2Op::indexing_maps()
+#       IMPL:  Test2Op::getIndexingMaps()
 #       IMPL:  = getSymbolBindings(*this);
 #       IMPL:  "affine_map<(d0, d1)[s0, s1, s2, s3] -> (d1 * s2, d0 * s3)>"
 #       IMPL:  "affine_map<(d0, d1)[s0, s1, s2, s3] -> (d0, d1)>"
 
 #       IMPL:  Test2Op::getNumRegionArgs() { return 2; }
 
 #       IMPL:  Test2Op::hasDynamicIndexingMaps() { return true; }
 #       IMPL:  Test2Op::verifyIndexingMapRequiredAttributes()
value: !ScalarExpression
         type_var: U
         operands:
         - !ScalarExpression
           scalar_arg: value
 
 #       IMPL:  Test3Op::iterator_types() {
 #  IMPL-NEXT:    int64_t rank = getRank(getOutputOperand(0));
 
-#       IMPL:  Test3Op::indexing_maps() {
+#       IMPL:  Test3Op::getIndexingMaps() {
 #  IMPL-NEXT:    MLIRContext *context = getContext();
 #  IMPL-NEXT:    AffineMap scalarMap = AffineMap::get(getNumParallelLoops(), 0, context);
 #  IMPL-NEXT:    AffineMap tensorMap = AffineMap::getMultiDimIdentityMap(
 
 # @linalg_structured_op
 # def test4(O=TensorDef(T, S.M, S.N, output=True),
 #           unary_fun=UnaryFnAttrDef(default=UnaryFn.exp),
 #           binary_fun=BinaryFnAttrDef(default=BinaryFn.add)):

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

/*extraInterfaces=*/[{2}])> {
     ];
     let hasCustomAssemblyFormat = 1;
     let hasFolder = 1;
     {6}
 
     let extraClassDeclaration = structuredOpsBaseDecls # [{{
       // Auto-generated.
       ArrayAttr iterator_types();
-      ArrayAttr indexing_maps();
+      ArrayAttr getIndexingMaps();
       static void regionBuilder(ImplicitLocOpBuilder &b,
                                 Block &block, ArrayRef<NamedAttribute> attrs);
       static std::function<void(ImplicitLocOpBuilder &,
                                 Block &, ArrayRef<NamedAttribute>)>
       getRegionBuilder() {{
         return regionBuilder;
       }
 

 }
 )FMT";
 
 // The indexing_maps() method for structured ops. Parameters:
 // {0}: Class name
 // {1}: Comma-separated list of dimension variable names.
 // {2}: Statements
 static const char structuredOpIndexingMapsFormat[] = R"FMT(
-ArrayAttr {0}::indexing_maps() {{
+ArrayAttr {0}::getIndexingMaps() {{
   static const char memoizeAttr[] = "linalg.memoized_indexing_maps";
   ArrayAttr cached = getOperation()->getAttrOfType<ArrayAttr>(memoizeAttr);
   if (cached)
     return cached;
 
   MLIRContext *context = getContext();
   auto symbolBindings = getSymbolBindings(*this);
   SmallVector<AffineMap> maps;
   {2}
   cached = Builder(context).getAffineMapArrayAttr(maps);
   getOperation()->setAttr(memoizeAttr, cached);
   return cached;
 }
 )FMT";
 
 // The indexing_maps() method for rank polymorphic structured ops. Parameters:
 // {0}: Class name
 static const char rankPolyStructuredOpIndexingMapsFormat[] = R"FMT(
-ArrayAttr {0}::indexing_maps() {{
+ArrayAttr {0}::getIndexingMaps() {{
   MLIRContext *context = getContext();
   AffineMap scalarMap = AffineMap::get(getNumParallelLoops(), 0, context);
   AffineMap tensorMap = AffineMap::getMultiDimIdentityMap(
     getNumParallelLoops(), context);
   SmallVector<AffineMap> indexingMaps;
   for (OpOperand *opOperand : getInputAndOutputOperands())
     indexingMaps.push_back(getRank(opOperand) == 0 ? scalarMap : tensorMap);
   return Builder(getContext()).getAffineMapArrayAttr(indexingMaps);
llvm::interleaveComma(opConfig.structuredOp->iteratorTypes, ss,
                           });
     ss.flush();
     os << llvm::formatv(structuredOpIteratorTypesFormat, className,
                         iteratorsStr);
   } else {
     os << llvm::formatv(rankPolyStructuredOpIteratorTypesFormat, className);
   }
 
-  // Generating the indexing_maps() method.
+  // Generating the getIndexingMaps() method.
   if (auto &staticMaps =
           opConfig.structuredOp->indexingMaps.staticIndexingMaps) {
     if (staticMaps->empty())
       return emitError(genContext.getLoc()) << "op has no indexing maps";
     if (!isRankPolymorphic) {
       AffineMap firstMap = staticMaps->front().affineMap();
 
       // Symbol bindings.