[mlir][bufferize] Remove alias consistency check

[springerm]

Summary

This change removes a check that guards against incorrect implementations of BufferizableOpInterface::mustBufferizeInplace. This check was not useful in practice and added extra complexity to the code base.

Depends On D135053

[springerm]

rebase

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

 ///
 /// In the above example, the two TransferWriteOps have already been decided to
 /// bufferize inplace. Bufferizing the ExtractSliceOp inplace would create a
 /// conflict because:
 /// * According to SSA use-def chains, we expect to read the result of %1.
 /// * However, adding an alias {%0, %t} would mean that the second
 ///   TransferWriteOp overwrites the first one. Therefore, the TransferReadOp
 ///   would no longer be reading the result of %1.
-///
-/// If `checkConsistencyOnly` is true, this function checks if there is a
-/// read-after-write conflict without bufferizing `operand` inplace. This would
-/// indicate a problem with the current inplace bufferization decisions.
-///
-/// Note: If `checkConsistencyOnly`, this function may be called with a null
-/// OpResult. In that case, only the consistency of bufferization decisions
-/// involving aliases of the given OpOperand are checked.
 static bool wouldCreateReadAfterWriteInterference(
     OpOperand &operand, const DominanceInfo &domInfo, AnalysisState &state,
-    const BufferizationAliasInfo &aliasInfo,
-    bool checkConsistencyOnly = false) {
+    const BufferizationAliasInfo &aliasInfo) {
   // Collect reads and writes of all aliases of OpOperand and OpResult.
   DenseSet<OpOperand *> usesRead, usesWrite;
   getAliasingReads(usesRead, operand.get(), aliasInfo, state);
   getAliasingInplaceWrites(usesWrite, operand.get(), aliasInfo, state);
   for (OpResult result : state.getAliasingOpResult(operand)) {
     getAliasingReads(usesRead, result, aliasInfo, state);
     getAliasingInplaceWrites(usesWrite, result, aliasInfo, state);
   }
-  if (!checkConsistencyOnly && state.bufferizesToMemoryWrite(operand))
+  if (state.bufferizesToMemoryWrite(operand))
     usesWrite.insert(&operand);
 
   return hasReadAfterWriteInterference(usesRead, usesWrite, domInfo, state,
                                        aliasInfo);
 }
 
 /// Check the reverse SSA use-def chain (following aliasing OpOperands) for
 /// non-writable tensor values. Stop searching when an out-of-place bufferized
for (OpOperand *opOperand : aliasingOpOperands)
       if (aliasInfo.isInPlace(*opOperand) || currentOpOperand == opOperand)
         worklist.push_back(opOperand->get());
   }
   return false;
 }
 
 /// Return true if bufferizing `operand` inplace would create a write to a
 /// non-writable buffer.
-static bool wouldCreateWriteToNonWritableBuffer(
-    OpOperand &operand, const BufferizationAliasInfo &aliasInfo,
-    OneShotAnalysisState &state, bool checkConsistencyOnly = false) {
+static bool
+wouldCreateWriteToNonWritableBuffer(OpOperand &operand,
+                                    const BufferizationAliasInfo &aliasInfo,
+                                    OneShotAnalysisState &state) {
   // Collect writes of all aliases of OpOperand and OpResult.
   DenseSet<OpOperand *> usesWrite;
   getAliasingInplaceWrites(usesWrite, operand.get(), aliasInfo, state);
   for (OpResult result : state.getAliasingOpResult(operand)) {
     getAliasingInplaceWrites(usesWrite, result, aliasInfo, state);
   }
-  if (!checkConsistencyOnly && state.bufferizesToMemoryWrite(operand))
+  if (state.bufferizesToMemoryWrite(operand))
     usesWrite.insert(&operand);
 
   // Assuming that `operand` bufferizes in-place: For each write (to each
   // alias), check if there is a non-writable tensor in the reverse SSA use-def
   // chain.
   for (OpOperand *uWrite : usesWrite)
     if (hasPrecedingAliasingNonWritableTensor(uWrite->get(), &operand,
                                               aliasInfo, state))

 /// Analyze all ops that are contained in `op`.
 static LogicalResult inPlaceAnalysis(Operation *op,
                                      BufferizationAliasInfo &aliasInfo,
                                      OneShotAnalysisState &state,
                                      const DominanceInfo &domInfo,
                                      unsigned analysisFuzzerSeed = 0) {
   // Collect ops so we can build our own reverse traversal.
   SmallVector<Operation *> ops;
-  op->walk([&](Operation *op) {
+  WalkResult status = op->walk([&](Operation *op) {
     // No tensors => no buffers.
     if (!hasTensorSemantics(op))
-      return;
+      return WalkResult::skip();
+
+    // Input IR may not contain any ToMemrefOps. These are not supported because
+    // the analysis cannot follow the data flow through memrefs.
+    if (isa<ToMemrefOp>(op)) {
+      op->emitError("to_memref ops not supported during One-Shot Analysis");
+      return WalkResult::interrupt();
+    }
+
     ops.push_back(op);
+    return WalkResult::advance();
   });
 
+  if (status.wasInterrupted())
+    return failure();
+
   return inPlaceAnalysis(ops, aliasInfo, state, domInfo, analysisFuzzerSeed);
 }
 
 /// Analyze equivalence of tied OpResult/OpOperand pairs of the given ops.
 static void equivalenceAnalysis(SmallVector<Operation *> &ops,
                                 BufferizationAliasInfo &aliasInfo,
                                 AnalysisState &state) {
   for (Operation *op : ops)
op->walk<WalkOrder::PostOrder>([&](Operation *op) {
     if (none_of(op->getResultTypes(), isaTensor))
       return;
     ops.push_back(op);
   });
 
   equivalenceAnalysis(ops, aliasInfo, state);
 }
 
-/// Assert that the current bufferization decisions are consistent.
-static LogicalResult
-checkAliasInfoConsistency(Operation *op, const DominanceInfo &domInfo,
-                          AnalysisState &state,
-                          const BufferizationAliasInfo &aliasInfo) {
-  const BufferizationOptions &options = state.getOptions();
-
-  WalkResult walkResult = op->walk([&](BufferizableOpInterface op) {
-    // Skip ops that are not in the filter.
-    if (!options.isOpAllowed(op.getOperation()))
-      return WalkResult::advance();
-
-    // Input IR may not contain any ToMemrefOps. These are not supported because
-    // the analysis cannot follow the data flow through memrefs.
-    if (isa<ToMemrefOp>(op.getOperation())) {
-      op->emitError("to_memref ops not supported during One-Shot Analysis");
-      return WalkResult::interrupt();
-    }
-
-    for (OpOperand &opOperand : op->getOpOperands()) {
-      if (opOperand.get().getType().isa<TensorType>()) {
-        if (wouldCreateReadAfterWriteInterference(
-                opOperand, domInfo, state, aliasInfo,
-                /*checkConsistencyOnly=*/true)) {
-          // This error can happen if certain "mustBufferizeInPlace" interface
-          // methods are implemented incorrectly, such that the IR already has
-          // a RaW conflict before making any bufferization decisions.
-          op->emitError("input IR has RaW conflict");
-          return WalkResult::interrupt();
-        }
-      }
-    }
-
-    return WalkResult::advance();
-  });
-
-  return success(!walkResult.wasInterrupted());
-}
-
 /// Annotate the IR with the result of the analysis. For testing/debugging only.
 static void
 annotateOpsWithBufferizationMarkers(Operation *op,
                                     const BufferizationAliasInfo &aliasInfo,
                                     AnalysisState &state) {
   op->walk([&](Operation *op) {
     if (auto bufferizableOp = state.getOptions().dynCastBufferizableOp(op))
       for (OpOperand &opOperand : op->getOpOperands())

 
 LogicalResult bufferization::analyzeOp(Operation *op,
                                        OneShotAnalysisState &state) {
   DominanceInfo domInfo(op);
   BufferizationAliasInfo &aliasInfo = state.getAliasInfo();
   const auto &options =
       static_cast<const OneShotBufferizationOptions &>(state.getOptions());
 
-  if (failed(checkAliasInfoConsistency(op, domInfo, state, aliasInfo)))
-    return failure();
-
   // If the analysis fails, just return.
   if (failed(inPlaceAnalysis(op, aliasInfo, state, domInfo,
                              options.analysisFuzzerSeed)))
     return failure();
   equivalenceAnalysis(op, aliasInfo, state);
 
   bool failedAnalysis = false;
   if (!options.allowReturnAllocs) {