[mlir][bufferize][NFC] Query BufferizableOpInterface::isNotConflicting last

[springerm]

Summary

This change by itself is NFC. It does currently not matter in what order "not a conflict" checks are performed.

This change is in preparation of adding additional functionality for value privatization. Such privatization will be performed as part of isNotConflicting. It is important that this check is performed last, so that we do not introduce unnecessary value privatizations (when a different check can already rule out a RaW conflict).

Depends On D135049

[springerm]

rebase

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

for (OpOperand *uConflictingWrite : usesWrite) {
         //
         // Note: If ops are executed multiple times (e.g., because they are
         //       inside a loop), mutually exclusive regions may be executed
         //       multiple times.
         if (insideMutuallyExclusiveRegions(readingOp, conflictingWritingOp))
           continue;
       }
 
-      // No conflict if the op interface says so.
-      if (auto bufferizableOp = options.dynCastBufferizableOp(readingOp))
-        if (bufferizableOp.isNotConflicting(uRead, uConflictingWrite, state))
-          continue;
-
-      if (conflictingWritingOp != readingOp)
-        if (auto bufferizableOp =
-                options.dynCastBufferizableOp(conflictingWritingOp))
-          if (bufferizableOp.isNotConflicting(uRead, uConflictingWrite, state))
-            continue;
-
       // Check all possible last writes.
+      bool foundConflict = false;
+      Value conflictLastWrite;
       for (Value lastWrite : lastWrites) {
         // No conflict if the conflicting write happens before the last
         // write.
         if (Operation *writingOp = lastWrite.getDefiningOp()) {
           if (happensBefore(conflictingWritingOp, writingOp, domInfo))
             // conflictingWritingOp happens before writingOp. No conflict.
             continue;
           // No conflict if conflictingWritingOp is contained in writingOp.
for (OpOperand *uConflictingWrite : usesWrite) {
 
         // No conflict if the conflicting write and the last write are the same
         // use.
         SmallVector<OpResult> aliasingOpResult =
             state.getAliasingOpResult(*uConflictingWrite);
         if (aliasingOpResult.size() == 1 && aliasingOpResult[0] == lastWrite)
           continue;
 
-        // All requirements are met. Conflict found!
+        // All requirements are met. Conflict found! But the op interface can
+        // still override this decision.
+        foundConflict = true;
+        conflictLastWrite = lastWrite;
+        break;
+      }
 
-        if (options.printConflicts)
-          annotateConflict(uRead, uConflictingWrite, lastWrite);
+      if (!foundConflict)
+        // Continue if no conflict found.
+        continue;
 
-        return true;
-      }
-    }
-  }
+      // No conflict if the op interface says so.
+      if (auto bufferizableOp = options.dynCastBufferizableOp(readingOp))
+        if (bufferizableOp.isNotConflicting(uRead, uConflictingWrite, state))
+          continue;
+
+      if (conflictingWritingOp != readingOp)
+        if (auto bufferizableOp =
+                options.dynCastBufferizableOp(conflictingWritingOp))
+          if (bufferizableOp.isNotConflicting(uRead, uConflictingWrite, state))
+            continue;
+
+      // Report the conflict.
+      if (options.printConflicts)
+        annotateConflict(uRead, uConflictingWrite, conflictLastWrite);
 
   return false;
 }
 
 // Helper function to iterate on aliases of `root` and capture the writes.
 static void getAliasingInplaceWrites(DenseSet<OpOperand *> &res, Value root,
                                      const BufferizationAliasInfo &aliasInfo,
                                      const AnalysisState &state) {