[mlir][bufferization][NFC] Rename getAliasingOpOperand/getAliasingOpResult

[springerm]

Summary

• getAliasingOpOperand => getAliasingOpOperands
• getAliasingOpResult => getAliasingOpResults

Also a few minor code cleanups and better documentation.

[springerm]

rebase

[springerm]

Note: This change was extracted from D142129 to make D142129 smaller.

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h

 namespace mlir {
 class OpBuilder;
 
 namespace bufferization {
 
 class AnalysisState;
 class BufferizableOpInterface;
 
+/// Specify fine-grain relationship between buffers to enable more analysis.
+enum class BufferRelation {
+  Unknown,
+  // TODO: ResultContainsOperand,
+  // TODO: OperandContainsResult,
+  Equivalent
+};
+
+/// A list of possible aliasing OpOperands. This list models the runtime
+/// aliasing relationship for an OpResult.
+using AliasingOpOperandList = SmallVector<OpOperand *>;
+
+/// A list of possible aliasing OpResults. This list models the runtime
+/// aliasing relationship for an OpOperand.
+using AliasingOpResultList = SmallVector<OpResult>;
+
 class OpFilter {
 public:
   /// An op filter entry. Filters can be used to specify which ops should be
   /// processed by the bufferization.
   struct Entry {
     /// If the filter function evaluates to `true`, the filter matches.
     using FilterFn = std::function<bool(Operation *)>;
 
struct BufferizationOptions {
   /// Buffer alignment for new memory allocations.
   unsigned int bufferAlignment = 64;
 
   /// Initializer functions for analysis state. These can be used to
   /// initialize dialect-specific analysis state.
   SmallVector<AnalysisStateInitFn> stateInitializers;
 };
 
-/// Specify fine-grain relationship between buffers to enable more analysis.
-enum class BufferRelation {
-  Unknown,
-  // TODO: ResultContainsOperand,
-  // TODO: OperandContainsResult,
-  Equivalent
-};
-
 /// Return `true` if the given value is a BlockArgument of a func::FuncOp.
 bool isFunctionArgument(Value value);
 
 /// AnalysisState provides a variety of helper functions for dealing with
 /// tensor values.
 class AnalysisState {
 public:
-  /// Determine which OpOperand* will alias with `opResult` if the op is
+  /// Determine which OpOperand* will alias with `result` if the op is
   /// bufferized in place. Return all tensor OpOperand* if the op is not
   /// bufferizable.
-  SmallVector<OpOperand *> getAliasingOpOperand(OpResult opResult) const;
+  AliasingOpOperandList getAliasingOpOperands(OpResult result) const;
 
   /// Determine which OpResult will alias with `opOperand` if the op is
   /// bufferized in place. Return all tensor OpResults if the op is not
   /// bufferizable.
-  SmallVector<OpResult> getAliasingOpResult(OpOperand &opOperand) const;
+  AliasingOpResultList getAliasingOpResults(OpOperand &opOperand) const;
 
   /// Return true if `opOperand` bufferizes to a memory read. Return `true` if
   /// the op is not bufferizable.
   bool bufferizesToMemoryRead(OpOperand &opOperand) const;
 
   /// Return true if `opOperand` bufferizes to a memory write. Return true` if
   /// the op is not bufferizable.
   bool bufferizesToMemoryWrite(OpOperand &opOperand) const;
Region *getEnclosingRepetitiveRegion(Value value,
                                      const BufferizationOptions &options);
 
 /// Return the closest enclosing repetitive region around the given block.
 Region *getEnclosingRepetitiveRegion(Block *block,
                                      const BufferizationOptions &options);
 
 namespace detail {
 /// This is the default implementation of
+/// BufferizableOpInterface::getAliasingOpOperands. Should not be called from
+/// other places.
+AliasingOpOperandList defaultGetAliasingOpOperands(OpResult opResult,
+                                                   const AnalysisState &state);
+
+/// This is the default implementation of
 /// BufferizableOpInterface::getBufferType. Should not be called from other
 /// places.
 FailureOr<BaseMemRefType>
 defaultGetBufferType(Value value, const BufferizationOptions &options,
                      const DenseMap<Value, BaseMemRefType> &fixedTypes);
 
 /// This is the default implementation of
 /// BufferizableOpInterface::resultBufferizesToMemoryWrite. Should not be called
 /// from other places.
 bool defaultResultBufferizesToMemoryWrite(OpResult opResult,
                                           const AnalysisState &state);
 
 /// This is the default implementation of
 /// BufferizableOpInterface::isRepetitiveRegion. Should not be called from other
 /// places.
 bool defaultIsRepetitiveRegion(BufferizableOpInterface bufferizableOp,
                                unsigned index);
 
-/// This is the default implementation of getAliasingOpOperand in case the
+/// This is the default implementation of getAliasingOpOperands in case the
 /// defining op does not implement the BufferizableOpInterface.
-SmallVector<OpOperand *> unknownGetAliasingOpOperand(OpResult opResult);
+AliasingOpOperandList unknownGetAliasingOpOperands(OpResult opResult);
 
-/// This is the default implementation of getAliasingOpResult in case the
-/// defining op does not implement the BufferizableOpInterface.
-SmallVector<OpResult> unknownGetAliasingOpResult(OpOperand &opOperand);
+/// This is the default implementation of getAliasingOpResults in case the
+/// owner op does not implement the BufferizableOpInterface.
+AliasingOpResultList unknownGetAliasingOpResults(OpOperand &opOperand);
 } // namespace detail
 
 } // namespace bufferization
 } // namespace mlir
 
 MLIR_DECLARE_EXPLICIT_TYPE_ID(mlir::bufferization::AnalysisState)
 
 //===----------------------------------------------------------------------===//
 // Bufferization Interfaces
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h.inc"
 
 #endif // MLIR_DIALECT_BUFFERIZATION_IR_BUFFERIZABLEOPINTERFACE_H_

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.td

let methods = [
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           return opOperand.get().getType().isa<UnrankedTensorType>();
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
-          Return the OpResult that aliases with a given OpOperand when
+          Return the OpResults that may alias with a given OpOperand when
           bufferized in-place. This method will never be called on OpOperands
           that do not have a tensor type.
 
-          Note: This method can return multiple OpResults, indicating that a
-          given OpOperand may at runtime alias with any (or multiple) of the
-          returned OpResults.
+          This method can return multiple OpResults, indicating that a given
+          OpOperand may at runtime alias with any (or multiple) of the returned
+          OpResults.
+
+          False positives are allowed in the list of OpResults, but they can
+          adversely affect the accuracy of the anlysis. On the contrary,
+          omitting potential aliases is incorrect.
+
+          One possible (conservative) implementation of this interface method,
+          that is always safe, is to return all tensor OpResults.
+
+          Examples:
+
+          ```
+          // aliasingOpResults(%t) = {%r}
+          %r = tensor.insert_slice %f into %t : tensor<10xf32>
+
+          // aliasingOpResults(%t) = {%r}
+          %r = tensor.extract_slice %t[0]][5][1]
+              : tensor<10xf32> to tensor<5xf32>
+
+          // aliasingOpResults(%t1) = {%r}
+          // aliasingOpResults(%t2) = {%r}
+          %r = arith.select %c, %t1, %t2 : tensor<10xf32>
+
+          // A hypothetical op that bufferizes to rolling a dice and based on
+          // the result to either return buffer(%t) or a newly allocated copy
+          // thereof.
+          // aliasingOpResults(%t) = {%r}
+          %r = "dummy.alias_or_copy(%t) : (tensor<10xf32>) -> (tensor<10xf32>)"
+          ```
         }],
-        /*retType=*/"::mlir::SmallVector<::mlir::OpResult>",
-        /*methodName=*/"getAliasingOpResult",
+        /*retType=*/"::mlir::bufferization::AliasingOpResultList",
+        /*methodName=*/"getAliasingOpResults",
         /*args=*/(ins "::mlir::OpOperand &":$opOperand,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           // Does not have to be implemented for ops without tensor OpOperands.
-          llvm_unreachable("getAliasingOpResult not implemented");
+          assert(opOperand.get().getType().isa<TensorType>() &&
+                 "expected OpOperand with tensor type");
+          llvm_unreachable("getAliasingOpResults not implemented");
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return the OpOperands that alias with a given OpResult when
           bufferized in-place. This method will never be called on OpResults
           that do not have a tensor type.
 
-          By default, this method is the inverse of `getAliasingOpResult`. Ops
+          By default, this method is the inverse of `getAliasingOpResults`. Ops
           with a region that yield values may want to override this method to
           return the OpOperands that are yielded by the terminator.
 
-          Note: This method can return multiple OpOperands, indicating that the
-          given OpResult may at runtime alias with any (or multiple) of the
-          returned OpOperands. This can be useful for branches and for ops such
-          as `arith.select`.
+          This method can return multiple OpOperands, indicating that a given
+          OpResult may at runtime alias with any (or multiple) of the returned
+          OpOperands.
+
+          False positives are allowed in the list of OpOperands, but they can
+          adversely affect the accuracy of the anlysis. On the contrary,
+          omitting potential aliases is incorrect.
+
+          One possible (conservative) implementation of this interface method,
+          that is always safe, is to return all tensor OpOperands.
+
+          Note: If the returned list of OpOperands is empty, this op definitely
+          bufferizes to a new allocation. In that case `bufferizesToAllocation`
+          must return `true`.
+
+          Examples:
+
+          ```
+          // aliasingOpOperands(%r) = {%t}
+          %r = tensor.insert_slice %f into %t : tensor<10xf32>
+
+          // aliasingOpOperands(%r) = {%t}
+          %r = tensor.extract_slice %t[0]][5][1]
+              : tensor<10xf32> to tensor<5xf32>
+
+          // aliasingOpOperands(%r) = {%t1, %t2}
+          %r = arith.select %c, %t1, %t2 : tensor<10xf32>
+
+          // aliasingOpOperands(%r) = {}
+          %r = te
         }],
-        /*retType=*/"::mlir::SmallVector<::mlir::OpOperand *>",
-        /*methodName=*/"getAliasingOpOperand",
+        /*retType=*/"::mlir::bufferization::AliasingOpOperandList",
+        /*methodName=*/"getAliasingOpOperands",
         /*args=*/(ins "::mlir::OpResult":$opResult,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           assert(opResult.getType().isa<TensorType>() &&
                  "expected OpResult with tensor type");
-          SmallVector<OpOperand *> result;
-          auto bufferizableOp =
-              cast<BufferizableOpInterface>($_op.getOperation());
-          for (OpOperand &opOperand : $_op.getOperation()->getOpOperands()) {
-            if (!opOperand.get().getType().isa<TensorType>())
-              continue;
-            SmallVector<OpResult> aliasingOpResults =
-                bufferizableOp.getAliasingOpResult(opOperand, state);
-            if (llvm::is_contained(aliasingOpResults, opResult))
-              result.push_back(&opOperand);
-          }
-          return result;
+          return ::mlir::bufferization::detail::defaultGetAliasingOpOperands(
+              opResult, state);
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return the buffer relation between the given OpResult and its aliasing
           OpOperands when bufferized in-place. Most OpOperands have an
           "equivalence" relation. This method will never be called on OpResults
           that do not have a tensor type. It will also never be called on
let methods = [
           Bufferize this op, i.e., rewrite it into a memref-based equivalent.
           Buffers of tensor SSA values can be retrieved via `getBuffer`.
           Uses of tensor results of the existing tensor op can be replaced with
           `replaceOpWithBufferizedValues` or `replaceOpWithNewBufferizedOp`.
           These two functions automatically handle the tensor-to-memref type
           conversion.
 
           The implementation of this method must be consistent with the
-          remaining methods, in particular `getAliasingOpOperand`. I.e., a
+          remaining methods, in particular `getAliasingOpOperands`. I.e., a
           tensor result `r` may only be replaced with:
-          a) A buffer that aliases one of buffers in getAliasingOpOperand(r).
-          b) Or: A newly allocated buffer.
+
+          a) One of the buffers in getAliasingOpOperands(r).
+          b) Or: A newly allocated buffer (only if `bufferizesToAllocation`).
 
           This method will never be called on ops that do not have at least one
           tensor operand/result.
 
           The return value of this method indicates whether there was an error
           while bufferizing this op (such as failing to create a new buffer
           allocation op). The bufferization driver immediately stops bufferizing
           the input IR and returns `failure` in that case. If this op is
let extraClassDeclaration = [{
     ///
     /// Examples of such ops are `tensor.extract_slice` and `tensor.cast`.
     bool bufferizesToAliasOnly(OpOperand &opOperand,
                                const AnalysisState &state) {
       auto bufferizableOp =
           cast<BufferizableOpInterface>(getOperation());
       return !bufferizableOp.bufferizesToMemoryRead(opOperand, state)
           && !bufferizableOp.bufferizesToMemoryWrite(opOperand, state)
-          && !bufferizableOp.getAliasingOpResult(opOperand, state).empty();
+          && !bufferizableOp.getAliasingOpResults(opOperand, state).empty();
     }
   }];
 }
 
 #endif  // BUFFERIZABLE_OP_INTERFACE

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationOps.td

let extraClassDeclaration = [{
     bool bufferizesToAllocation(OpResult opResult) { return true; }
 
     bool bufferizesToMemoryRead(OpOperand &opOperand,
                                 const AnalysisState &state);
 
     bool bufferizesToMemoryWrite(OpOperand &opOperand,
                                  const AnalysisState &state);
 
-    SmallVector<OpResult> getAliasingOpResult(
+    AliasingOpResultList getAliasingOpResults(
         OpOperand &opOperand, const AnalysisState &state);
 
     FailureOr<BaseMemRefType> getBufferType(
         Value value, const BufferizationOptions &options,
         const DenseMap<Value, BaseMemRefType> &fixedTypes);
 
     RankedTensorType getType() {
       return getResult().getType().cast<RankedTensorType>();
bool bufferizesToMemoryRead(OpOperand &opOperand,
       return false;
     }
 
     bool bufferizesToMemoryWrite(OpOperand &opOperand,
                                  const AnalysisState &state) const {
       return false;
     }
 
-    SmallVector<OpResult> getAliasingOpResult(
+    AliasingOpResultList getAliasingOpResults(
         OpOperand &opOperand, const AnalysisState &state) const {
       return {};
     }
 
     LogicalResult bufferize(RewriterBase &rewriter,
                             const BufferizationOptions &options);
   }];
 }
let extraClassDeclaration = [{
     }
 
     bool mustBufferizeInPlace(OpOperand &opOperand,
                               const AnalysisState &state) const {
       // ToMemrefOps always bufferize inplace.
       return true;
     }
 
-    SmallVector<OpResult> getAliasingOpResult(
+    AliasingOpResultList getAliasingOpResults(
         OpOperand &opOperand, const AnalysisState &state) const {
       return {};
     }
 
     LogicalResult bufferize(RewriterBase &rewriter,
                             const BufferizationOptions &options);
   }];
 
   let assemblyFormat = "$tensor attr-dict `:` type($memref)";
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
 #endif // BUFFERIZATION_OPS

mlir/include/mlir/Dialect/Bufferization/IR/DstBufferizableOpInterfaceImpl.h

struct DstBufferizableOpInterfaceExternalModel
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Only outputs bufferize to a memory write.
     auto dstOp = cast<DestinationStyleOpInterface>(op);
     return dstOp.isDpsInit(&opOperand);
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     // Output operands alias with their respective tied OpResults.
     auto dstOp = cast<DestinationStyleOpInterface>(op);
     if (dstOp.isDpsInit(&opOperand))
       return {dstOp.getTiedOpResult(&opOperand)};
     return {};
   }
 

mlir/lib/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.cpp

bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {op->getResult(0)};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Equivalent;
   }
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {op->getOpResult(0) /*result*/};
   }
 
-  SmallVector<OpOperand *>
-  getAliasingOpOperand(Operation *op, OpResult opResult,
+  AliasingOpOperandList
+  getAliasingOpOperands(Operation *op, OpResult opResult,
                         const AnalysisState &state) const {
     return {&op->getOpOperand(1) /*true_value*/,
             &op->getOpOperand(2) /*false_value*/};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto selectOp = cast<arith::SelectOp>(op);
     Location loc = selectOp.getLoc();

mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp

for (OpOperand &opOperand : op->getOpOperands()) {
     Type operandType = opOperand.get().getType();
     if (!operandType.isa<TensorType>())
       continue;
     if (state.isInPlace(opOperand))
       continue;
     if (operandType.isa<UnrankedTensorType>())
       return op->emitError("copying of unranked tensors is not implemented");
 
-    SmallVector<OpResult> aliasingOpResults =
-        state.getAliasingOpResult(opOperand);
+    AliasingOpResultList aliasingOpResults =
+        state.getAliasingOpResults(opOperand);
     // Is the result yielded from a block? Or are deallocations turned off
     // entirely? In either case, mark the allocation as "escaping", so that it
     // will not be deallocated.
     bool escape = !state.getOptions().createDeallocs ||
                   llvm::any_of(aliasingOpResults, [&](Value v) {
                     return state.isTensorYielded(v);
                   });
 
     if (aliasingOpResults.size() == 1 &&
         !state.bufferizesToMemoryWrite(opOperand) &&
-        state.getAliasingOpOperand(aliasingOpResults.front()).size() == 1 &&
+        state.getAliasingOpOperands(aliasingOpResults.front()).size() == 1 &&
         !aliasingOpResults.front().getType().isa<UnrankedTensorType>()) {
       // The op itself does not write but may create exactly one alias. Instead
       // of copying the OpOperand, copy the OpResult. The OpResult can sometimes
       // be smaller than the OpOperand (e.g., in the case of an extract_slice,
       // where the result is usually a smaller part of the source). Do not apply
       // this optimization if the OpResult is an unranked tensor (because those
       // cannot be copied at the moment).
       outOfPlaceOpResults.push_back(aliasingOpResults.front());
static void setInsertionPointAfter(OpBuilder &b, Value value) {
   } else {
     b.setInsertionPointAfter(value.getDefiningOp());
   }
 }
 
 /// Determine which OpOperand* will alias with `opResult` if the op is
 /// bufferized in place. Return all tensor OpOperand* if the op is not
 /// bufferizable.
-SmallVector<OpOperand *>
-AnalysisState::getAliasingOpOperand(OpResult opResult) const {
+AliasingOpOperandList
+AnalysisState::getAliasingOpOperands(OpResult opResult) const {
   if (Operation *op = opResult.getDefiningOp())
     if (auto bufferizableOp = getOptions().dynCastBufferizableOp(op))
-      return bufferizableOp.getAliasingOpOperand(opResult, *this);
+      return bufferizableOp.getAliasingOpOperands(opResult, *this);
 
   // The op is not bufferizable.
-  return detail::unknownGetAliasingOpOperand(opResult);
+  return detail::unknownGetAliasingOpOperands(opResult);
 }
 
 /// Determine which OpResult will alias with `opOperand` if the op is bufferized
 /// in place. Return all tensor OpResults if the op is not bufferizable.
-SmallVector<OpResult>
-AnalysisState::getAliasingOpResult(OpOperand &opOperand) const {
+AliasingOpResultList
+AnalysisState::getAliasingOpResults(OpOperand &opOperand) const {
   if (auto bufferizableOp =
           getOptions().dynCastBufferizableOp(opOperand.getOwner()))
-    return bufferizableOp.getAliasingOpResult(opOperand, *this);
+    return bufferizableOp.getAliasingOpResults(opOperand, *this);
 
   // The op is not bufferizable.
-  return detail::unknownGetAliasingOpResult(opOperand);
+  return detail::unknownGetAliasingOpResults(opOperand);
 }
 
 /// Return true if `opOperand` bufferizes to a memory read. Return `true` if the
 /// op is not bufferizable.
 bool AnalysisState::bufferizesToMemoryRead(OpOperand &opOperand) const {
   if (auto bufferizableOp =
           getOptions().dynCastBufferizableOp(opOperand.getOwner()))
     return bufferizableOp.bufferizesToMemoryRead(opOperand, *this);
bool AnalysisState::isValueRead(Value value) const {
   SmallVector<OpOperand *> workingSet;
   for (OpOperand &use : value.getUses())
     workingSet.push_back(&use);
 
   while (!workingSet.empty()) {
     OpOperand *uMaybeReading = workingSet.pop_back_val();
     // Skip over all ops that neither read nor write (but create an alias).
     if (bufferizesToAliasOnly(*uMaybeReading))
-      for (OpResult opResult : getAliasingOpResult(*uMaybeReading))
+      for (OpResult opResult : getAliasingOpResults(*uMaybeReading))
         for (OpOperand &use : opResult.getUses())
           workingSet.push_back(&use);
     if (bufferizesToMemoryRead(*uMaybeReading))
       return true;
   }
 
   return false;
 }
while (!workingSet.empty()) {
     if (condition(value) || value.isa<BlockArgument>()) {
       result.insert(value);
       continue;
     }
 
     OpResult opResult = value.cast<OpResult>();
     BufferizableOpInterface bufferizableOp =
         options.dynCastBufferizableOp(opResult.getDefiningOp());
-    SmallVector<OpOperand *> opOperands = getAliasingOpOperand(opResult);
+    AliasingOpOperandList aliases = getAliasingOpOperands(opResult);
 
     // Stop iterating in either one of these cases:
     // * The current op is not bufferizable or excluded in the filter.
     // * There are no OpOperands to follow.
     // * There is an OpOperand, but it is not an equivalent tensor (only if
     //   `followEquivalentOnly` is set).
-    if (!bufferizableOp || opOperands.empty() ||
+    if (!bufferizableOp || aliases.empty() ||
         (followEquivalentOnly &&
          bufferizableOp.bufferRelation(opResult, *this) !=
              BufferRelation::Equivalent)) {
       if (alwaysIncludeLeaves)
         result.insert(value);
       continue;
     }
 
-    for (OpOperand *o : opOperands)
+    for (OpOperand *o : aliases)
       workingSet.insert(o->get());
   }
 
   return result;
 }
 
 // Find the values that define the contents of the given value.
 llvm::SetVector<Value>
if (hasUndefinedContents(&opOperand))
     return true;
 
   // Do not copy if the buffer of the tensor is entirely overwritten (with
   // values that do not depend on the old tensor).
   if (bufferizesToMemoryWrite(opOperand) && !bufferizesToMemoryRead(opOperand))
     return true;
 
   // Do not copy if the tensor is never read.
-  SmallVector<OpResult> aliasingOpResults = getAliasingOpResult(opOperand);
+  AliasingOpResultList aliases = getAliasingOpResults(opOperand);
   if (!bufferizesToMemoryRead(opOperand) &&
-      llvm::none_of(aliasingOpResults,
+      llvm::none_of(aliases,
                     [&](OpResult opResult) { return isValueRead(opResult); }))
     return true;
 
   // Default: Cannot omit the copy.
   return false;
 }
 
 bool AnalysisState::isInPlace(OpOperand &opOperand) const {
while (!worklist.empty()) {
     // Check if the op is returning/yielding.
     if (isRegionReturnLike(op))
       return true;
 
     // Add all aliasing OpResults to the worklist.
     // Note: In the absence of detailed analysis information (e.g., there may be
     // no function call analysis information), this `getAliasingOpResult` is
     // conservative and may report additional OpResults as potentially aliasing.
-    for (OpResult opResult : getAliasingOpResult(*operand))
+    for (OpResult opResult : getAliasingOpResults(*operand))
       for (OpOperand &use : opResult.getUses())
         worklist.push_back(&use);
   }
 
   // No ReturnLike op found: The value is not yielded.
   return false;
 }
 

 
 //===----------------------------------------------------------------------===//
 // Default implementations of interface methods
 //===----------------------------------------------------------------------===//
 
 bool bufferization::detail::defaultResultBufferizesToMemoryWrite(
     OpResult opResult, const AnalysisState &state) {
   auto bufferizableOp = cast<BufferizableOpInterface>(opResult.getDefiningOp());
-  SmallVector<OpOperand *> opOperands =
-      bufferizableOp.getAliasingOpOperand(opResult, state);
+  AliasingOpOperandList opOperands =
+      bufferizableOp.getAliasingOpOperands(opResult, state);
 
   // Case 1: OpResults that have no aliasing OpOperand usually bufferize to
   // memory writes.
   if (opOperands.empty())
     return true;
 
   // Case 2: If an aliasing OpOperand bufferizes to a memory write, the OpResult
   // may bufferize to a memory write.
if (!state
                                             isMemoryWriteInsideOp,
                                             /*followEquivalentOnly=*/false)
              .empty())
       return true;
   }
   return false;
 }
 
+// Compute the AliasingOpOperandList for a given OpResult based on
+// getAliasingOpResults.
+AliasingOpOperandList bufferization::detail::defaultGetAliasingOpOperands(
+    OpResult opResult, const AnalysisState &state) {
+  Operation *op = opResult.getDefiningOp();
+  AliasingOpOperandList result;
+  for (OpOperand &opOperand : op->getOpOperands()) {
+    if (!opOperand.get().getType().isa<TensorType>())
+      continue;
+    AliasingOpResultList aliasingOpResults =
+        state.getAliasingOpResults(opOperand);
+    if (llvm::is_contained(aliasingOpResults, opResult))
+      result.push_back(&opOperand);
+  }
+  return result;
+}
+
 FailureOr<BaseMemRefType> bufferization::detail::defaultGetBufferType(
     Value value, const BufferizationOptions &options,
     const DenseMap<Value, BaseMemRefType> &fixedTypes) {
   assert(value.getType().isa<TensorType>() && "expected tensor type");
 
   // No further analysis is possible for a block argument.
   if (value.isa<BlockArgument>())
     return bufferization::getMemRefType(value, options);
 
   // Value is an OpResult.
   Operation *op = getOwnerOfValue(value);
   auto opResult = value.cast<OpResult>();
   auto bufferizableOp = cast<BufferizableOpInterface>(op);
   AnalysisState state(options);
-  auto aliasingOperands = bufferizableOp.getAliasingOpOperand(opResult, state);
-  if (!aliasingOperands.empty() &&
-      bufferizableOp.bufferRelation(opResult, state) ==
+  AliasingOpOperandList aliases = state.getAliasingOpOperands(opResult);
+  if (!aliases.empty() && bufferizableOp.bufferRelation(opResult, state) ==
                               BufferRelation::Equivalent) {
     // If the OpResult has an equivalent OpOperand, both OpResult and
     // OpOperand bufferize to the exact same buffer type.
-    Value equivalentOperand = aliasingOperands.front()->get();
+    Value equivalentOperand = aliases.front()->get();
     return getBufferType(equivalentOperand, options, fixedTypes);
   }
 
   // If we do not know the memory space and there is no default memory space,
   // report a failure.
   if (!options.defaultMemorySpace.has_value())
     return op->emitError("could not infer memory space");
 
   return getMemRefType(value, options, /*layout=*/{},
                        *options.defaultMemorySpace);
 }
 
 bool bufferization::detail::defaultIsRepetitiveRegion(
     BufferizableOpInterface bufferizableOp, unsigned index) {
   assert(index < bufferizableOp->getNumRegions() && "invalid region index");
   auto regionInterface =
       dyn_cast<RegionBranchOpInterface>(bufferizableOp.getOperation());
   if (!regionInterface)
     return false;
   return regionInterface.isRepetitiveRegion(index);
 }
 
-SmallVector<OpOperand *>
-bufferization::detail::unknownGetAliasingOpOperand(OpResult opResult) {
+AliasingOpOperandList
+bufferization::detail::unknownGetAliasingOpOperands(OpResult opResult) {
   // Conservatively assume that everything is aliasing.
-  SmallVector<OpOperand *> r;
+  AliasingOpOperandList r;
   for (OpOperand &operand : opResult.getDefiningOp()->getOpOperands())
     if (operand.get().getType().isa<TensorType>())
       r.push_back(&operand);
   return r;
 }
 
-SmallVector<OpResult>
-bufferization::detail::unknownGetAliasingOpResult(OpOperand &opOperand) {
+AliasingOpResultList
+bufferization::detail::unknownGetAliasingOpResults(OpOperand &opOperand) {
   // Conservatively assume that everything is aliasing.
-  SmallVector<OpResult> r;
+  AliasingOpResultList r;
   for (OpResult result : opOperand.getOwner()->getOpResults())
     if (result.getType().isa<TensorType>())
       r.push_back(result);
   return r;
 }

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

 
 bool AllocTensorOp::bufferizesToMemoryWrite(OpOperand &opOperand,
                                             const AnalysisState &state) {
   assert(opOperand.getOperandNumber() == getNumOperands() - 1 &&
          "expected copy operand");
   return false;
 }
 
-SmallVector<OpResult>
-AllocTensorOp::getAliasingOpResult(OpOperand &opOperand,
+AliasingOpResultList
+AllocTensorOp::getAliasingOpResults(OpOperand &opOperand,
                                     const AnalysisState &state) {
   // This is a new allocation. It does not alias with any other buffer.
   return {};
 }
 
 FailureOr<BaseMemRefType> AllocTensorOp::getBufferType(
     Value value, const BufferizationOptions &options,
     const DenseMap<Value, BaseMemRefType> &fixedTypes) {
   assert(value == getResult() && "invalid value");

mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp

if (getFuncOpAnalysisState(state, funcOp) != FuncOpAnalysisState::Analyzed)
       // FuncOp not analyzed yet. Assume that OpOperand is written.
       return true;
 
     const FuncAnalysisState &funcState = getFuncAnalysisState(state);
     return funcState.writtenBbArgs.lookup(funcOp).contains(
         opOperand.getOperandNumber());
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     func::CallOp callOp = cast<func::CallOp>(op);
     FuncOp funcOp = getCalledFunction(callOp);
     assert(funcOp && "expected CallOp to a FuncOp");
     if (getFuncOpAnalysisState(state, funcOp) != FuncOpAnalysisState::Analyzed)
       // FuncOp not analyzed yet. Any OpResult may be aliasing.
-      return detail::unknownGetAliasingOpResult(opOperand);
+      return detail::unknownGetAliasingOpResults(opOperand);
 
     // Get aliasing results from state.
     const FuncAnalysisState &funcState = getFuncAnalysisState(state);
     auto aliasingReturnVals =
         funcState.aliasingReturnVals.lookup(funcOp).lookup(
             opOperand.getOperandNumber());
-    SmallVector<OpResult> result;
+    AliasingOpResultList result;
     for (int64_t resultIdx : aliasingReturnVals)
       result.push_back(callOp->getOpResult(resultIdx));
     return result;
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     func::CallOp callOp = cast<func::CallOp>(op);
     FuncOp funcOp = getCalledFunction(callOp);
     assert(funcOp && "expected CallOp to a FuncOp");
     if (getFuncOpAnalysisState(state, funcOp) !=
         FuncOpAnalysisState::Analyzed) {
       // Function not analyzed yet. The conservative answer is "None".
       return BufferRelation::Unknown;
     }
 
     const FuncAnalysisState &funcState = getFuncAnalysisState(state);
     std::optional<int64_t> maybeEquiv =
         getEquivalentFuncArgIdx(funcOp, funcState, opResult.getResultNumber());
     if (maybeEquiv) {
 #ifndef NDEBUG
       SmallVector<OpOperand *> aliasingOpOperands =
-          getAliasingOpOperand(op, opResult, state);
+          getAliasingOpOperands(op, opResult, state);
       assert(aliasingOpOperands.size() == 1 &&
              "expected exactly 1 aliasing OpOperand");
       assert(aliasingOpOperands.front()->getOperandNumber() == *maybeEquiv &&
              "inconsistent analysis state");
 #endif
       return BufferRelation::Equivalent;
     }
     return BufferRelation::Unknown;
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
 #ifndef NDEBUG
     auto returnOp = cast<func::ReturnOp>(op);

mlir/lib/Dialect/Bufferization/Transforms/OneShotAnalysis.cpp

 }
 
 /// Set the inPlace bufferization spec to true.
 void BufferizationAliasInfo::bufferizeInPlace(OpOperand &operand,
                                               AnalysisState &state) {
   if (inplaceBufferized.contains(&operand))
     return;
   markInPlace(operand);
-  for (OpResult result : state.getAliasingOpResult(operand))
+  for (OpResult result : state.getAliasingOpResults(operand))
     aliasInfo.unionSets(result, operand.get());
   ++statNumTensorInPlace;
 }
 
 /// Set the inPlace bufferization spec to false.
 void BufferizationAliasInfo::bufferizeOutOfPlace(OpOperand &operand) {
   assert(!inplaceBufferized.contains(&operand) &&
          "OpOperand was already decided to bufferize inplace");
for (OpOperand *uConflictingWrite : usesWrite) {
             // conflictingWritingOp happens outside of the block. No
             // conflict.
             continue;
           }
         }
 
         // No conflict if the conflicting write and the definition are the same
         // use.
-        SmallVector<OpResult> aliasingOpResult =
-            state.getAliasingOpResult(*uConflictingWrite);
-        if (aliasingOpResult.size() == 1 && aliasingOpResult[0] == definition) {
+        AliasingOpResultList aliases =
+            state.getAliasingOpResults(*uConflictingWrite);
+        if (aliases.size() == 1 && aliases[0] == definition) {
           LLVM_DEBUG(llvm::dbgs()
                      << "    no conflict: definition and write are same\n");
           continue;
         }
 
         // All requirements are met. Conflict found!
 
         if (options.printConflicts)
for (auto &use : alias.getUses()) {
       // but its aliasing result is eventually fed into an op that does.
       //
       // Note: This is considered a "read" only if the use does not bufferize to
       // a memory write. (We already ruled out memory reads. In case of a memory
       // write, the buffer would be entirely overwritten; in the above example
       // there would then be no flow of data from the extract_slice operand to
       // its result's uses.)
       if (!state.bufferizesToMemoryWrite(use)) {
-        SmallVector<OpResult> opResults = state.getAliasingOpResult(use);
+        AliasingOpResultList opResults = state.getAliasingOpResults(use);
         if (llvm::any_of(opResults,
                          [&](OpResult r) { return state.isValueRead(r); }))
           res.insert(&use);
       }
     }
   });
 }
 

 static bool wouldCreateReadAfterWriteInterference(
     OpOperand &operand, const DominanceInfo &domInfo, AnalysisState &state,
     const BufferizationAliasInfo &aliasInfo,
     bool checkConsistencyOnly = false) {
   // Collect reads and writes of all aliases of OpOperand and OpResult.
   DenseSet<OpOperand *> usesRead, usesWrite;
   getAliasingReads(usesRead, operand.get(), aliasInfo, state);
   getAliasingInplaceWrites(usesWrite, operand.get(), aliasInfo, state);
-  for (OpResult result : state.getAliasingOpResult(operand)) {
+  for (OpResult result : state.getAliasingOpResults(operand)) {
     getAliasingReads(usesRead, result, aliasInfo, state);
     getAliasingInplaceWrites(usesWrite, result, aliasInfo, state);
   }
   if (!checkConsistencyOnly && state.bufferizesToMemoryWrite(operand))
     usesWrite.insert(&operand);
 
   return hasReadAfterWriteInterference(usesRead, usesWrite, domInfo, state,
                                        aliasInfo);
while (!worklist.empty()) {
     }
 
     // If `nextVal` is not a BlockArgument: End of use-def chain reached.
     auto opResult = nextVal.dyn_cast<OpResult>();
     if (!opResult)
       continue;
 
     // Follow reverse SSA use-def chain.
-    SmallVector<OpOperand *> aliasingOpOperands =
-        state.getAliasingOpOperand(opResult);
+    AliasingOpOperandList aliasingOpOperands =
+        state.getAliasingOpOperands(opResult);
     for (OpOperand *opOperand : aliasingOpOperands)
       if (aliasInfo.isInPlace(*opOperand) || currentOpOperand == opOperand)
         worklist.push_back(opOperand->get());
   }
   return false;
 }
 
 /// Return true if bufferizing `operand` inplace would create a write to a
 /// non-writable buffer.
 static bool wouldCreateWriteToNonWritableBuffer(
     OpOperand &operand, const BufferizationAliasInfo &aliasInfo,
     OneShotAnalysisState &state, bool checkConsistencyOnly = false) {
   // Collect writes of all aliases of OpOperand and OpResult.
   DenseSet<OpOperand *> usesWrite;
   getAliasingInplaceWrites(usesWrite, operand.get(), aliasInfo, state);
-  for (OpResult result : state.getAliasingOpResult(operand)) {
+  for (OpResult result : state.getAliasingOpResults(operand)) {
     getAliasingInplaceWrites(usesWrite, result, aliasInfo, state);
   }
   if (!checkConsistencyOnly && state.bufferizesToMemoryWrite(operand))
     usesWrite.insert(&operand);
 
   // Assuming that `operand` bufferizes in-place: For each write (to each
   // alias), check if there is a non-writable tensor in the reverse SSA use-def
   // chain.

 static void equivalenceAnalysis(SmallVector<Operation *> &ops,
                                 BufferizationAliasInfo &aliasInfo,
                                 AnalysisState &state) {
   for (Operation *op : ops)
     if (auto bufferizableOp = state.getOptions().dynCastBufferizableOp(op))
       for (OpResult opResult : op->getOpResults())
         if (opResult.getType().isa<TensorType>())
           for (OpOperand *opOperand :
-               bufferizableOp.getAliasingOpOperand(opResult, state))
+               bufferizableOp.getAliasingOpOperands(opResult, state))
             if (state.isInPlace(*opOperand))
               if (bufferizableOp.bufferRelation(opResult, state) ==
                   BufferRelation::Equivalent)
                 aliasInfo.unionEquivalenceClasses(opResult, opOperand->get());
 }
 
 /// Analyze equivalence of tied OpResult/OpOperand pairs of all ops contained
 /// in `op`.

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

bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     // Operand is read if it is used in the computation.
     auto genericOp = cast<linalg::LinalgOp>(op);
     return genericOp.payloadUsesValueFromOperand(&opOperand);
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Operand is written to if it has an aliasing OpResult.
-    auto bufferizableOp = cast<BufferizableOpInterface>(op);
-    return !bufferizableOp.getAliasingOpResult(opOperand, state).empty();
+    auto dpsOp = cast<DestinationStyleOpInterface>(op);
+    return dpsOp.isDpsInit(&opOperand);
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     return bufferizeDestinationStyleOpInterface(
         rewriter, cast<DestinationStyleOpInterface>(op), options);
   }
 };

mlir/lib/Dialect/SCF/Transforms/BufferizableOpInterfaceImpl.cpp

bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 
   bool mustBufferizeInPlace(Operation *op, OpOperand &opOperand,
                             const AnalysisState &state) const {
     // Condition operands always bufferize inplace. Otherwise, an alloc + copy
     // may be generated inside the block. We should not return/yield allocations
struct ConditionOpInterface
   }
 };
 
 /// Bufferization of scf.execute_region. Can be analyzed, but bufferization not
 /// fully implemented at the moment.
 struct ExecuteRegionOpInterface
     : public BufferizableOpInterface::ExternalModel<ExecuteRegionOpInterface,
                                                     scf::ExecuteRegionOp> {
-  SmallVector<OpOperand *>
-  getAliasingOpOperand(Operation *op, OpResult opResult,
+  AliasingOpOperandList
+  getAliasingOpOperands(Operation *op, OpResult opResult,
                         const AnalysisState &state) const {
     // ExecuteRegionOps do not have tensor OpOperands. The yielded value can be
     // any SSA value that is in scope. To allow for use-def chain traversal
     // through ExecuteRegionOps in the analysis, the corresponding yield value
     // is considered to be aliasing with the result.
     auto executeRegionOp = cast<scf::ExecuteRegionOp>(op);
     size_t resultNum = std::distance(op->getOpResults().begin(),
                                      llvm::find(op->getOpResults(), opResult));
     // TODO: Support multiple blocks.
BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Equivalent;
   }
 };
 
 /// Bufferization of scf.if. Replace with a new scf.if that yields memrefs.
 struct IfOpInterface
     : public BufferizableOpInterface::ExternalModel<IfOpInterface, scf::IfOp> {
-  SmallVector<OpOperand *>
-  getAliasingOpOperand(Operation *op, OpResult opResult,
+  AliasingOpOperandList
+  getAliasingOpOperands(Operation *op, OpResult opResult,
                         const AnalysisState &state) const {
     // IfOps do not have tensor OpOperands. The yielded value can be any SSA
     // value that is in scope. To allow for use-def chain traversal through
     // IfOps in the analysis, both corresponding yield values from the then/else
     // branches are considered to be aliasing with the result.
     auto ifOp = cast<scf::IfOp>(op);
     size_t resultNum = std::distance(op->getOpResults().begin(),
                                      llvm::find(op->getOpResults(), opResult));
     return {&ifOp.thenYield()->getOpOperand(resultNum),
struct IfOpInterface
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     // IfOp results are equivalent to their corresponding yield values if both
     // yield values are equivalent to each other.
     auto bufferizableOp = cast<BufferizableOpInterface>(op);
     SmallVector<OpOperand *> yieldValues =
-        bufferizableOp.getAliasingOpOperand(opResult, state);
+        bufferizableOp.getAliasingOpOperands(opResult, state);
     assert(yieldValues.size() == 2 && "expected 2 yield values");
     bool equivalentYields = state.areEquivalentBufferizedValues(
         yieldValues[0]->get(), yieldValues[1]->get());
     return equivalentYields ? BufferRelation::Equivalent
                             : BufferRelation::Unknown;
   }
 };
 
struct ForOpInterface
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Tensor iter_args of scf::ForOps are always considered as a write.
     return true;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     auto forOp = cast<scf::ForOp>(op);
     return {forOp.getResultForOpOperand(opOperand)};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     // ForOp results are equivalent to their corresponding init_args if the
struct WhileOpInterface
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Tensor iter_args of scf::WhileOps are always considered as a write.
     return true;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     auto whileOp = cast<scf::WhileOp>(op);
     unsigned int idx = opOperand.getOperandNumber();
 
     // The OpResults and OpOperands may not match. They may not even have the
     // same type. The number of OpResults and OpOperands can also differ.
     if (idx >= op->getNumResults() ||
         opOperand.get().getType() != op->getResult(idx).getType())
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     if (isa<scf::IfOp>(op->getParentOp()))
       return {op->getParentOp()->getResult(opOperand.getOperandNumber())};
     if (isa<scf::ExecuteRegionOp>(op->getParentOp()))
       return {op->getParentOp()->getResult(opOperand.getOperandNumber())};
     return {};
   }
 
struct ForeachThreadOpInterface
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Outputs of scf::ForeachThreadOps are always considered as a write.
     return true;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     auto foreachThreadOp = cast<ForeachThreadOp>(op);
     return {foreachThreadOp.getTiedOpResult(&opOperand)};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Equivalent;

mlir/lib/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.cpp

 namespace mlir {
 namespace shape {
 namespace {
 
 /// Bufferization of shape.assuming.
 struct AssumingOpInterface
     : public BufferizableOpInterface::ExternalModel<AssumingOpInterface,
                                                     shape::AssumingOp> {
-  SmallVector<OpOperand *>
-  getAliasingOpOperand(Operation *op, OpResult opResult,
+  AliasingOpOperandList
+  getAliasingOpOperands(Operation *op, OpResult opResult,
                         const AnalysisState &state) const {
     // AssumingOps do not have tensor OpOperands. The yielded value can be any
     // SSA value that is in scope. To allow for use-def chain traversal through
     // AssumingOps in the analysis, the corresponding yield value is considered
     // to be aliasing with the result.
     auto assumingOp = cast<shape::AssumingOp>(op);
     size_t resultNum = std::distance(op->getOpResults().begin(),
                                      llvm::find(op->getOpResults(), opResult));
     // TODO: Support multiple blocks.
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     assert(isa<shape::AssumingOp>(op->getParentOp()) &&
            "expected that parent is an AssumingOp");
-    return {op->getParentOp()->getResult(opOperand.getOperandNumber())};
+    OpResult opResult =
+        op->getParentOp()->getResult(opOperand.getOperandNumber());
+    return {opResult};
   }
 
   bool mustBufferizeInPlace(Operation *op, OpOperand &opOperand,
                             const AnalysisState &state) const {
     // Yield operands always bufferize inplace. Otherwise, an alloc + copy
     // may be generated inside the block. We should not return/yield allocations
     // when possible.
     return true;

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

bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 
   bool isWritable(Operation *op, Value value,
                   const AnalysisState &state) const {
     return true;
   }
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 
   bool isWritable(Operation *op, Value value,
                   const AnalysisState &state) const {
     return true;
   }
 };
 
 struct LoadOpInterface
     : public BufferizableOpInterface::ExternalModel<LoadOpInterface,
                                                     sparse_tensor::LoadOp> {
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {op->getOpResult(0)};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Equivalent;
   }
struct InsertOpInterface
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // InsertOp writes to memory.
     return true;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     // InsertOp returns an alias of its operand.
     assert(op->getNumResults() == 1);
     return op->getResults();
   }
 
   BufferRelation bufferRelation(Operation *oo, OpResult opResult,
                                 const AnalysisState &state) const {
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 };
 
 struct ToIndicesBufferOpInterface
     : public BufferizableOpInterface::ExternalModel<
           ToIndicesBufferOpInterface, sparse_tensor::ToIndicesBufferOp> {
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Potential writes into memory through the result of sparse_tensor.indices
     // are not considered.
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 };
 
 struct ToIndicesOpInterface
     : public BufferizableOpInterface::ExternalModel<
           ToIndicesOpInterface, sparse_tensor::ToIndicesOp> {
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Potential writes into memory through the result of sparse_tensor.indices
     // are not considered.
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 };
 
 struct ToPointersOpInterface
     : public BufferizableOpInterface::ExternalModel<
           ToPointersOpInterface, sparse_tensor::ToPointersOp> {
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Potential writes into memory through the result of sparse_tensor.pointers
     // are not considered.
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 };
 
 struct ToValuesOpInterface
     : public BufferizableOpInterface::ExternalModel<ToValuesOpInterface,
                                                     sparse_tensor::ToValuesOp> {
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Potential writes into memory through the result of sparse_tensor.values
     // are not considered.
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 };
 
 } // namespace
 } // namespace sparse_tensor
 } // namespace mlir

mlir/lib/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.cpp

bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {op->getResult(0)};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Equivalent;
   }
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
-    if (&opOperand == &op->getOpOperand(0) /*src*/)
-      return {op->getOpResult(0)};
-    return {};
+    // TODO: CollapseShapeOp may allocate at runtime.
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Equivalent;
   }
 
   FailureOr<BaseMemRefType>
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto dimOp = cast<tensor::DimOp>(op);
     FailureOr<Value> v = getBuffer(rewriter, dimOp.getSource(), options);
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
-    if (&opOperand == &op->getOpOperand(0) /*src*/)
-      return {op->getOpResult(0)};
-    return {};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Equivalent;
   }
 
   FailureOr<BaseMemRefType>
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     if (&opOperand == &op->getOpOperand(0) /*source*/)
       return {op->getOpResult(0)};
     return {};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto extractOp = cast<tensor::ExtractOp>(op);
     FailureOr<Value> srcMemref =
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 
   FailureOr<BaseMemRefType>
   getBufferType(Operation *op, Value value, const BufferizationOptions &options,
                 const DenseMap<Value, BaseMemRefType> &fixedTypes) const {
     // Infer memory space from the source tensor.
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto rankOp = cast<tensor::RankOp>(op);
     FailureOr<Value> v = getBuffer(rewriter, rankOp.getTensor(), options);
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {op->getOpResult(0)};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Equivalent;
   }
LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
     return success();
   }
 };
 
 /// Analysis of ParallelInsertSliceOp.
 struct ParallelInsertSliceOpInterface
     : public BufferizableOpInterface::ExternalModel<
           ParallelInsertSliceOpInterface, ParallelInsertSliceOp> {
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
-      return {};
   }
 
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,

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

struct TransferReadOpInterface
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     assert(opOperand.get().getType().isa<RankedTensorType>() &&
            "only tensor types expected");
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto readOp = cast<vector::TransferReadOp>(op);
     assert(readOp.getShapedType().isa<TensorType>() &&
struct GatherOpInterface
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     assert(opOperand.get().getType().isa<RankedTensorType>() &&
            "only tensor types expected");
     return false;
   }
 
-  SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
+  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     return {};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto gatherOp = cast<vector::GatherOp>(op);
     assert(gatherOp.getBaseType().isa<TensorType>() &&