[mlir][linalg][bufferize][NFC] Add inPlaceAnalysis overload

[springerm]

Summary

Depends On D114772

[springerm]

update

[springerm]

update

[springerm]

update

[springerm]

update

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

for (OpOperand &opOperand : op->getOpOperands())
           if (OpResult opResult = bufferizableOp.getAliasingOpResult(opOperand))
             if (failed(bufferizableInPlaceAnalysisImpl(opOperand, opResult,
                                                        aliasInfo, domInfo)))
               return failure();
 
   return success();
 }
 
+/// Analyze all ops that are contained in `op`.
+static LogicalResult inPlaceAnalysis(Operation *op,
+                                     BufferizationAliasInfo &aliasInfo,
+                                     const DominanceInfo &domInfo,
+                                     unsigned analysisFuzzerSeed = 0) {
+  // Collect ops so we can build our own reverse traversal.
+  SmallVector<Operation *> ops;
+  op->walk([&](Operation *op) {
+    // No tensors => no buffers.
+    if (none_of(op->getOperandTypes(), isaTensor) &&
+        none_of(op->getResultTypes(), isaTensor))
+      return;
+    ops.push_back(op);
+  });
+
+  return inPlaceAnalysis(ops, aliasInfo, domInfo, analysisFuzzerSeed);
+}
+
 /// Assert that the current bufferization decisions are consistent.
 static LogicalResult
 checkAliasInfoConsistency(FuncOp funcOp, const DominanceInfo &domInfo,
                           const BufferizationAliasInfo &aliasInfo) {
   Operation *inconsistentOp = nullptr;
   WalkResult walkResult = funcOp.walk([&](Operation *op) {
     if (auto bufferizableOp = dyn_cast<BufferizableOpInterface>(op))
       for (OpOperand &opOperand : op->getOpOperands())
LogicalResult mlir::linalg::comprehensive_bufferize::runComprehensiveBufferize(
   BufferizationAliasInfo &aliasInfo = state.aliasInfo;
 
   if (funcOp.body().empty())
     return success();
 
   if (failed(checkAliasInfoConsistency(funcOp, domInfo, aliasInfo)))
     return failure();
 
-  // Collect ops so we can build our own reverse traversal.
-  SmallVector<Operation *> ops;
-  funcOp.walk([&](Operation *op) {
-    // No tensors => no buffers.
-    if (none_of(op->getOperandTypes(), isaTensor) &&
-        none_of(op->getResultTypes(), isaTensor))
-      return;
-    ops.push_back(op);
-  });
-
   // If the analysis fails, just return.
+  Operation *op = funcOp.getOperation();
   if (failed(
-          inPlaceAnalysis(ops, aliasInfo, domInfo, options.analysisFuzzerSeed)))
+          inPlaceAnalysis(op, aliasInfo, domInfo, options.analysisFuzzerSeed)))
     return failure();
 
   for (const std::unique_ptr<PostAnalysisStep> &step :
        options.postAnalysisSteps) {
     SmallVector<Operation *> newOps;
     if (failed(step->run(funcOp, state, newOps)))
       return failure();
     // Analyze ops that were created by the PostAnalysisStep.