[mlir][Interfaces] Fix DestinationStyleOpInterface for vector ops

[springerm]

Summary

This revision fixes hasTensorSemantics and hasBufferSemantics for vector transfer ops, which may have a vector operand. VectorType implements ShapedType and such operands do not affect whether an op has tensor or buffer semantics. Also implement DestinationStyleOpInterface on TransferReadOp so that hasTensorSemantics/hasBufferSemantics can be called. (The op has no inits, but this makes it symmetric to TransferWriteOp.)

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

 // TODO: Tighten semantics so that masks and inbounds can't be used
 // simultaneously within the same transfer op.
 def Vector_TransferReadOp :
   Vector_Op<"transfer_read", [
       DeclareOpInterfaceMethods<VectorTransferOpInterface>,
       DeclareOpInterfaceMethods<VectorUnrollOpInterface, ["getShapeForUnroll"]>,
       DeclareOpInterfaceMethods<MaskableOpInterface>,
       DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
-      AttrSizedOperandSegments
+      AttrSizedOperandSegments,
+      DestinationStyleOpInterface
     ]>,
     Arguments<(ins AnyShaped:$source,
                    Variadic<Index>:$indices,
                    AffineMapAttr:$permutation_map,
                    AnyType:$padding,
                    Optional<VectorOf<[I1]>>:$mask,
                    OptionalAttr<BoolArrayAttr>:$in_bounds)>,
     Results<(outs AnyVectorOfAnyRank:$vector)> {
OpBuilder<(ins "VectorType":$vectorType,
                    "Value":$source,
                    "ValueRange":$indices,
                    CArg<"std::optional<ArrayRef<bool>>", "::std::nullopt">:$inBounds)>,
   ];
 
   let extraClassDeclaration = [{
     // MaskableOpInterface methods.
     bool supportsPassthru() { return true; }
+
+    std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
+      return {0, 0};  // empty range (no init operands)
+    }
   }];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 

mlir/include/mlir/Interfaces/DestinationStyleOpInterface.td

let description = [{
 
     Init operands must be ranked tensors or ranked memrefs. Input operands can
     have any type. All non-init operands are DPS inputs.
 
     It is assumed that the init operands of the op are the operands at
     position [start, end). The positions are defined by getDpsInitsPositionRange
     method.
 
-    If the op has "tensor semantics", then the input operands are either scalars
-    or ranked tensors. The init operands are ranked tensors and every tensor
-    init is tied to a corresponding tensor OpResult in a 1-to-1 fashion.
-    The i-th init tensor is tied to the i-th OpResult. The op may not have any
-    additional OpResults. Init operands and their tied OpResults have the same
-    type.
+    If the op has "tensor semantics", then the input operands are either ranked
+    tensors or other non-tensor/memref types ("scalars"). The init operands are
+    ranked tensors and every tensor init is tied to a corresponding tensor
+    OpResult in a 1-to-1 fashion. The i-th init tensor is tied to the i-th
+    OpResult. The op may not have any additional OpResults. Init operands and
+    their tied OpResults have the same type.
 
     If the op has "buffer semantics", then the input operands are either ranked
-    memrefs or other non-tensor types, e.g. scalar types. Furthermore, the
+    memrefs or other non-tensor/memref types ("scalar" types). Furthermore, the
     init operands are ranked memrefs and the op has no results.
 
     Destination-passing style abstraction makes certain transformations easier.
     For example, tiling implementation can extract/insert slices from/into the
     destination of an op and use the resulting shaped value as an iter_arg in
     the surrounding loop structure. As another example, bufferization does not
     have to allocate new buffers for destinations (in case of in-place
     bufferization) and can directly reuse the existing destination buffer.
InterfaceMethod<
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         auto [start, end] = $_op.getDpsInitsPositionRange();
         auto operandNumber = opOperand->getOperandNumber();
         return operandNumber >= start && operandNumber < end;
       }]
     >,
     InterfaceMethod<
-      /*desc=*/"Return true if the `opOperand` is a scalar value.",
+      /*desc=*/[{
+        Return true if the `opOperand` is a scalar value. A scalar is defined
+        as neither a memref nor a tensor value.
+      }],
       /*retTy=*/"bool",
       /*methodName=*/"isScalar",
       /*args=*/(ins "::mlir::OpOperand *":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opOperand->getOwner() == $_op.getOperation());
-        return !::llvm::isa<ShapedType>(opOperand->get().getType());
+        return !::llvm::isa<MemRefType, TensorType>(opOperand->get().getType());
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the OpResult that is tied to the given OpOperand.",
       /*retTy=*/"::mlir::OpResult",
       /*methodName=*/"getTiedOpResult",
       /*args=*/(ins "::mlir::OpOperand *":$opOperand),
       /*methodBody=*/"",
InterfaceMethod<
         assert(opResult.getDefiningOp() == $_op.getOperation());
         return $_op.getDpsInitOperand(opResult.getResultNumber());
       }]
     >,
     //===------------------------------------------------------------------===//
     // Other interface methods.
     //===------------------------------------------------------------------===//
     InterfaceMethod<
-      /*desc=*/"Return whether the op has only ranked MemRef input/inits.",
+      /*desc=*/[{
+        Return whether the op has buffer semantics. That is the case if the op
+        has no tensor operands and at least one memref operand.
+      }],
       /*retTy=*/"bool",
       /*methodName=*/"hasBufferSemantics",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return $_op->getNumResults() == 0 &&
-          ::llvm::all_of($_op->getOpOperands(),
-            [&](::mlir::OpOperand &opOperand) {
-              return isScalar(&opOperand) ||
-                     ::llvm::isa<::mlir::MemRefType>(opOperand.get().getType());
-            });
+        // No tensors.
+        auto isTensor = [](Value v){
+          return ::llvm::isa<::mlir::RankedTensorType>(v.getType());
+        };
+        if (::llvm::any_of($_op->getOperands(), isTensor))
+          return false;
+        // At least one memref.
+        auto isMemref = [](Value v){
+          return ::llvm::isa<::mlir::MemRefType>(v.getType());
+        };
+        return llvm::any_of($_op->getOperands(), isMemref);
       }]
     >,
     InterfaceMethod<
-      /*desc=*/"Return whether the op has only ranked tensor inputs/inits.",
+      /*desc=*/[{
+        Return whether the op has tensor semantics. That is the case if the op
+        has no memref operands and at least one tensor operand.
+      }],
       /*retTy=*/"bool",
       /*methodName=*/"hasTensorSemantics",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return ::llvm::all_of($_op->getOpOperands(),
-          [&](::mlir::OpOperand &opOperand) {
-            return isScalar(&opOperand) ||
-                   ::llvm::isa<::mlir::RankedTensorType>(opOperand.get().getType());
-          });
+        // No memrefs.
+        auto isMemref = [](Value v){
+          return ::llvm::isa<::mlir::MemRefType>(v.getType());
+        };
+        if (::llvm::any_of($_op->getOperands(), isMemref))
+          return false;
+        // At least one tensor.
+        auto isTensor = [](Value v){
+          return ::llvm::isa<::mlir::RankedTensorType>(v.getType());
+        };
+        return llvm::any_of($_op->getOperands(), isTensor);
       }]
     >
   ];
 
   let verify = [{ return detail::verifyDestinationStyleOpInterface($_op); }];
   let verifyWithRegions = 1;
 }
 
 
 #endif // MLIR_DESTINATIONSTYLEOPINTERFACE