[mlir][bufferization] Generalize getAliasingOpResults to getAliasingValues

[springerm]

Summary

This revision is needed to support bufferization of cf.br/cf.cond_br. It will also be useful for better analysis of loop ops.

This revision generalizes getAliasingOpResults to getAliasingValues. An OpOperand can now not only alias with OpResults but also with BlockArguments. In the case of cf.br (will be added in a later revision): a cf.br operand will alias with the corresponding argument of the destination block.

If an op does not implement the BufferizableOpInterface, the analysis in conservative. It previously assumed that an OpOperand may alias with each OpResult. It now assumes that an OpOperand may alias with each OpResult and each BlockArgument of the entry block.

Depends On: D157893

[maerhart]

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

32

"that"?

227

"Values"

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

1059

Shouldn't we also assume each block argument of each successor may also alias (also in above function)? Or are you planning to add this in a follow-up revision?

[springerm]

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

1059

I'm going to add that in a subsequent change.

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

AliasingOpOperand(OpOperand *opOperand, BufferRelation relation,
                     bool isDefinite = true)
       : opOperand(opOperand), relation(relation), isDefinite(isDefinite) {}
 
   OpOperand *opOperand;
   BufferRelation relation;
   bool isDefinite;
 };
 
-/// A maybe aliasing OpResult. If `isDefinite` is `true`, the OpResult is
-/// guaranteed to alias at runtime.
-struct AliasingOpResult {
-  AliasingOpResult(OpResult opResult, BufferRelation relation,
-                   bool isDefinite = true)
-      : opResult(opResult), relation(relation), isDefinite(isDefinite) {}
+/// A maybe aliasing Value. If `isDefinite` is `true`, the Value is guaranteed
+/// to alias at runtime.
+struct AliasingValue {
+  AliasingValue(Value value, BufferRelation relation, bool isDefinite = true)
+      : value(value), relation(relation), isDefinite(isDefinite) {}
 
-  OpResult opResult;
+  Value value;
   BufferRelation relation;
   bool isDefinite;
 };
 
 template <typename T> class AliasList {
 public:
   /// Create an empty list of aliases.
   AliasList() = default;
public:
   auto end() const { return aliases.end(); }
 
 private:
   /// The list of aliases.
   SmallVector<T> aliases;
 };
 
 /// A list of possible aliasing OpOperands. This list models the runtime
-/// aliasing relationship for an OpResult.
+/// aliasing relationship for a Value.
 using AliasingOpOperandList = AliasList<AliasingOpOperand>;
 
-/// A list of possible aliasing OpResults. This list models the runtime
-/// aliasing relationship for an OpOperand.
-using AliasingOpResultList = AliasList<AliasingOpResult>;
+/// A list of possible aliasing Values. This list models the runtime aliasing
+/// relationship for an OpOperand.
+using AliasingValueList = AliasList<AliasingValue>;
 
 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 TraversalConfig {
   /// of a CastOpInterface op should be followed.
   bool followSameTypeOrCastsOnly = false;
 };
 
 /// AnalysisState provides a variety of helper functions for dealing with
 /// tensor values.
 class AnalysisState {
 public:
-  /// Determine which OpOperand* will alias with `result` if the op is
+  /// Determine which OpOperand* will alias with `value` if the op is
   /// bufferized in place. Return all tensor OpOperand* if the op is not
   /// bufferizable.
-  AliasingOpOperandList getAliasingOpOperands(OpResult result) const;
+  AliasingOpOperandList getAliasingOpOperands(Value value) 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.
-  AliasingOpResultList getAliasingOpResults(OpOperand &opOperand) const;
+  /// Determine which Value will alias with `opOperand` if the op is bufferized
+  /// in place. Return all tensor Values if the op is not bufferizable.
+  AliasingValueList getAliasingValues(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;

 /// repetitive region.
 Region *getNextEnclosingRepetitiveRegion(Region *region,
                                          const BufferizationOptions &options);
 
 namespace detail {
 /// This is the default implementation of
 /// BufferizableOpInterface::getAliasingOpOperands. Should not be called from
 /// other places.
-AliasingOpOperandList defaultGetAliasingOpOperands(OpResult opResult,
+AliasingOpOperandList defaultGetAliasingOpOperands(Value value,
                                                    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 getAliasingOpOperands in case the
 /// defining op does not implement the BufferizableOpInterface.
-AliasingOpOperandList unknownGetAliasingOpOperands(OpResult opResult);
+AliasingOpOperandList unknownGetAliasingOpOperands(Value value);
 
-/// This is the default implementation of getAliasingOpResults in case the
-/// owner op does not implement the BufferizableOpInterface.
-AliasingOpResultList unknownGetAliasingOpResults(OpOperand &opOperand);
+/// This is the default implementation of getAliasingValues in case the owner
+/// op does not implement the BufferizableOpInterface.
+AliasingValueList unknownGetAliasingValues(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

 
 def BufferizableOpInterface : OpInterface<"BufferizableOpInterface"> {
   let description = [{
     An op interface for One-Shot Bufferize. Ops that implement this interface
     interface can be analyzed and bufferized using One-Shot Bufferize.
 
     Note: All "bufferizesTo*" and "getAliasing*" interface methods must be
     implemented conservatively. If it is not statically known whether an
-    OpOperand/OpResult bufferizes in a certain way (e.g., to a memory write),
+    OpOperand/Value bufferizes in a certain way (e.g., to a memory write),
     the worst case must be assumed (e.g., that it does). Similarly,
     "getAliasing*" interface methods may always return additional OpOperands or
-    OpResults, but must not miss an OpOperand or OpResult that could potentially
+    Values, but must not miss an OpOperand or Value that could potentially
     alias at runtime.
   }];
   let cppNamespace = "::mlir::bufferization";
   let methods = [
       InterfaceMethod<
         /*desc=*/[{
-          Return `true` if the given OpResult may bufferize to a new buffer
-          allocation. If it is statically unknown if the given OpResult
+          Return `true` if the given Value may bufferize to a new buffer
+          allocation. If it is statically unknown that the given Value
           bufferizes to a buffer allocation, `true` should be returned.
         }],
         /*retType=*/"bool",
         /*methodName=*/"bufferizesToAllocation",
-        /*args=*/(ins "::mlir::OpResult":$opResult),
+        /*args=*/(ins "::mlir::Value":$value),
         /*methodBody=*/"",
         /*defaultImplementation=*/"return false;"
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return `true` if the given OpOperand bufferizes to a memory read. This
           method will never be called on OpOperands that do not have a tensor
           type.
let methods = [
       InterfaceMethod<
         /*desc=*/[{
           Return `true` if the given OpOperand bufferizes to a memory write.
 
           This method will never be called on OpOperands that do not have a
           tensor type.
 
           This method will never be called on OpOperands that do not have an
-          aliasing OpResult. Intuitively, it does not make sense for an
-          OpOperand to bufferize to a memory write without returning an aliasing
-          tensor, because the write would have no visible effect outside of the
-          op.
+          aliasing Value. Intuitively, it does not make sense for an OpOperand
+          to bufferize to a memory write without returning an aliasing tensor,
+          because the write would have no visible effect outside of the op.
 
           Note: It is always safe to consider an OpOperand as a memory write,
           even if it does actually not write; however, this can introduce
           unnecessary out-of-place bufferization decisions. One-Shot Analysis
           considers OpOperands of unknown ops (that do not implement this
           interface) as writing OpOperands.
         }],
         /*retType=*/"bool",
         /*methodName=*/"bufferizesToMemoryWrite",
         /*args=*/(ins "::mlir::OpOperand &":$opOperand,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           // Does not have to be implemented for ops without tensor OpOperands.
           // Does not have to be implemented for OpOperands that do not have an
-          // aliasing OpResult.
+          // aliasing Value.
           llvm_unreachable("bufferizesToMemoryWrite not implemented");
          }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return `true` if the operation bufferizes to IR that performs only
           element-wise accesses on all tensor operands. (All operands must have
           the same shape.) The `bufferize` method must be implemented in such a
let methods = [
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           return ::llvm::isa<::mlir::UnrankedTensorType>(opOperand.get().getType());
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
-          Return the OpResults that may alias with a given OpOperand when
+          Return the Values 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.
 
-          This method can return multiple OpResults, indicating that a given
+          This method can return multiple Values, indicating that a given
           OpOperand may at runtime alias with any (or multiple) of the returned
-          OpResults.
+          Values.
 
           Each alias is specified with a degree of certainty:
 
           * MAYBE (`isDefinite = false`): At runtime, buffer(opOperand) may
-            alias with the specified OpResult.
+            alias with the specified Value.
           * DEFINITE (`isDefinite = true`, default): At runtime,
             buffer(opOperand) is guaranteed to alias the buffer of the specified
-            OpResult. This is a stronger property than MAYBE and allows for more
+            Value. This is a stronger property than MAYBE and allows for more
             precise analyses. DEFINITE properties should be used when possible.
 
           Furthermore, each alias is specified with a buffer relation:
 
           * `BufferRelation::Equivalent`: Both aliases are the exact same
             buffer. I.e., same size, no offset, same strides.
           * `BufferRelation::Unknown`: There is no further information apart
             from the fact that both buffers alias.
 
-          False positives are allowed in the list of OpResults, but they can
+          False positives are allowed in the list of Values, 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 with
+          that is always safe, is to return all tensor Values with
           BufferRelation::Unknown and MAYBE.
 
           Examples:
 
           ```
-          // aliasingOpResults(%t) = DEFINITE {Equivalent %r}
+          // aliasingValues(%t) = DEFINITE {Equivalent %r}
           %r = tensor.insert_slice %f into %t : tensor<10xf32>
 
-          // aliasingOpResults(%t) = DEFINITE {Unknown %r}
+          // aliasingValues(%t) = DEFINITE {Unknown %r}
           // Note: "Buffer is subset of buffer" relationship are not yet
           // supported, so "Unknown" is the best we can do for now.
           %r = tensor.extract_slice %t[0]][5][1]
               : tensor<10xf32> to tensor<5xf32>
 
-          // aliasingOpResults(%t1) = MAYBE {Equivalent %r}
-          // aliasingOpResults(%t2) = MAYBE {Equivalent %r}
+          // aliasingValues(%t1) = MAYBE {Equivalent %r}
+          // aliasingValues(%t2) = MAYBE {Equivalent %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) = MAYBE {Equivalent %r}
+          // aliasingValues(%t) = MAYBE {Equivalent %r}
           %r = "dummy.alias_or_copy(%t) : (tensor<10xf32>) -> (tensor<10xf32>)"
           ```
         }],
-        /*retType=*/"::mlir::bufferization::AliasingOpResultList",
-        /*methodName=*/"getAliasingOpResults",
+        /*retType=*/"::mlir::bufferization::AliasingValueList",
+        /*methodName=*/"getAliasingValues",
         /*args=*/(ins "::mlir::OpOperand &":$opOperand,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           // Does not have to be implemented for ops without tensor OpOperands.
           assert(::llvm::isa<::mlir::TensorType>(opOperand.get().getType()) &&
                  "expected OpOperand with tensor type");
-          llvm_unreachable("getAliasingOpResults not implemented");
+          llvm_unreachable("getAliasingValues 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.
+          Return the OpOperands that alias with a given Value when bufferized
+          in-place. This method will never be called on Values that do not
+          have a tensor type.
 
-          By default, this method is the inverse of `getAliasingOpResults`. Ops
+          By default, this method is the inverse of `getAliasingValues`. Ops
           with a region that yield values may want to override this method to
           return the OpOperands that are yielded by the terminator.
 
           This method can return multiple OpOperands, indicating that a given
-          OpResult may at runtime alias with any (or multiple) of the returned
+          Value may at runtime alias with any (or multiple) of the returned
           OpOperands.
 
           This property is specified with a degree of certainty:
 
-          * MAYBE (`isDefinite = false`): At runtime, buffer(opResult) may
-            alias with the specified OpOperand.
+          * MAYBE (`isDefinite = false`): At runtime, buffer(value) may alias
+            with the specified OpOperand.
           * DEFINITE (`isDefinite = true`, default): At runtime,
-            buffer(opResult) is guaranteed to alias the buffer of the specified
+            buffer(value) is guaranteed to alias the buffer of the specified
             OpOperand. This is a stronger property than MAYBE and allows for
             more precise analyses. DEFINITE properties should be used when
             possible.
 
           For each alias, a BufferRelation can be specified:
 
           * `BufferRelation::Equivalent`: Both aliases are the exact same
             buffer. I.e., same size, no offset, same strides.
let methods = [
           %r = arith.select %c, %t1, %t2 : tensor<10xf32>
 
           // aliasingOpOperands(%r) = MAYBE {}
           %r = tensor.empty() : tensor<10xf32>
           ```
         }],
         /*retType=*/"::mlir::bufferization::AliasingOpOperandList",
         /*methodName=*/"getAliasingOpOperands",
-        /*args=*/(ins "::mlir::OpResult":$opResult,
+        /*args=*/(ins "::mlir::Value":$value,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
-          assert(::llvm::isa<::mlir::TensorType>(opResult.getType()) &&
-                 "expected OpResult with tensor type");
+          assert(isa<::mlir::TensorType>(value.getType()) &&
+                 "expected tensor type");
           return ::mlir::bufferization::detail::defaultGetAliasingOpOperands(
-              opResult, state);
+              value, state);
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Resolve all inplacability conflicts by inserting explicit
           `bufferization.alloc_tensor` ops. Examples of inplacability conflicts
           are read-after-write conflicts or writes into non-writable buffers.
 
let extraClassDeclaration = [{
     /// Examples of such ops are `tensor.extract_slice` and `tensor.cast`.
     bool bufferizesToAliasOnly(
         ::mlir::OpOperand &opOperand,
         const ::mlir::bufferization::AnalysisState &state) {
       auto bufferizableOp =
           ::llvm::cast<::mlir::bufferization::BufferizableOpInterface>(getOperation());
       return !bufferizableOp.bufferizesToMemoryRead(opOperand, state)
           && !bufferizableOp.bufferizesToMemoryWrite(opOperand, state)
-          && bufferizableOp.getAliasingOpResults(opOperand, state)
+          && bufferizableOp.getAliasingValues(opOperand, state)
               .getNumAliases() != 0;
     }
   }];
 }
 
 #endif  // BUFFERIZABLE_OP_INTERFACE

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

def Bufferization_AllocTensorOp : Bufferization_Op<"alloc_tensor",
 
   let extraClassDeclaration = [{
     LogicalResult bufferize(RewriterBase &rewriter,
                             const BufferizationOptions &options);
 
     bool resultBufferizesToMemoryWrite(OpResult opResult,
                                        const AnalysisState &state);
 
-    bool bufferizesToAllocation(OpResult opResult) { return true; }
+    bool bufferizesToAllocation(Value value) { return true; }
 
     bool bufferizesToMemoryRead(OpOperand &opOperand,
                                 const AnalysisState &state);
 
     bool bufferizesToMemoryWrite(OpOperand &opOperand,
                                  const AnalysisState &state);
 
-    AliasingOpResultList getAliasingOpResults(
+    AliasingValueList getAliasingValues(
         OpOperand &opOperand, const AnalysisState &state);
 
     FailureOr<BaseMemRefType> getBufferType(
         Value value, const BufferizationOptions &options,
         const DenseMap<Value, BaseMemRefType> &fixedTypes);
 
     RankedTensorType getType() {
       return ::llvm::cast<RankedTensorType>(getResult().getType());
LogicalResult bufferize(RewriterBase &rewriter,
                             const BufferizationOptions &options);
 
     bool bufferizesToMemoryRead(OpOperand &opOperand,
                                 const AnalysisState &state);
 
     bool bufferizesToMemoryWrite(OpOperand &opOperand,
                                  const AnalysisState &state);
 
-    AliasingOpResultList getAliasingOpResults(
+    AliasingValueList getAliasingValues(
         OpOperand &opOperand, const AnalysisState &state);
 
     RankedTensorType getType() {
       return ::llvm::cast<RankedTensorType>(getResult().getType());
     }
   }];
 
   let assemblyFormat = "$source `,` $dest attr-dict `:` type($source)";
bool bufferizesToMemoryRead(OpOperand &opOperand,
       return false;
     }
 
     bool bufferizesToMemoryWrite(OpOperand &opOperand,
                                  const AnalysisState &state) const {
       return false;
     }
 
-    AliasingOpResultList getAliasingOpResults(
+    AliasingValueList getAliasingValues(
         OpOperand &opOperand, const AnalysisState &state) const {
       return {};
     }
 
     LogicalResult bufferize(RewriterBase &rewriter,
                             const BufferizationOptions &options);
   }];
 }
bool bufferizesToMemoryRead(OpOperand &opOperand,
       return true;
     }
 
     bool bufferizesToMemoryWrite(OpOperand &opOperand,
                                  const AnalysisState &state) {
       return !getReadOnly();
     }
 
-    AliasingOpResultList getAliasingOpResults(
+    AliasingValueList getAliasingValues(
         OpOperand &opOperand, const AnalysisState &state) const {
       return {};
     }
 
     LogicalResult bufferize(RewriterBase &rewriter,
                             const BufferizationOptions &options);
   }];
 

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);
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     // Output operands alias with their respective tied OpResults.
     auto dstOp = cast<DestinationStyleOpInterface>(op);
     if (dstOp.isDpsInit(&opOperand))
       return {{dstOp.getTiedOpResult(&opOperand), BufferRelation::Equivalent}};
     return {};
   }
 };
 
 } // namespace bufferization
 } // namespace mlir
 
 #endif // MLIR_DIALECT_BUFFERIZATION_IR_DSTBUFFERIZABLEOPINTERFACEIMPL_H_

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;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {{op->getResult(0), BufferRelation::Equivalent}};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto castOp = cast<arith::IndexCastOp>(op);
     auto resultTensorType = cast<TensorType>(castOp.getType());
 
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {{op->getOpResult(0) /*result*/, BufferRelation::Equivalent,
              /*isDefinite=*/false}};
   }
 
   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

 
 LogicalResult BufferizableOpInterface::resolveTensorOpOperandConflicts(
     RewriterBase &rewriter, const AnalysisState &state) {
   OpBuilder::InsertionGuard g(rewriter);
   Operation *op = getOperation();
   SmallVector<OpOperand *> outOfPlaceOpOperands;
   DenseSet<OpOperand *> copiedOpOperands;
   DenseSet<OpOperand *> escapingOpOperandCopies;
-  SmallVector<OpResult> outOfPlaceOpResults;
-  DenseSet<OpResult> copiedOpResults;
-  DenseSet<OpResult> escapingOpResultCopies;
+  SmallVector<Value> outOfPlaceValues;
+  DenseSet<Value> copiedOpValues;
+  DenseSet<Value> escapingValueCopies;
 
   // Find all out-of-place OpOperands.
   for (OpOperand &opOperand : op->getOpOperands()) {
     Type operandType = opOperand.get().getType();
     if (!llvm::isa<TensorType>(operandType))
       continue;
     if (state.isInPlace(opOperand))
       continue;
     if (llvm::isa<UnrankedTensorType>(operandType))
       return op->emitError("copying of unranked tensors is not implemented");
 
-    AliasingOpResultList aliasingOpResults =
-        state.getAliasingOpResults(opOperand);
+    AliasingValueList aliasingValues = state.getAliasingValues(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, [&](AliasingOpResult a) {
-                    return state.isTensorYielded(a.opResult);
+                  llvm::any_of(aliasingValues, [&](AliasingValue a) {
+                    return state.isTensorYielded(a.value);
                   });
 
-    if (aliasingOpResults.getNumAliases() == 1 &&
+    if (aliasingValues.getNumAliases() == 1 &&
         !state.bufferizesToMemoryWrite(opOperand) &&
-        state.getAliasingOpOperands(aliasingOpResults.getAliases()[0].opResult)
+        state.getAliasingOpOperands(aliasingValues.getAliases()[0].value)
                 .getNumAliases() == 1 &&
-        !llvm::isa<UnrankedTensorType>(
-            aliasingOpResults.getAliases()[0].opResult.getType())) {
+        !isa<UnrankedTensorType>(
+            aliasingValues.getAliases()[0].value.getType())) {
       // 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).
-      OpResult opResult = aliasingOpResults.getAliases()[0].opResult;
-      outOfPlaceOpResults.push_back(opResult);
+      Value value = aliasingValues.getAliases()[0].value;
+      outOfPlaceValues.push_back(value);
       if (!state.canOmitTensorCopy(opOperand))
-        copiedOpResults.insert(opResult);
+        copiedOpValues.insert(value);
       if (escape)
-        escapingOpResultCopies.insert(opResult);
+        escapingValueCopies.insert(value);
     } else {
       // In all other cases, make a copy of the OpOperand.
       outOfPlaceOpOperands.push_back(&opOperand);
       if (!state.canOmitTensorCopy(opOperand))
         copiedOpOperands.insert(&opOperand);
       if (escape)
         escapingOpOperandCopies.insert(&opOperand);
     }
   }
 
   // Insert copies of OpOperands.
   rewriter.setInsertionPoint(op);
   for (OpOperand *opOperand : outOfPlaceOpOperands) {
     FailureOr<Value> copy = allocateTensorForShapedValue(
         rewriter, op->getLoc(), opOperand->get(),
         escapingOpOperandCopies.contains(opOperand), state.getOptions(),
         copiedOpOperands.contains(opOperand));
     if (failed(copy))
       return failure();
     rewriter.updateRootInPlace(op, [&]() { opOperand->set(*copy); });
   }
 
-  // Insert copies of OpResults.
+  // Insert copies of Values.
   rewriter.setInsertionPointAfter(op);
-  for (OpResult opResult : outOfPlaceOpResults) {
+  for (Value value : outOfPlaceValues) {
     FailureOr<Value> copy = allocateTensorForShapedValue(
-        rewriter, op->getLoc(), opResult,
-        escapingOpResultCopies.contains(opResult), state.getOptions(),
-        copiedOpResults.count(opResult));
+        rewriter, op->getLoc(), value, escapingValueCopies.contains(value),
+        state.getOptions(), copiedOpValues.count(value));
     if (failed(copy))
       return failure();
-    SmallVector<OpOperand *> uses = llvm::to_vector(llvm::map_range(
-        opResult.getUses(), [](OpOperand &use) { return &use; }));
+    SmallVector<OpOperand *> uses = llvm::to_vector(
+        llvm::map_range(value.getUses(), [](OpOperand &use) { return &use; }));
     for (OpOperand *use : uses) {
       // Do not update the alloc_tensor op that we just created.
       if (use->getOwner() == copy->getDefiningOp())
         continue;
       // tensor.dim ops may have been created to be used as alloc_tensor op
       // dynamic extents. Do not update these either.
       if (isa<tensor::DimOp>(use->getOwner()))
         continue;

 static void setInsertionPointAfter(OpBuilder &b, Value value) {
   if (auto bbArg = llvm::dyn_cast<BlockArgument>(value)) {
     b.setInsertionPointToStart(bbArg.getOwner());
   } 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.
-AliasingOpOperandList
-AnalysisState::getAliasingOpOperands(OpResult opResult) const {
-  if (Operation *op = opResult.getDefiningOp())
+/// Determine which OpOperand* will alias with `value` if the op is bufferized
+/// in place. Return all tensor OpOperand* if the op is not bufferizable.
+AliasingOpOperandList AnalysisState::getAliasingOpOperands(Value value) const {
+  if (Operation *op = getOwnerOfValue(value))
     if (auto bufferizableOp = getOptions().dynCastBufferizableOp(op))
-      return bufferizableOp.getAliasingOpOperands(opResult, *this);
+      return bufferizableOp.getAliasingOpOperands(value, *this);
 
   // The op is not bufferizable.
-  return detail::unknownGetAliasingOpOperands(opResult);
+  return detail::unknownGetAliasingOpOperands(value);
 }
 
-/// Determine which OpResult will alias with `opOperand` if the op is bufferized
-/// in place. Return all tensor OpResults if the op is not bufferizable.
-AliasingOpResultList
-AnalysisState::getAliasingOpResults(OpOperand &opOperand) const {
+/// Determine which Values will alias with `opOperand` if the op is bufferized
+/// in place. Return all tensor Values if the op is not bufferizable.
+AliasingValueList AnalysisState::getAliasingValues(OpOperand &opOperand) const {
   if (auto bufferizableOp =
           getOptions().dynCastBufferizableOp(opOperand.getOwner()))
-    return bufferizableOp.getAliasingOpResults(opOperand, *this);
+    return bufferizableOp.getAliasingValues(opOperand, *this);
 
   // The op is not bufferizable.
-  return detail::unknownGetAliasingOpResults(opOperand);
+  return detail::unknownGetAliasingValues(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 (AliasingOpResult alias : getAliasingOpResults(*uMaybeReading))
-        for (OpOperand &use : alias.opResult.getUses())
+      for (AliasingValue alias : getAliasingValues(*uMaybeReading))
+        for (OpOperand &use : alias.value.getUses())
           workingSet.push_back(&use);
     if (bufferizesToMemoryRead(*uMaybeReading))
       return true;
   }
 
   return false;
 }
 
llvm::SetVector<Value> AnalysisState::findValueInReverseUseDefChain(
 
   while (!workingSet.empty()) {
     Value value = workingSet.pop_back_val();
     if (condition(value)) {
       result.insert(value);
       continue;
     }
 
-    if (llvm::isa<BlockArgument>(value)) {
-      if (config.alwaysIncludeLeaves)
-        result.insert(value);
-      continue;
-    }
-
-    OpResult opResult = llvm::cast<OpResult>(value);
-    BufferizableOpInterface bufferizableOp =
-        options.dynCastBufferizableOp(opResult.getDefiningOp());
-    if (!config.followUnknownOps && !bufferizableOp) {
+    if (!config.followUnknownOps && !options.dynCastBufferizableOp(value)) {
       // Stop iterating if `followUnknownOps` is unset and the op is either
       // not bufferizable or excluded in the OpFilter.
       if (config.alwaysIncludeLeaves)
         result.insert(value);
       continue;
     }
 
-    AliasingOpOperandList aliases = getAliasingOpOperands(opResult);
+    AliasingOpOperandList aliases = getAliasingOpOperands(value);
     if (aliases.getNumAliases() == 0) {
       // The traversal ends naturally if there are no more OpOperands that
       // could be followed.
       if (config.alwaysIncludeLeaves)
         result.insert(value);
       continue;
     }
 
for (AliasingOpOperand a : aliases) {
         // out-of-place.
         if (config.alwaysIncludeLeaves)
           result.insert(value);
         continue;
       }
 
       if (config.followSameTypeOrCastsOnly &&
           a.opOperand->get().getType() != value.getType() &&
-          !opResult.getDefiningOp<CastOpInterface>()) {
+          !value.getDefiningOp<CastOpInterface>()) {
         // Stop iterating if `followSameTypeOrCastsOnly` is set but the alias is
         // has a different type and the op is not a cast.
         if (config.alwaysIncludeLeaves)
           result.insert(value);
         continue;
       }
 
       workingSet.insert(a.opOperand->get());
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.
-  AliasingOpResultList aliases = getAliasingOpResults(opOperand);
+  AliasingValueList aliases = getAliasingValues(opOperand);
   if (!bufferizesToMemoryRead(opOperand) &&
-      llvm::none_of(
-          aliases, [&](AliasingOpResult a) { return isValueRead(a.opResult); }))
+      llvm::none_of(aliases,
+                    [&](AliasingValue a) { return isValueRead(a.value); }))
     return true;
 
   // Default: Cannot omit the copy.
   return false;
 }
 
 bool AnalysisState::isInPlace(OpOperand &opOperand) const {
   // ToMemrefOps are always in-place.
while (!worklist.empty()) {
     // assume that the value is yielded.
     if (isa<ToMemrefOp>(op))
       return true;
 
     // Check if the op is returning/yielding.
     if (isa<RegionBranchTerminatorOpInterface>(op))
       return true;
 
-    // Add all aliasing OpResults to the worklist.
+    // Add all aliasing Values 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 (AliasingOpResult alias : getAliasingOpResults(*operand))
-      for (OpOperand &use : alias.opResult.getUses())
+    // no function call analysis information), this `getAliasingValues` is
+    // conservative and may report additional Values as potentially aliasing.
+    for (AliasingValue alias : getAliasingValues(*operand))
+      for (OpOperand &use : alias.value.getUses())
         worklist.push_back(&use);
   }
 
   // No ReturnLike op found: The value is not yielded.
   return false;
 }
 
 // bufferization.to_memref is not allowed to change the rank.
if (!state
              .findValueInReverseUseDefChain(alias.opOperand->get(),
                                             isMemoryWriteInsideOp, config)
              .empty())
       return true;
   }
   return false;
 }
 
-// Compute the AliasingOpOperandList for a given OpResult based on
-// getAliasingOpResults.
+// Compute the AliasingOpOperandList for a given Value based on
+// getAliasingValues.
 AliasingOpOperandList bufferization::detail::defaultGetAliasingOpOperands(
-    OpResult opResult, const AnalysisState &state) {
-  Operation *op = opResult.getDefiningOp();
+    Value value, const AnalysisState &state) {
+  Operation *op = getOwnerOfValue(value);
   SmallVector<AliasingOpOperand> result;
   for (OpOperand &opOperand : op->getOpOperands()) {
     if (!llvm::isa<TensorType>(opOperand.get().getType()))
       continue;
-    AliasingOpResultList aliasingOpResults =
-        state.getAliasingOpResults(opOperand);
-    for (const auto &it : aliasingOpResults)
-      if (it.opResult == opResult)
+    AliasingValueList aliasingValues = state.getAliasingValues(opOperand);
+    for (const auto &it : aliasingValues)
+      if (it.value == value)
         result.emplace_back(&opOperand, it.relation, it.isDefinite);
   }
   return AliasingOpOperandList(std::move(result));
 }
 
 FailureOr<BaseMemRefType> bufferization::detail::defaultGetBufferType(
     Value value, const BufferizationOptions &options,
     const DenseMap<Value, BaseMemRefType> &fixedTypes) {
bool bufferization::detail::defaultIsRepetitiveRegion(
   auto regionInterface =
       dyn_cast<RegionBranchOpInterface>(bufferizableOp.getOperation());
   if (!regionInterface)
     return false;
   return regionInterface.isRepetitiveRegion(index);
 }
 
 AliasingOpOperandList
-bufferization::detail::unknownGetAliasingOpOperands(OpResult opResult) {
-  // Conservatively assume that everything may be aliasing.
+bufferization::detail::unknownGetAliasingOpOperands(Value value) {
+  // TODO: Take into account successor blocks.
+  // No aliasing in case of non-entry blocks.
+  if (auto bbArg = dyn_cast<BlockArgument>(value))
+    if (bbArg.getOwner() != &bbArg.getOwner()->getParent()->getBlocks().front())
+      return {};
+
+  // Unknown op: Conservatively assume that each OpResult may alias with every
+  // OpOperand. In addition, each block argument of an entry block may alias
+  // with every OpOperand.
   AliasingOpOperandList r;
-  for (OpOperand &operand : opResult.getDefiningOp()->getOpOperands())
-    if (llvm::isa<TensorType>(operand.get().getType()))
+  for (OpOperand &operand : value.getDefiningOp()->getOpOperands())
+    if (isa<TensorType>(operand.get().getType()))
       r.addAlias({&operand, BufferRelation::Unknown, /*isDefinite=*/false});
   return r;
 }
 
-AliasingOpResultList
-bufferization::detail::unknownGetAliasingOpResults(OpOperand &opOperand) {
-  // Conservatively assume that everything may be aliasing.
-  AliasingOpResultList r;
+AliasingValueList
+bufferization::detail::unknownGetAliasingValues(OpOperand &opOperand) {
+  // TODO: Take into account successor blocks.
+  // Unknown op: Conservatively assume that each OpResult may alias with every
+  // OpOperand. In addition, each block argument of an entry block may alias
+  // with every OpOperand.
+  AliasingValueList r;
   for (OpResult result : opOperand.getOwner()->getOpResults())
     if (llvm::isa<TensorType>(result.getType()))
       r.addAlias({result, BufferRelation::Unknown, /*isDefinite=*/false});
+  for (Region &region : opOperand.getOwner()->getRegions())
+    if (!region.getBlocks().empty())
+      for (BlockArgument bbArg : region.getBlocks().front().getArguments())
+        if (bbArg.getType().isa<TensorType>())
+          r.addAlias({bbArg, BufferRelation::Unknown, /*isDefinite=*/false});
   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;
 }
 
-AliasingOpResultList
-AllocTensorOp::getAliasingOpResults(OpOperand &opOperand,
+AliasingValueList AllocTensorOp::getAliasingValues(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");

 
 bool CopyTensorOp::bufferizesToMemoryWrite(OpOperand &opOperand,
                                            const AnalysisState &state) {
   if (&opOperand == &getOperation()->getOpOperand(1) /*dest*/)
     return true;
   return false;
 }
 
-AliasingOpResultList
-CopyTensorOp::getAliasingOpResults(OpOperand &opOperand,
+AliasingValueList CopyTensorOp::getAliasingValues(OpOperand &opOperand,
                                                   const AnalysisState &state) {
   if (&opOperand == &getOperation()->getOpOperand(1) /*dest*/)
     return {{getOperation()->getResult(0), BufferRelation::Equivalent}};
   return {};
 }
 
 LogicalResult CopyTensorOp::bufferize(RewriterBase &rewriter,
                                       const BufferizationOptions &options) {
   FailureOr<Value> buffer = getBuffer(rewriter, getDest(), options);

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());
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     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::unknownGetAliasingOpResults(opOperand);
+      return detail::unknownGetAliasingValues(opOperand);
 
     // Get aliasing results from state.
     const FuncAnalysisState &funcState = getFuncAnalysisState(state);
     auto aliasingReturnVals =
         funcState.aliasingReturnVals.lookup(funcOp).lookup(
             opOperand.getOperandNumber());
 
     // Check if the aliasing OpResult is equivalent to the OpOperand.
     std::optional<int64_t> equivalent = {};
     if (aliasingReturnVals.size() == 1) {
       equivalent = getEquivalentFuncArgIdx(funcOp, funcState,
                                            aliasingReturnVals.front());
       assert((!equivalent.has_value() ||
               *equivalent == opOperand.getOperandNumber()) &&
              "inconsistent analysis state");
     }
-    AliasingOpResultList result;
+    AliasingValueList result;
     for (int64_t resultIdx : aliasingReturnVals)
       result.addAlias({callOp->getOpResult(resultIdx),
                        equivalent.has_value() ? BufferRelation::Equivalent
                                               : BufferRelation::Unknown,
                        /*isDefinite=*/equivalent.has_value()});
     return result;
   }
 
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
 #ifndef NDEBUG
     auto returnOp = cast<func::ReturnOp>(op);
     assert(isa<FuncOp>(returnOp->getParentOp()) &&

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

 // in OneShotBufferizationState. When run with `testAnalysisOnly`, the IR is
 // annotated with the results of the analysis, so that they can be checked in
 // tests.
 //===----------------------------------------------------------------------===//
 
 /// Attribute marker to specify op operands that bufferize in-place.
 constexpr StringLiteral kInPlaceOperandsAttrName = "__inplace_operands_attr__";
 
-constexpr StringLiteral kAliasSetAttrName = "__alias_set_attr__";
+constexpr StringLiteral kOpResultAliasSetAttrName =
+    "__opresult_alias_set_attr__";
+
+constexpr StringLiteral kBbArgAliasSetAttrName = "__bbarg_alias_set_attr__";
 
 /// Mark whether OpOperand will be bufferized inplace.
 static void setInPlaceOpOperand(OpOperand &opOperand, bool inPlace) {
   Operation *op = opOperand.getOwner();
   SmallVector<StringRef> inPlaceVector;
   if (auto attr = op->getAttr(kInPlaceOperandsAttrName)) {
     inPlaceVector = SmallVector<StringRef>(llvm::to_vector<4>(
         cast<ArrayAttr>(attr).getAsValueRange<StringAttr>()));
bool OneShotAnalysisState::areAliasingBufferizedValues(Value v1,
                                                        Value v2) const {
   return aliasInfo.isEquivalent(v1, v2);
 }
 
 void OneShotAnalysisState::bufferizeInPlace(OpOperand &operand) {
   if (inplaceBufferized.contains(&operand))
     return;
   inplaceBufferized.insert(&operand);
-  for (AliasingOpResult alias : getAliasingOpResults(operand))
-    aliasInfo.unionSets(alias.opResult, operand.get());
+  for (AliasingValue alias : getAliasingValues(operand))
+    aliasInfo.unionSets(alias.value, operand.get());
   ++statNumTensorInPlace;
 }
 
 void OneShotAnalysisState::bufferizeOutOfPlace(OpOperand &operand) {
   assert(!inplaceBufferized.contains(&operand) &&
          "OpOperand was already decided to bufferize inplace");
   ++statNumTensorOutOfPlace;
 }
for (OpOperand &use : val.getUses())
       if (isInPlace(use) && bufferizesToMemoryWrite(use))
         isWritten = true;
   });
   return isWritten;
 }
 
 bool OneShotAnalysisState::isWritable(Value value) const {
   // TODO: Out-of-place bufferized value could be considered writable.
-  if (auto bufferizableOp = getOptions().dynCastBufferizableOp(value))
-    return bufferizableOp.isWritable(value, *this);
-
   // Query BufferizableOpInterface to see if the BlockArgument is writable.
-  if (auto bbArg = dyn_cast<BlockArgument>(value))
-    if (auto bufferizableOp =
-            getOptions().dynCastBufferizableOp(bbArg.getOwner()->getParentOp()))
-      return bufferizableOp.isWritable(bbArg, *this);
+          getOptions().dynCastBufferizableOp(getOwnerOfValue(value)))
+    return bufferizableOp.isWritable(value, *this);
 
   // Not a bufferizable op: The conservative answer is "not writable".
   return false;
 }
 
 void OneShotAnalysisState::unionAliasSets(Value v1, Value v2) {
   aliasInfo.unionSets(v1, v2);
 }
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.
-        AliasingOpResultList aliases =
-            state.getAliasingOpResults(*uConflictingWrite);
+        AliasingValueList aliases = state.getAliasingValues(*uConflictingWrite);
         if (aliases.getNumAliases() == 1 &&
-            aliases.getAliases()[0].opResult == definition) {
+            aliases.getAliases()[0].value == 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)) {
-        AliasingOpResultList aliases = state.getAliasingOpResults(use);
-        if (llvm::any_of(aliases, [&](AliasingOpResult a) {
-              return state.isValueRead(a.opResult);
+        AliasingValueList aliases = state.getAliasingValues(use);
+        if (llvm::any_of(aliases, [&](AliasingValue a) {
+              return state.isValueRead(a.value);
             }))
           res.insert(&use);
       }
     }
   });
 }
 
 /// Return true if bufferizing `operand` inplace would create a conflict. A read

 /// involving aliases of the given OpOperand are checked.
 static bool wouldCreateReadAfterWriteInterference(
     OpOperand &operand, const DominanceInfo &domInfo,
     OneShotAnalysisState &state, bool checkConsistencyOnly = false) {
   // Collect reads and writes of all aliases of OpOperand and OpResult.
   DenseSet<OpOperand *> usesRead, usesWrite;
   getAliasingReads(usesRead, operand.get(), state);
   getAliasingInplaceWrites(usesWrite, operand.get(), state);
-  for (AliasingOpResult alias : state.getAliasingOpResults(operand)) {
-    getAliasingReads(usesRead, alias.opResult, state);
-    getAliasingInplaceWrites(usesWrite, alias.opResult, state);
+  for (AliasingValue alias : state.getAliasingValues(operand)) {
+    getAliasingReads(usesRead, alias.value, state);
+    getAliasingInplaceWrites(usesWrite, alias.value, state);
   }
   if (!checkConsistencyOnly && state.bufferizesToMemoryWrite(operand))
     usesWrite.insert(&operand);
 
   return hasReadAfterWriteInterference(usesRead, usesWrite, domInfo, state);
 }
 
 /// Annotate IR with details about the detected non-writability conflict.
wouldCreateWriteToNonWritableBuffer(OpOperand &operand,
                                     bool checkConsistencyOnly = false) {
   bool foundWrite =
       !checkConsistencyOnly && state.bufferizesToMemoryWrite(operand);
 
   if (!foundWrite) {
     // Collect writes of all aliases of OpOperand and OpResult.
     DenseSet<OpOperand *> usesWrite;
     getAliasingInplaceWrites(usesWrite, operand.get(), state);
-    for (AliasingOpResult alias : state.getAliasingOpResults(operand))
-      getAliasingInplaceWrites(usesWrite, alias.opResult, state);
+    for (AliasingValue alias : state.getAliasingValues(operand))
+      getAliasingInplaceWrites(usesWrite, alias.value, state);
     foundWrite = !usesWrite.empty();
   }
 
   if (!foundWrite)
     return false;
 
   // Look for a read-only tensor among all aliases.
   bool foundReadOnly = false;
   auto checkReadOnly = [&](Value v) {
     if (!state.isWritable(v)) {
       foundReadOnly = true;
       if (state.getOptions().printConflicts)
         annotateNonWritableTensor(v);
     }
   };
   state.applyOnAliases(operand.get(), checkReadOnly);
-  for (AliasingOpResult alias : state.getAliasingOpResults(operand))
-    state.applyOnAliases(alias.opResult, checkReadOnly);
+  for (AliasingValue alias : state.getAliasingValues(operand))
+    state.applyOnAliases(alias.value, checkReadOnly);
   if (foundReadOnly) {
     LLVM_DEBUG(llvm::dbgs() << "=> NOT WRITABLE\n");
     return true;
   }
 
   return false;
 }
 
if (auto bufferizableOp = state.getOptions().dynCastBufferizableOp(op)) {
           if (!state.areEquivalentBufferizedValues(operand, firstOperand))
             allEquivalent = false;
         }
 
         // If all "maybe" aliases are equivalent and the OpResult is not a new
         // allocation, it is a definite, equivalent alias. E.g.:
         //
         // aliasingOpOperands(%r) = {(%t0, EQUIV, MAYBE), (%t1, EQUIV, MAYBE)}
-        // aliasingOpResults(%t0) = {(%r, EQUIV, MAYBE)}
-        // aliasingOpResults(%t1) = {(%r, EQUIV, MAYBE)}
+        // aliasingValues(%t0) = {(%r, EQUIV, MAYBE)}
+        // aliasingValues(%t1) = {(%r, EQUIV, MAYBE)}
         // %r = arith.select %c, %t0, %t1 : tensor<?xf32>
         //
         // If %t0 and %t1 are equivalent, it is safe to union the equivalence
         // classes of %r, %t0 and %t1.
         if (allEquivalent && !bufferizableOp.bufferizesToAllocation(opResult))
           state.unionEquivalenceClasses(opResult, firstOperand);
       }
     }
for (OpOperand &opOperand : op->getOpOperands())
         setInPlaceOpOperand(opOperand, state.isInPlace(opOperand));
   });
 }
 
 static void annotateOpsWithAliasSets(Operation *op,
                                      const OneShotAnalysisState &state) {
   AsmState asmState(op);
   Builder b(op->getContext());
-  op->walk([&](Operation *op) {
-    SmallVector<Attribute> aliasSets;
-    for (OpResult opResult : op->getOpResults()) {
-      if (llvm::isa<TensorType>(opResult.getType())) {
-        SmallVector<Attribute> aliases;
-        state.applyOnAliases(opResult, [&](Value alias) {
-          std::string buffer;
-          llvm::raw_string_ostream stream(buffer);
-          alias.printAsOperand(stream, asmState);
-          aliases.push_back(b.getStringAttr(stream.str()));
-        });
-        aliasSets.push_back(b.getArrayAttr(aliases));
+  // Helper function to build an array attribute of aliasing SSA value strings.
+  auto buildAliasesArray = [&](Value v) {
+    state.applyOnAliases(v, [&](Value alias) {
+    return b.getArrayAttr(aliases);
+  };
+
+  op->walk([&](Operation *op) {
+    // Build alias set array for every OpResult.
+    SmallVector<Attribute> opResultAliasSets;
+    for (OpResult opResult : op->getOpResults()) {
+      if (llvm::isa<TensorType>(opResult.getType())) {
+        opResultAliasSets.push_back(buildAliasesArray(opResult));
+      }
+    }
+    if (!opResultAliasSets.empty())
+      op->setAttr(kOpResultAliasSetAttrName, b.getArrayAttr(opResultAliasSets));
+
+    // Build alias set array for every BlockArgument.
+    SmallVector<Attribute> regionAliasSets;
+    bool hasTensorBbArg = false;
+    for (Region &r : op->getRegions()) {
+      SmallVector<Attribute> blockAliasSets;
+      for (Block &block : r.getBlocks()) {
+        SmallVector<Attribute> bbArgAliasSets;
+        for (BlockArgument bbArg : block.getArguments()) {
+          if (llvm::isa<TensorType>(bbArg.getType())) {
+            bbArgAliasSets.push_back(buildAliasesArray(bbArg));
+            hasTensorBbArg = true;
+          }
+        }
+        blockAliasSets.push_back(b.getArrayAttr(bbArgAliasSets));
       }
+      regionAliasSets.push_back(b.getArrayAttr(blockAliasSets));
     }
-    if (!aliasSets.empty())
-      op->setAttr(kAliasSetAttrName, b.getArrayAttr(aliasSets));
+    if (hasTensorBbArg)
+      op->setAttr(kBbArgAliasSetAttrName, b.getArrayAttr(regionAliasSets));
   });
 }
 
 /// Assert that every allocation can be deallocated in the same block. I.e.,
 /// every value that is returned or yielded from a block is:
 /// * guaranteed to be aliasing a bbArg of that block or a parent block, or
 /// * guaranteed to be aliasing an OpResult of a op in a parent block.
 ///

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

 using namespace mlir;
 using namespace mlir::bufferization;
 
 namespace {
 /// Bufferization of memref.tensor_store. Replace with memref.copy.
 struct TensorStoreOpInterface
     : public BufferizableOpInterface::ExternalModel<TensorStoreOpInterface,
                                                     memref::TensorStoreOp> {
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {};
   }
 
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     assert(opOperand.getOperandNumber() == 0 && "expected src operand");
     return true;
   }

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;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     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
     // when possible.

 };
 
 /// Bufferization of scf.execute_region. Can be analyzed, but bufferization not
 /// fully implemented at the moment.
 struct ExecuteRegionOpInterface
     : public BufferizableOpInterface::ExternalModel<ExecuteRegionOpInterface,
                                                     scf::ExecuteRegionOp> {
   AliasingOpOperandList
-  getAliasingOpOperands(Operation *op, OpResult opResult,
+  getAliasingOpOperands(Operation *op, Value value,
                         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));
+                                     llvm::find(op->getOpResults(), value));
     // TODO: Support multiple blocks.
     assert(executeRegionOp.getRegion().getBlocks().size() == 1 &&
            "expected exactly 1 block");
     auto yieldOp = dyn_cast<scf::YieldOp>(
         executeRegionOp.getRegion().front().getTerminator());
     assert(yieldOp && "expected scf.yield terminator in scf.execute_region");
     return {{&yieldOp->getOpOperand(resultNum), BufferRelation::Equivalent}};
   }
LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
     return success();
   }
 };
 
 /// Bufferization of scf.if. Replace with a new scf.if that yields memrefs.
 struct IfOpInterface
     : public BufferizableOpInterface::ExternalModel<IfOpInterface, scf::IfOp> {
   AliasingOpOperandList
-  getAliasingOpOperands(Operation *op, OpResult opResult,
+  getAliasingOpOperands(Operation *op, Value value,
                         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));
+                                     llvm::find(op->getOpResults(), value));
     OpOperand *thenOperand = &ifOp.thenYield()->getOpOperand(resultNum);
     OpOperand *elseOperand = &ifOp.elseYield()->getOpOperand(resultNum);
     return {{thenOperand, BufferRelation::Equivalent, /*isDefinite=*/false},
             {elseOperand, BufferRelation::Equivalent, /*isDefinite=*/false}};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
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;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     auto forOp = cast<scf::ForOp>(op);
     OpResult opResult = forOp.getResultForOpOperand(opOperand);
     BufferRelation relation = bufferRelation(op, opResult, state);
     return {{opResult, relation,
              /*isDefinite=*/relation == BufferRelation::Equivalent}};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
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;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     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())
       return {};
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     if (auto ifOp = dyn_cast<scf::IfOp>(op->getParentOp())) {
       return {{op->getParentOp()->getResult(opOperand.getOperandNumber()),
                BufferRelation::Equivalent, /*isDefinite=*/false}};
     }
     if (isa<scf::ExecuteRegionOp>(op->getParentOp()))
       return {{op->getParentOp()->getResult(opOperand.getOperandNumber()),
                BufferRelation::Equivalent}};
     return {};
struct ForallOpInterface
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Outputs of scf::ForallOps are always considered as a write.
     return true;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     auto forallOp = cast<ForallOp>(op);
     return {
         {{forallOp.getTiedOpResult(&opOperand), BufferRelation::Equivalent}}};
   }
 
   bool isWritable(Operation *op, Value value,
                   const AnalysisState &state) const {
     return true;

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

 namespace shape {
 namespace {
 
 /// Bufferization of shape.assuming.
 struct AssumingOpInterface
     : public BufferizableOpInterface::ExternalModel<AssumingOpInterface,
                                                     shape::AssumingOp> {
   AliasingOpOperandList
-  getAliasingOpOperands(Operation *op, OpResult opResult,
+  getAliasingOpOperands(Operation *op, Value value,
                         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));
+                                     llvm::find(op->getOpResults(), value));
     // TODO: Support multiple blocks.
     assert(assumingOp.getDoRegion().getBlocks().size() == 1 &&
            "expected exactly 1 block");
     auto yieldOp = dyn_cast<shape::AssumingYieldOp>(
         assumingOp.getDoRegion().front().getTerminator());
     assert(yieldOp && "expected shape.assuming_yield terminator");
     return {{&yieldOp->getOpOperand(resultNum), BufferRelation::Equivalent}};
   }
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     assert(isa<shape::AssumingOp>(op->getParentOp()) &&
            "expected that parent is an AssumingOp");
     OpResult opResult =
         op->getParentOp()->getResult(opOperand.getOperandNumber());
     return {{opResult, BufferRelation::Equivalent}};
   }
 
   bool mustBufferizeInPlace(Operation *op, OpOperand &opOperand,

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

 
 namespace mlir {
 namespace sparse_tensor {
 namespace {
 
 struct ConcatenateOpInterface
     : public BufferizableOpInterface::ExternalModel<
           ConcatenateOpInterface, sparse_tensor::ConcatenateOp> {
-  bool bufferizesToAllocation(Operation *op, OpResult opResult) const {
-    return true;
-  }
+  bool bufferizesToAllocation(Operation *op, Value value) const { return true; }
 
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {};
   }
 
   bool isWritable(Operation *op, Value value,
                   const AnalysisState &state) const {
     return true;
   }
 };
 
 struct ConvertOpInterface
     : public BufferizableOpInterface::ExternalModel<ConvertOpInterface,
                                                     sparse_tensor::ConvertOp> {
-  bool bufferizesToAllocation(Operation *op, OpResult opResult) const {
+  bool bufferizesToAllocation(Operation *op, Value value) const {
     // ConvertOps may allocate. (Unless they convert between two identical
     // types, then they fold away.)
     return true;
   }
 
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     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;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {{op->getOpResult(0), BufferRelation::Equivalent}};
   }
 };
 
 struct NewOpInterface
     : public BufferizableOpInterface::ExternalModel<NewOpInterface,
                                                     sparse_tensor::NewOp> {
   bool resultBufferizesToMemoryWrite(Operation *op, OpResult opResult,
                                      const AnalysisState &state) const {
     // NewOps allocate but do not write.
     return false;
   }
 
-  bool bufferizesToAllocation(Operation *op, OpResult opResult) const {
-    return true;
-  }
+  bool bufferizesToAllocation(Operation *op, Value value) const { return true; }
 };
 
 struct PackOpInterface
     : public BufferizableOpInterface::ExternalModel<PackOpInterface,
                                                     sparse_tensor::PackOp> {
-  bool bufferizesToAllocation(Operation *op, OpResult opResult) const {
+  bool bufferizesToAllocation(Operation *op, Value value) const {
     // PackOp reuses all the buffers instead of allocating new ones
     return false;
   }
 
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     assert(op->getNumResults() == 1);
     // PackOp reuses the input tensors as values/coordinates instead of
     // creating new ones when packing into a COO format.
     return {{op->getOpResult(0), BufferRelation::Equivalent}};
   }
 
   BufferRelation bufferRelation(Operation *oo, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Unknown;
   }
 };
 
 struct UnpackOpInterface
     : public BufferizableOpInterface::ExternalModel<UnpackOpInterface,
                                                     sparse_tensor::UnpackOp> {
-  bool bufferizesToAllocation(Operation *op, OpResult opResult) const {
+  bool bufferizesToAllocation(Operation *op, Value value) const {
     // The output buffer is pre-allocated by the user.
     return false;
   }
 
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     // The first operand is the sparse tensor that we are unpacking.
     return opOperand.getOperandNumber() == 0;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // We write into the output operand.
     assert(2 * (op->getNumOperands() - 1) == op->getNumResults());
     return opOperand.getOperandNumber() > 0;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     assert(2 * (op->getNumOperands() - 1) == op->getNumResults());
 
     if (opOperand.getOperandNumber() == 0)
       return {};
     // We write directly into the output tensors and returns them.
     return {{op->getResult(opOperand.getOperandNumber() - 1),
              BufferRelation::Equivalent}};
   }
 };
 
 struct InsertOpInterface
     : public BufferizableOpInterface::ExternalModel<InsertOpInterface,
                                                     sparse_tensor::InsertOp> {
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // InsertOp writes to memory.
     return true;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     // InsertOp returns an alias of its operand.
     assert(op->getNumResults() == 1);
     return {{op->getOpResult(0), BufferRelation::Equivalent}};
   }
 };
 
 struct NumberOfEntriesOpInterface
     : public BufferizableOpInterface::ExternalModel<
           NumberOfEntriesOpInterface, sparse_tensor::NumberOfEntriesOp> {
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {};
   }
 };
 
 struct ToCoordinatesBufferOpInterface
     : public BufferizableOpInterface::ExternalModel<
           ToCoordinatesBufferOpInterface,
           sparse_tensor::ToCoordinatesBufferOp> {
   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.coordinates` are not considered.
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {};
   }
 };
 
 struct ToCoordinatesOpInterface
     : public BufferizableOpInterface::ExternalModel<
           ToCoordinatesOpInterface, sparse_tensor::ToCoordinatesOp> {
   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.coordinates` are not considered.
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {};
   }
 };
 
 struct ToPositionsOpInterface
     : public BufferizableOpInterface::ExternalModel<
           ToPositionsOpInterface, sparse_tensor::ToPositionsOp> {
   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.positions` are not considered.
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     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;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     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;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {{op->getResult(0), BufferRelation::Equivalent}};
   }
 
   FailureOr<BaseMemRefType>
   getBufferType(Operation *op, Value value, const BufferizationOptions &options,
                 const DenseMap<Value, BaseMemRefType> &fixedTypes) const {
     auto castOp = cast<tensor::CastOp>(op);
     auto maybeSrcBufferType =
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     // TODO: CollapseShapeOp may allocate at runtime.
     return {{op->getOpResult(0), BufferRelation::Equivalent}};
   }
 
   FailureOr<BaseMemRefType>
   getBufferType(Operation *op, Value value, const BufferizationOptions &options,
                 const DenseMap<Value, BaseMemRefType> &fixedTypes) const {
     auto collapseShapeOp = cast<tensor::CollapseShapeOp>(op);
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     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);
     if (failed(v))
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {{op->getOpResult(0), BufferRelation::Equivalent}};
   }
 
   FailureOr<BaseMemRefType>
   getBufferType(Operation *op, Value value, const BufferizationOptions &options,
                 const DenseMap<Value, BaseMemRefType> &fixedTypes) const {
     auto expandShapeOp = cast<tensor::ExpandShapeOp>(op);
     auto maybeSrcBufferType = bufferization::getBufferType(
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {{op->getOpResult(0), BufferRelation::Unknown}};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto extractSliceOp = cast<tensor::ExtractSliceOp>(op);
     SmallVector<OpFoldResult> mixedOffsets = extractSliceOp.getMixedOffsets();
     SmallVector<OpFoldResult> mixedSizes = extractSliceOp.getMixedSizes();
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto extractOp = cast<tensor::ExtractOp>(op);
     FailureOr<Value> srcMemref =
         getBuffer(rewriter, extractOp.getTensor(), options);
static void createStores(RewriterBase &rewriter, Location loc, int dim,
   }
 }
 
 /// Bufferization of tensor.from_elements.
 struct FromElementsOpInterface
     : public BufferizableOpInterface::ExternalModel<FromElementsOpInterface,
                                                     tensor::FromElementsOp> {
 
-  bool bufferizesToAllocation(Operation *op, OpResult opResult) const {
-    return true;
-  }
+  bool bufferizesToAllocation(Operation *op, Value value) const { return true; }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto fromElementsOp = cast<tensor::FromElementsOp>(op);
     // Should the buffer be deallocated?
     bool dealloc = shouldDeallocateOpResult(
         cast<OpResult>(fromElementsOp.getResult()), options);
 
static Value lowerGenerateLikeOpBody(RewriterBase &rewriter, Location loc,
   return linalgOp.getResult()[0];
 }
 
 /// Bufferization of tensor.generate.
 struct GenerateOpInterface
     : public BufferizableOpInterface::ExternalModel<GenerateOpInterface,
                                                     tensor::GenerateOp> {
 
-  bool bufferizesToAllocation(Operation *op, OpResult opResult) const {
-    return true;
-  }
+  bool bufferizesToAllocation(Operation *op, Value value) const { return true; }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto generateOp = cast<tensor::GenerateOp>(op);
     // Should the buffer be deallocated?
     bool dealloc = shouldDeallocateOpResult(
         cast<OpResult>(generateOp.getResult()), options);
 

 
 /// Bufferization of tensor.pad. Replace with bufferization.alloc_tensor +
 /// linalg.map + insert_slice.
 /// For best performance, vectorize before bufferization (better performance in
 /// case of padding with a constant).
 struct PadOpInterface
     : public BufferizableOpInterface::ExternalModel<PadOpInterface,
                                                     tensor::PadOp> {
-  bool bufferizesToAllocation(Operation *op, OpResult opResult) const {
-    return true;
-  }
+  bool bufferizesToAllocation(Operation *op, Value value) const { return true; }
 
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {};
   }
 
   FailureOr<BaseMemRefType>
   getBufferType(Operation *op, Value value, const BufferizationOptions &options,
                 const DenseMap<Value, BaseMemRefType> &fixedTypes) const {
     // Infer memory space from the source tensor.
     auto padOp = cast<tensor::PadOp>(op);
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     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);
     if (failed(v))
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return false;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {{op->getOpResult(0), BufferRelation::Equivalent}};
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto reshapeOp = cast<tensor::ReshapeOp>(op);
     FailureOr<Value> srcBuffer =
         getBuffer(rewriter, reshapeOp.getSource(), options);
return getMemRefTypeWithStaticIdentityLayout(
         cast<BaseMemRefType>(maybeSourceBufferType.value()).getMemorySpace());
   }
 };
 
 /// Analysis of ParallelInsertSliceOp.
 struct ParallelInsertSliceOpInterface
     : public BufferizableOpInterface::ExternalModel<
           ParallelInsertSliceOpInterface, ParallelInsertSliceOp> {
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {};
   }
 
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const AnalysisState &state) const {
     return true;
   }
 

 };
 
 /// Bufferization of tensor.splat. Bufferizes to a new allocation that is filled
 /// with a linalg.map. Similar to tensor.generate.
 struct SplatOpInterface
     : public BufferizableOpInterface::ExternalModel<SplatOpInterface,
                                                     tensor::SplatOp> {
 
-  bool bufferizesToAllocation(Operation *op, OpResult opResult) const {
-    return true;
-  }
+  bool bufferizesToAllocation(Operation *op, Value value) const { return true; }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     OpBuilder::InsertionGuard g(rewriter);
     auto splatOp = cast<tensor::SplatOp>(op);
 
     // Should the buffer be deallocated?
     bool dealloc =

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

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

 };
 
 /// Bufferization of vector.mask. Replaced with a new vector.mask that
 /// operates on a memref.
 struct MaskOpInterface
     : public BufferizableOpInterface::ExternalModel<MaskOpInterface,
                                                     vector::MaskOp> {
   AliasingOpOperandList
-  getAliasingOpOperands(Operation *op, OpResult opResult,
+  getAliasingOpOperands(Operation *op, Value value,
                         const AnalysisState &state) const {
     // MaskOps do not have tensor OpOperands. The yielded values are the result
     // of the wrapped op.
     auto maskOp = cast<vector::MaskOp>(op);
     size_t resultNum = std::distance(op->getOpResults().begin(),
-                                     llvm::find(op->getOpResults(), opResult));
+                                     llvm::find(op->getOpResults(), value));
     auto yieldOp =
         cast<vector::YieldOp>(maskOp.getMaskRegion().front().getTerminator());
     return {{&yieldOp->getOpOperand(resultNum), BufferRelation::Equivalent}};
   }
 
   LogicalResult resolveConflicts(Operation *op, RewriterBase &rewriter,
                                  const AnalysisState &state) const {
     auto bufferizableOp = cast<BufferizableOpInterface>(op);
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     return false;
   }
 
-  AliasingOpResultList getAliasingOpResults(Operation *op, OpOperand &opOperand,
-                                            const AnalysisState &state) const {
+  AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
     return {{op->getParentOp()->getResult(opOperand.getOperandNumber()),
              BufferRelation::Equivalent}};
   }
 
   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

mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-analysis.mlir

 // RUN: mlir-opt %s -one-shot-bufferize="test-analysis-only" \
 // RUN:     -allow-unregistered-dialect -split-input-file | FileCheck %s
 
 // RUN: mlir-opt %s -one-shot-bufferize="test-analysis-only dump-alias-sets" \
 // RUN:     -allow-unregistered-dialect -split-input-file | \
 // RUN: FileCheck %s --check-prefix=CHECK-ALIAS-SETS
 
 // CHECK-LABEL: func @unknown_op_aliasing(
+// CHECK-ALIAS-SETS-LABEL: func @unknown_op_aliasing(
 func.func @unknown_op_aliasing(%f: f32, %f2: f32, %pos: index) -> f32 {
   // CHECK-ALIAS-SETS: %[[empty:.*]] = tensor.empty
 
   %0 = tensor.empty() : tensor<10xf32>
   // CHECK: linalg.fill {__inplace_operands_attr__ = ["none", "true"]}
   // CHECK-ALIAS-SETS: %[[fill1:.*]] = linalg.fill
   %1 = linalg.fill ins(%f : f32) outs(%0 : tensor<10xf32>) -> tensor<10xf32>
 
   // Something must bufferize out-of-place because the op may return an alias
   // of %1.
   // CHECK: "dummy.dummy_op"(%{{.*}}) {__inplace_operands_attr__ = ["false"]}
   %alias = "dummy.dummy_op"(%1) : (tensor<10xf32>) -> (tensor<10xf32>)
 
   // CHECK: linalg.fill {__inplace_operands_attr__ = ["none", "true"]}
-  // CHECK-ALIAS-SETS: %[[fill2:.*]] = linalg.fill {__alias_set_attr__ = [
-  // CHECK-ALIAS-SETS-SAME: ["%[[fill2]]", "%[[fill1]]", "%[[empty]]"]]
+  // CHECK-ALIAS-SETS: %[[fill2:.*]] = linalg.fill
+  // CHECK-ALIAS-SETS-SAME: __opresult_alias_set_attr__ = [{{\[}}"%[[fill2]]", "%[[fill1]]", "%[[empty]]"]]
   %2 = linalg.fill ins(%f2 : f32) outs(%1 : tensor<10xf32>) -> tensor<10xf32>
   %3 = tensor.extract %alias[%pos] : tensor<10xf32>
   return %3 : f32
 }
 
 // -----
 
+// CHECK-LABEL: func @unknown_op_bbarg_aliasing(
+// CHECK-ALIAS-SETS-LABEL: func @unknown_op_bbarg_aliasing(
+func.func @unknown_op_bbarg_aliasing() {
+  %0 = tensor.empty() : tensor<7xf32>
+
+  // %arg0 is not aliasing with %0 because it bufferizes out-of-place.
+  // CHECK-ALIAS-SETS: "dummy.dummy_op"
+  // CHECK-ALIAS-SETS-NEXT: ^{{.*}}(%[[arg:.*]]: tensor<7xf32>):
+  // CHECK-ALIAS-SETS-NEXT: }) {__bbarg_alias_set_attr__ = [{{\[}}[{{\[}}"%[[arg]]"]]]], __inplace_operands_attr__ = ["false"]} : (tensor<7xf32>) -> ()
+  "dummy.dummy_op"(%0) ({
+  ^bb0(%arg1: tensor<7xf32>):
+  }) : (tensor<7xf32>) -> ()
+  return
+}
+
+// -----
+
 // CHECK-LABEL: func @unknown_op_writing(
 func.func @unknown_op_writing(%f: f32, %f2: f32, %pos: index) -> f32 {
   %0 = tensor.empty() : tensor<10xf32>
   // CHECK: linalg.fill {__inplace_operands_attr__ = ["none", "true"]}
   %1 = linalg.fill ins(%f : f32) outs(%0 : tensor<10xf32>) -> tensor<10xf32>
 
   // The op may bufferize to a memory write, so it must bufferize out-of-place.
   // CHECK: "dummy.dummy_op"(%{{.*}}) {__inplace_operands_attr__ = ["false"]}
func.func @to_memref_read_only(%idx : index, %f: f32) -> f32 {
   } : tensor<5xf32>
   // Some op may write into the result of to_memref later.
   // CHECK: bufferization.to_memref
   // CHECK-SAME: {__inplace_operands_attr__ = ["true"]}
   %m = bufferization.to_memref %t {read_only} : memref<5xf32>
   %2 = tensor.extract %t[%idx] : tensor<5xf32>
   return %2 : f32
 }
+
+// -----
+
+// CHECK-LABEL: func @bbarg_of_unknown_op(
+func.func @bbarg_of_unknown_op(%f: f32) {
+  %0 = tensor.empty() : tensor<10xf32>
+  // CHECK: linalg.fill {__inplace_operands_attr__ = ["none", "true"]}
+  %1 = linalg.fill ins(%f : f32) outs(%0 : tensor<10xf32>) -> tensor<10xf32>
+
+  // The op is not bufferizable because %1 is assumed to alias with %arg1.
+  // BlockArguments are considered "not writable" by default. So %1 is also
+  // considered "not writable".
+
+  // CHECK: "dummy.dummy_op"
+  // CHECK: {__inplace_operands_attr__ = ["false"]} : (tensor<10xf32>) -> ()
+  "dummy.dummy_op"(%1) ({
+  ^bb0(%arg1: tensor<10xf32>):
+  }) : (tensor<10xf32>) -> ()
+  return
+}
+
+// -----
+
+// CHECK-LABEL: func @bbarg_of_unknown_op_2(
+func.func @bbarg_of_unknown_op_2(%f: f32) {
+  %0 = tensor.empty() : tensor<10xf32>
+  // CHECK: linalg.fill {__inplace_operands_attr__ = ["none", "true"]}
+  %1 = linalg.fill ins(%f : f32) outs(%0 : tensor<10xf32>) -> tensor<10xf32>
+
+  // The op is not bufferizable because %1 is assumed to alias with %arg1.
+  // BlockArguments are considered "not writable" by default. So %1 is also
+  // considered "not writable".
+
+  // CHECK: "dummy.dummy_op"
+  "dummy.dummy_op"(%1) ({
+  ^bb0(%arg1: tensor<10xf32>):
+    // CHECK: "dummy.another_op"(%{{.*}}) {__inplace_operands_attr__ = ["false"]}
+    "dummy.another_op"(%arg1) : (tensor<10xf32>) -> ()
+  }) : (tensor<10xf32>) -> ()
+  // CHECK: {__inplace_operands_attr__ = ["false"]} : (tensor<10xf32>) -> ()
+  return
+}