[mlir][linalg][bufferize] Remove redundant methods from op interface

[springerm]

Summary

These two methods are redundant and removed:

• bufferizesToAliasOnly: If not bufferizesToMemoryRead and not bufferizesToMemoryWrite but getAliasingOpResult returns a non-null value, we know that this OpOperand is alias-only.
• getInplaceableOpResult: The analysis does not differentiate between "inplaceable" and "aliasing". The only thing that matters is whether or not OpOperand and OpResult are aliasing. That is the key property that makes buffer copies necessary.

Depends On D112901

[springerm]

no change

[springerm]

no change

[springerm]

update

[springerm]

rebase

mlir/include/mlir/Dialect/Linalg/Transforms/BufferizableOpInterface.td

let methods = [
         /*methodName=*/"bufferizesToMemoryWrite",
         /*args=*/(ins "OpOperand &":$opOperand),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           // Does not have to be implemented for ops without tensor OpOperands.
           llvm_unreachable("bufferizesToMemoryWrite not implemented");
          }]
       >,
-      // TODO: Simplify this interface by removing `bufferizesToAliasOnly` and
-      // `getInplaceableOpResult`. Instead, always use `getAliasingOpResult`. If
-      // `getAliasingOpResult` returns a non-null value, we know that an alias
-      // is created. If `bufferizesToMemoryRead` and `bufferizesToMemoryWrite`
-      // return `false`, we know that the operands "bufferizes to alias only".
-      InterfaceMethod<
-        /*desc=*/[{
-          Return `true` if the given OpOperand creates an alias but does neither
-          read nor write. This implies that `bufferizesToMemoryRead` and
-          `bufferizesToMemoryWrite` must return `false`. This method will never
-          be called on OpOperands that do not have a tensor type.
-
-          Examples of such ops are `tensor.extract_slice` and `tensor.cast`.
-        }],
-        /*retType=*/"bool",
-        /*methodName=*/"bufferizesToAliasOnly",
-        /*args=*/(ins "OpOperand &":$opOperand),
-        /*methodBody=*/"",
-        /*defaultImplementation=*/[{
-          // For better debugging, run `bufferizesToMemoryWrite`, which fires an
-          // assertion when called on an op that should not have tensor
-          // OpOperands.
-          (void) cast<BufferizableOpInterface>($_op.getOperation())
-              .bufferizesToMemoryWrite(opOperand);
-          // Return `false` by default, as most ops are not "alias only".
-          return false;
-         }]
-      >,
-      InterfaceMethod<
-        /*desc=*/[{
-          Return the OpResult that can bufferize in-place with a given
-          OpOperand. Return a null value if the OpOperand cannot bufferize
-          in-place. This method will never be called on OpOperands that do not
-          have a tensor type.
-        }],
-        /*retType=*/"OpResult",
-        /*methodName=*/"getInplaceableOpResult",
-        /*args=*/(ins "OpOperand &":$opOperand),
-        /*methodBody=*/"",
-        /*defaultImplementation=*/[{
-          // Does not have to be implemented for ops without tensor OpOperands.
-          llvm_unreachable("getInplaceableOpResult not implemented");
-        }]
-      >,
       InterfaceMethod<
         /*desc=*/[{
           Return the OpResult that aliases with a given OpOperand when
           bufferized in-place. This is a superset of `getInplaceableOpResult`.
           This method will never be called on OpOperands that do not have a
           tensor type.
         }],
         /*retType=*/"OpResult",

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

 static SmallVector<OpOperand *> getAliasingOpOperand(OpResult result) {
   if (Operation *op = result.getDefiningOp())
     if (auto bufferizableOp = dyn_cast<BufferizableOpInterface>(op))
       return bufferizableOp.getAliasingOpOperand(result);
   return {};
 }
 
 /// Determine which OpResult will alias with `opOperand` if the op is bufferized
-/// in place. This is a superset of `getInplaceableOpResult`. Return an empty
-/// OpResult if the op is not bufferizable.
+/// in place. Return an empty OpResult if the op is not bufferizable.
 static OpResult getAliasingOpResult(OpOperand &opOperand) {
   if (auto bufferizableOp =
           dyn_cast<BufferizableOpInterface>(opOperand.getOwner()))
     return bufferizableOp.getAliasingOpResult(opOperand);
   return OpResult();
 }
 
-/// Return `true` if the given OpOperand does not bufferize to a memory read or
-/// write, but creates an alias when bufferized inplace. Return `false` if the
+/// Return true if `opOperand` bufferizes to a memory read. Return `true` if the
 /// op is not bufferizable.
-static bool bufferizesToAliasOnly(OpOperand &opOperand) {
+static bool bufferizesToMemoryRead(OpOperand &opOperand) {
   if (auto bufferizableOp =
           dyn_cast<BufferizableOpInterface>(opOperand.getOwner()))
-    return bufferizableOp.bufferizesToAliasOnly(opOperand);
+    return bufferizableOp.bufferizesToMemoryRead(opOperand);
 
   // Unknown op that returns a tensor. The inplace analysis does not support it.
-  // Conservatively return false.
-  return false;
+  // Conservatively return true.
+  return true;
 }
 
-// Predeclaration of function.
-static bool bufferizesToMemoryRead(OpOperand &opOperand);
+/// Return true if `opOperand` bufferizes to a memory write. Return
+/// `true` if the op is not bufferizable.
+static bool bufferizesToMemoryWrite(OpOperand &opOperand) {
+  if (auto bufferizableOp =
+          dyn_cast<BufferizableOpInterface>(opOperand.getOwner()))
+    return bufferizableOp.bufferizesToMemoryWrite(opOperand);
+
+  // Unknown op that returns a tensor. The inplace analysis does not support it.
+  // Conservatively return true.
+  return true;
+}
 
 /// Return true if the given value is read by an op that bufferizes to a memory
 /// read. Also takes into account ops that create an alias but do not read by
 /// themselves (e.g., ExtractSliceOp).
 static bool isValueRead(Value value) {
   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 create an alias but do not read.
-    if (bufferizesToAliasOnly(*uMaybeReading))
+    // Skip over all ops that neither read nor write (but create an alias).
+    if (!bufferizesToMemoryRead(*uMaybeReading) &&
+        !bufferizesToMemoryWrite(*uMaybeReading))
       for (OpOperand &use : getAliasingOpResult(*uMaybeReading).getUses())
         workingSet.push_back(&use);
     if (bufferizesToMemoryRead(*uMaybeReading))
       return true;
   }
 
   return false;
 }
 
-/// Return true if `opOperand` bufferizes to a memory read. Return `true` if the
-/// op is not bufferizable.
-static bool bufferizesToMemoryRead(OpOperand &opOperand) {
-  if (auto bufferizableOp =
-          dyn_cast<BufferizableOpInterface>(opOperand.getOwner()))
-    return bufferizableOp.bufferizesToMemoryRead(opOperand);
-
-  // Unknown op that returns a tensor. The inplace analysis does not support it.
-  // Conservatively return true.
-  return true;
-}
-
-/// Return true if `opOperand` bufferizes to a memory write. Return
-/// `true` if the op is not bufferizable.
-static bool bufferizesToMemoryWrite(OpOperand &opOperand) {
-  if (auto bufferizableOp =
-          dyn_cast<BufferizableOpInterface>(opOperand.getOwner()))
-    return bufferizableOp.bufferizesToMemoryWrite(opOperand);
-
-  // Unknown op that returns a tensor. The inplace analysis does not support it.
-  // Conservatively return true.
-  return true;
-}
-
 /// Return the relationship between the operand and the its corresponding
 /// OpResult that it may alias with. Return None if the op is not bufferizable.
 static BufferRelation bufferRelation(OpOperand &opOperand) {
   if (auto bufferizableOp =
           dyn_cast<BufferizableOpInterface>(opOperand.getOwner()))
     return bufferizableOp.bufferRelation(opOperand);
 
   // Unknown op that returns a tensor. The inplace analysis does not support it.
#endif // NDEBUG
   else
     aliasInfo.bufferizeInPlace(result, operand);
 
   LDBG("Done inplace analysis for result #" << resultNumber << '\n');
 
   return success();
 }
 
-/// This analysis function is used for OpOperands that alias with an OpResult
-/// but are not inplaceable on it. E.g., ExtractSliceOp.
+/// Determine if `operand` can be bufferized in-place with one of the op's
+/// results. If so, set InPlaceSpec::True on the result. Otherwise, set
+/// InPlaceSpec::False on the result.
+///
+/// Even if an op does not read or write, it may still create an alias when
+/// bufferized in-place. An example of such ops is tensor.extract_slice.
 ///
 /// Rationale for bufferizing `%1 = tensor.extract_slice %0[...]` inplace:
 ///
 /// When bufferized out of place, an ExtractSliceOp lowers to alloc + copy. This
 /// cannot change the flow of information for either the source or the
 /// result buffers.
 ///
 /// When bufferized inplace, an ExtractSliceOp does not by itself create any
 /// read or write from memory. Instead, it has the effect of merging the alias
 /// sets of the source and the result buffers.
 ///
 /// An analysis is required to ensure inplace bufferization would not result in
 /// RaW dependence violations.
 static LogicalResult
-bufferizableInPlaceAnalysisAliasOnlyOp(OpOperand &operand,
-                                       BufferizationAliasInfo &aliasInfo,
-                                       const DominanceInfo &domInfo) {
-  auto bufferizableOp = dyn_cast<BufferizableOpInterface>(operand.getOwner());
-  assert(bufferizableOp && "expected op with known bufferization behavior");
-  OpResult result = bufferizableOp.getAliasingOpResult(operand);
-  assert(result && "expected that the OpOperand has an aliasing OpResult");
-  return bufferizableInPlaceAnalysisImpl(operand, result, aliasInfo, domInfo);
-}
-
-/// Determine if `operand` can be bufferized in-place with one of the op's
-/// results. If so, set InPlaceSpec::True on the result. Otherwise, set
-/// InPlaceSpec::False on the result.
-static LogicalResult
 bufferizableInPlaceAnalysis(OpOperand &operand,
                             BufferizationAliasInfo &aliasInfo,
                             const DominanceInfo &domInfo) {
   auto bufferizableOp = dyn_cast<BufferizableOpInterface>(operand.getOwner());
   if (!bufferizableOp)
     return success();
-  if (OpResult result = bufferizableOp.getInplaceableOpResult(operand))
+  if (OpResult result = bufferizableOp.getAliasingOpResult(operand))
     return bufferizableInPlaceAnalysisImpl(operand, result, aliasInfo, domInfo);
   return success();
 }
 
 /// Analyze the `ops` to determine which OpResults are inplaceable. Walk ops in
 /// reverse and bufferize ops greedily. This is a good starter heuristic.
 /// ExtractSliceOps are interleaved with other ops in traversal order.
 LogicalResult mlir::linalg::inPlaceAnalysis(SmallVector<Operation *> &ops,
                                             BufferizationAliasInfo &aliasInfo,
                                             const DominanceInfo &domInfo,
                                             unsigned analysisFuzzerSeed) {
   if (analysisFuzzerSeed) {
     // This is a fuzzer. For testing purposes only. Randomize the order in which
     // operations are analyzed. The bufferization quality is likely worse, but
     // we want to make sure that no assertions are triggered anywhere.
     std::mt19937 g(analysisFuzzerSeed);
     llvm::shuffle(ops.begin(), ops.end(), g);
   }
 
   // Walk ops in reverse for better interference analysis.
-  for (Operation *op : reverse(ops)) {
+  for (Operation *op : reverse(ops))
     for (OpOperand &opOperand : op->getOpOperands())
-      if (opOperand.get().getType().isa<TensorType>()) {
+      if (opOperand.get().getType().isa<TensorType>())
         if (failed(bufferizableInPlaceAnalysis(opOperand, aliasInfo, domInfo)))
           return failure();
 
-        // Special logic to analyze OpOperands that are not inplaceable on an
-        // OpResult but may create an alias.
-        if (bufferizesToAliasOnly(opOperand))
-          if (failed(bufferizableInPlaceAnalysisAliasOnlyOp(
-                  opOperand, aliasInfo, domInfo)))
-            return failure();
-      }
-  }
-
   return success();
 }
 
 /// Analyze the `funcOp` body to determine which OpResults are inplaceable.
 static LogicalResult
 inPlaceAnalysisFuncOpBody(FuncOp funcOp, BufferizationAliasInfo &aliasInfo,
                           const DominanceInfo &domInfo,
                           unsigned analysisFuzzerSeed = 0) {
auto extractOp = b.create<tensor::ExtractSliceOp>(
         initTensor.getLoc(), insertOp.dest(), insertOp.getMixedOffsets(),
         insertOp.getMixedSizes(), insertOp.getMixedStrides());
     // Uses of the InitTensorOp are replaced here, but the op is not deleted.
     // InitTensorOps without uses are ignored by the bufferization.
     initTensor.replaceAllUsesWith(extractOp.result());
     aliasInfo.createAliasInfoEntry(extractOp.result());
 
     // Run analysis on the ExtractSliceOp.
-    if (failed(bufferizableInPlaceAnalysisAliasOnlyOp(
-            extractOp->getOpOperand(0), aliasInfo, domInfo)))
+    if (failed(bufferizableInPlaceAnalysis(extractOp->getOpOperand(0),
+                                           aliasInfo, domInfo)))
       return WalkResult::interrupt();
 
     // Advance to the next operation.
     return WalkResult::advance();
   });
 
   return failure(status.wasInterrupted());
 }
static LogicalResult allocateBuffersForResults(
   // Take a guard before anything else.
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(op);
 
   // TODO: provide the proper interface to iterate on OpResults and get the
   // matching OpOperands.
   for (OpOperand *opOperand : op.getOutputOperands()) {
     OpResult opResult = cast<BufferizableOpInterface>(op.getOperation())
-                            .getInplaceableOpResult(*opOperand);
+                            .getAliasingOpResult(*opOperand);
     assert(opResult && "could not find correspond OpResult");
     bool skipCopy = !op.payloadUsesValueFromOperand(opOperand);
     Value resultBuffer =
         getResultBuffer(b, opResult, bvm, aliasInfo, allocationFns, skipCopy);
     if (!resultBuffer)
       return failure();
     resultBuffers.push_back(resultBuffer);
   }
struct LinalgOpInterface
   }
 
   SmallVector<OpOperand *> getAliasingOpOperand(Operation *op,
                                                 OpResult opResult) const {
     auto genericOp = cast<linalg::LinalgOp>(op);
     return {genericOp.getOutputTensorOperands()[opResult.getResultNumber()]};
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     auto genericOp = cast<linalg::LinalgOp>(op);
     if (!opOperand.get().getType().isa<RankedTensorType>())
       return OpResult();
     // For now assume inputs are never inplaceable.
     // TODO: refine this.
     if (opOperand.getOperandNumber() < genericOp.getNumInputs())
       return OpResult();
     int64_t outputOperandIndex =
SmallVector<OpOperand *> getAliasingOpOperand(Operation *op,
                                                 OpResult opResult) const {
     // TODO: TiledLoopOp helper method to avoid leaking impl details.
     auto tiledLoopOp = cast<linalg::TiledLoopOp>(op);
     return {&op->getOpOperand(tiledLoopOp.getNumControlOperands() +
                               tiledLoopOp.getNumInputs() +
                               opResult.getResultNumber())};
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     auto tiledLoopOp = cast<linalg::TiledLoopOp>(op);
     return tiledLoopOp.getTiedOpResult(opOperand);
   }
 
   BufferRelation bufferRelation(Operation *op, OpOperand &opOperand) const {
     return BufferRelation::Equivalent;
   }
 
struct YieldOpInterface
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand) const {
     return false;
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     return OpResult();
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BlockAndValueMapping &bvm,
                           BufferizationAliasInfo &aliasInfo,
                           AllocationCallbacks &allocationFn) const {
     auto yieldOp = cast<linalg::YieldOp>(op);
struct ForOpInterface
   }
 
   SmallVector<OpOperand *> getAliasingOpOperand(Operation *op,
                                                 OpResult opResult) const {
     auto forOp = cast<scf::ForOp>(op);
     return {&forOp.getIterOpOperands()[opResult.getResultNumber()]};
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     auto forOp = cast<scf::ForOp>(op);
     if (!opOperand.get().getType().isa<RankedTensorType>())
       return OpResult();
     return forOp.getResultForOpOperand(opOperand);
   }
 
   BufferRelation bufferRelation(Operation *op, OpOperand &opOperand) const {
     return BufferRelation::Equivalent;
struct YieldOpInterface
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand) const {
     // scf::YieldOp does usually not bufferize to a memory write. However, there
     // is a special rule for IfOps. The aliasing OpOperand of an IfOp is the
     // YieldOp's OpOperand. For analysis purposes, IfOps are considered to be
     // writing ops, so this method should return `true`.
     return isa<scf::IfOp>(op->getParentOp());
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     return OpResult();
   }
 
   BufferRelation bufferRelation(Operation *op, OpOperand &opOperand) const {
     return BufferRelation::Equivalent;
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
struct CallOpInterface
   }
 
   SmallVector<OpOperand *> getAliasingOpOperand(Operation *op,
                                                 OpResult opResult) const {
     // TODO: Can we do better?
     return {};
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     // CallOpInterface is special, it needs to wait for the callee to be
     // bufferized and needs to inspect the BufferAliasInfo object. It can't
     // make a proper determination by itself and needs to be conservative.
     return OpResult();
   }
 
   BufferRelation bufferRelation(Operation *op, OpOperand &opOperand) const {
     return BufferRelation::Equivalent;
struct ReturnOpInterface
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand) const {
     return false;
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     return OpResult();
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BlockAndValueMapping &bvm,
                           BufferizationAliasInfo &aliasInfo,
                           AllocationCallbacks &allocationFn) const {
     auto returnOp = cast<ReturnOp>(op);
struct CastOpInterface
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand) const {
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand) const {
     return false;
   }
 
-  bool bufferizesToAliasOnly(Operation *op, OpOperand &opOperand) const {
-    return true;
-  }
-
   SmallVector<OpOperand *> getAliasingOpOperand(Operation *op,
                                                 OpResult opResult) const {
     return {&op->getOpOperand(0)};
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
-    return OpResult();
-  }
-
   OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     return op->getResult(0);
   }
 
   BufferRelation bufferRelation(Operation *op, OpOperand &opOperand) const {
     return BufferRelation::Equivalent;
   }
 
struct DimOpInterface
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand) const {
     return false;
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     return OpResult();
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BlockAndValueMapping &bvm,
                           BufferizationAliasInfo &aliasInfo,
                           AllocationCallbacks &allocationFn) const {
     auto dimOp = cast<tensor::DimOp>(op);
struct ExtractSliceOpInterface
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand) const {
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand) const {
     return false;
   }
 
-  bool bufferizesToAliasOnly(Operation *op, OpOperand &opOperand) const {
-    return true;
-  }
-
   SmallVector<OpOperand *> getAliasingOpOperand(Operation *op,
                                                 OpResult opResult) const {
     return {&op->getOpOperand(0) /*source*/};
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
-    return OpResult();
-  }
-
   OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     return &opOperand == &op->getOpOperand(0) /*source*/
                ? op->getResult(0)
                : OpResult();
   }
 
   BufferRelation bufferRelation(Operation *op, OpOperand &opOperand) const {
     return BufferRelation::None;
struct ExtractOpInterface
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand) const {
     return false;
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     return OpResult();
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BlockAndValueMapping &bvm,
                           BufferizationAliasInfo &aliasInfo,
                           AllocationCallbacks &allocationFn) const {
     auto extractOp = cast<tensor::ExtractOp>(op);
bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand) const {
     return &opOperand == &op->getOpOperand(1) /*dest*/;
   }
 
   SmallVector<OpOperand *> getAliasingOpOperand(Operation *op,
                                                 OpResult opResult) const {
     return {&op->getOpOperand(1) /*dest*/};
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     return &opOperand == &op->getOpOperand(1) /*dest*/
                ? op->getResult(0)
                : OpResult();
   }
 
   BufferRelation bufferRelation(Operation *op, OpOperand &opOperand) const {
     return BufferRelation::Equivalent;
   }
struct TransferReadOpInterface
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand) const {
     assert(opOperand.get().getType().isa<RankedTensorType>() &&
            "only tensor types expected");
     return false;
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     return OpResult();
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BlockAndValueMapping &bvm,
                           BufferizationAliasInfo &aliasInfo,
                           AllocationCallbacks &allocationFn) const {
     auto transferReadOp = cast<vector::TransferReadOp>(op);
bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand) const {
     return true;
   }
 
   SmallVector<OpOperand *> getAliasingOpOperand(Operation *op,
                                                 OpResult opResult) const {
     return {&op->getOpOperand(1)};
   }
 
-  OpResult getInplaceableOpResult(Operation *op, OpOperand &opOperand) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand) const {
     assert(opOperand.get().getType().isa<TensorType>() &&
            "only tensor types expected");
     return op->getOpResult(0);
   }
 
   BufferRelation bufferRelation(Operation *op, OpOperand &opOperand) const {
     return BufferRelation::Equivalent;
   }