[mlir][linalg][bufferize] Add isWritable to op interface

[springerm]

Summary

By default, OpResult buffers are writable. But there are ops (e.g., ConstantOp) for which this is not the case.

The purpose of this commit is to further decouple Comprehensive Bufferize from the Standard dialect.

Depends On D112907

[springerm]

no change

[springerm]

rebase

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

let methods = [
                       "BufferizationAliasInfo &":$aliasInfo,
                       "AllocationCallbacks &":$allocationFn),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           llvm_unreachable("bufferize not implemented");
           return failure();
         }]
       >,
+      InterfaceMethod<
+        /*desc=*/[{
+          Return `true` if the given OpOperand can be written to in-place. This
+          is the case for most ops, but some ops such as ConstantOp may
+          bufferize to non-writable (read-only) memory locations. This method
+          will never be called on OpResults that do not have a tensor type.
+        }],
+        /*retType=*/"bool",
+        /*methodName=*/"isWritable",
+        /*args=*/(ins "OpResult":$opResult),
+        /*methodBody=*/"",
+        /*defaultImplementation=*/[{
+          return true;
+        }]
+      >
   ];
 }
 
 #endif  // MLIR_DIALECT_LINALG_TRANSFORMS_BUFFERIZABLEOPINTERFACE

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

if (auto bbArg = v.dyn_cast<BlockArgument>()) {
         LDBG("-----------bbArg is writable -> skip: " << printValueInfo(bbArg)
                                                       << '\n');
         continue;
       }
       LDBG("-----------notWritable bbArg\n");
       return true;
     }
 
-    if (Operation *op = v.getDefiningOp()) {
-      if (isa<arith::ConstantOp>(op) ||
-          !dyn_cast<BufferizableOpInterface>(op)) {
-        LDBG("-----------notWritable op\n");
-        return true;
-      }
-    }
-  }
+    auto bufferizableOp = dyn_cast<BufferizableOpInterface>(v.getDefiningOp());
+    if (!bufferizableOp || !bufferizableOp.isWritable(v.cast<OpResult>())) {
+      // Unknown ops are treated conservatively: Assume that it is illegal to
+      // write to their OpResults in-place.
   LDBG("---->value is writable\n");
   return false;
 }
 
 bool BufferizationAliasInfo::bufferizesToWritableMemory(Value v) const {
   return bufferizeToWritableMemory.count(v) > 0;
 }
 
LogicalResult bufferize(Operation *op, OpBuilder &b,
     auto globalMemref = globalCreator.getGlobalFor(constantOp);
     Value memref = b.create<memref::GetGlobalOp>(
         constantOp.getLoc(), globalMemref.type(), globalMemref.getName());
     aliasInfo.insertNewBufferEquivalence(memref, constantOp.getResult());
     map(bvm, constantOp, memref);
 
     return success();
   }
+
+  bool isWritable(Operation *op, OpResult opResult) const {
+    // Memory locations returned by memref::GetGlobalOp may not be written to.
+    return false;
+  }
 };
 
 } // namespace arith_ext
 
 // TODO: Ops in the linalg dialect can directly implement this interface.
 namespace linalg_ext {
 
 /// Helper function for LinalgOp bufferization.