[mlir][vector][NFC] Minor VectorTransferOpInterface cleanup

[springerm]

Summary

• Rename functions with underscore to camel case.
• Return C++ bools of "in_bounds" values instead of an ArrayAttr.

Depends On: D155172

mlir/include/mlir/Interfaces/VectorInterfaces.td

InterfaceMethod<
       /*methodName=*/"indices",
       /*args=*/(ins),
       /*methodBody=*/"return $_op.getIndices();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/"Return the permutation map.",
       /*retTy=*/"::mlir::AffineMap",
-      /*methodName=*/"permutation_map",
+      /*methodName=*/"getPermutationMap",
       /*args=*/(ins),
       /*methodBody=*/"return $_op.getPermutationMap();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/[{ Returns true if the specified dimension is a broadcast. }],
       /*retTy=*/"bool",
       /*methodName=*/"isBroadcastDim",
InterfaceMethod<
         for (unsigned i = 0, rank = getTransferRank(); i < rank; ++i) {
           if ($_op.isBroadcastDim(i))
             return true;
         }
         return false;
       }]
     >,
     InterfaceMethod<
-      /*desc=*/"Return the `in_bounds` boolean ArrayAttr.",
-      /*retTy=*/"::std::optional<::mlir::ArrayAttr>",
-      /*methodName=*/"in_bounds",
+      /*desc=*/"Return a vector of all in_bounds values as booleans.",
+      /*retTy=*/"::llvm::SmallVector<bool>",
+      /*methodName=*/"getInBoundsValues",
       /*args=*/(ins),
-      /*methodBody=*/"return $_op.getInBounds();"
-      /*defaultImplementation=*/
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        ::llvm::SmallVector<bool> inBounds;
+        for (int64_t i = 0, e = $_op.getTransferRank(); i < e; ++i)
+          inBounds.push_back($_op.isDimInBounds(i));
+        return inBounds;
+      }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the ShapedType.",
       /*retTy=*/"::mlir::ShapedType",
       /*methodName=*/"getShapedType",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/

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

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())
+  if (op.getPermutationMap().isMinorIdentity())
     elidedAttrs.push_back(op.getPermutationMapAttrStrName());
-  bool elideInBounds = true;
-  if (auto inBounds = op.in_bounds()) {
-    for (auto attr : *inBounds) {
-      if (llvm::cast<BoolAttr>(attr).getValue()) {
-        elideInBounds = false;
-        break;
-      }
-    }
-  }
-  if (elideInBounds)
+  // Elide in_bounds attribute if all dims are out-of-bounds.
+  if (llvm::none_of(op.getInBoundsValues(), [](bool b) { return b; }))
     elidedAttrs.push_back(op.getInBoundsAttrStrName());
   p.printOptionalAttrDict(op->getAttrs(), elidedAttrs);
 }
 
 void TransferReadOp::print(OpAsmPrinter &p) {
   p << " " << getSource() << "[" << getIndices() << "], " << getPadding();
   if (getMask())
     p << ", " << getMask();

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

 
 using namespace mlir;
 using namespace mlir::vector;
 
 /// Build the condition to ensure that a particular VectorTransferOpInterface
 /// is in-bounds.
 static Value createInBoundsCond(RewriterBase &b,
                                 VectorTransferOpInterface xferOp) {
-  assert(xferOp.permutation_map().isMinorIdentity() &&
+  assert(xferOp.getPermutationMap().isMinorIdentity() &&
          "Expected minor identity map");
   Value inBoundsCond;
   xferOp.zipResultAndIndexing([&](int64_t resultIdx, int64_t indicesIdx) {
     // Zip over the resulting vector shape and memref indices.
     // If the dimension is known to be in-bounds, it does not participate in
     // the construction of `inBoundsCond`.
     if (xferOp.isDimInBounds(resultIdx))
       return;

 ///      memref.cast %alloc: memref<B...> to compatibleMemRefType
 ///      scf.yield %4 : compatibleMemRefType, index, index
 //     }
 ///    %0 = vector.transfer_read %1#0[%1#1, %1#2] {in_bounds = [true ... true]}
 /// ```
 /// where `alloc` is a top of the function alloca'ed buffer of one vector.
 ///
 /// Preconditions:
-///  1. `xferOp.permutation_map()` must be a minor identity map
+///  1. `xferOp.getPermutationMap()` must be a minor identity map
 ///  2. the rank of the `xferOp.memref()` and the rank of the `xferOp.vector()`
 ///  must be equal. This will be relaxed in the future but requires
 ///  rank-reducing subviews.
 static LogicalResult
 splitFullAndPartialTransferPrecondition(VectorTransferOpInterface xferOp) {
   // TODO: support 0-d corner case.
   if (xferOp.getTransferRank() == 0)
     return failure();
 
   // TODO: expand support to these 2 cases.
-  if (!xferOp.permutation_map().isMinorIdentity())
+  if (!xferOp.getPermutationMap().isMinorIdentity())
     return failure();
   // Must have some out-of-bounds dimension to be a candidate for splitting.
   if (!xferOp.hasOutOfBoundsDim())
     return failure();
   // Don't split transfer operations directly under IfOp, this avoids applying
   // the pattern recursively.
   // TODO: improve the filtering condition to make it more applicable.
   if (isa<scf::IfOp>(xferOp->getParentOp()))

 ///                                                                    true]}
 ///    scf.if (%notInBounds) {
 ///      // slowpath: not in-bounds vector.transfer or linalg.copy.
 ///    }
 /// ```
 /// where `alloc` is a top of the function alloca'ed buffer of one vector.
 ///
 /// Preconditions:
-///  1. `xferOp.permutation_map()` must be a minor identity map
+///  1. `xferOp.getPermutationMap()` must be a minor identity map
 ///  2. the rank of the `xferOp.source()` and the rank of the `xferOp.vector()`
 ///  must be equal. This will be relaxed in the future but requires
 ///  rank-reducing subviews.
 LogicalResult mlir::vector::splitFullAndPartialTransfer(
     RewriterBase &b, VectorTransferOpInterface xferOp,
     VectorTransformsOptions options, scf::IfOp *ifOp) {
   if (options.vectorTransferSplit == VectorTransferSplit::None)
     return failure();