Merge commit '7fd7078a8da6' from apple/main into swift/next

Author: git apple-llvm automerger

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

@@ -18,7 +18,7 @@
 
 namespace mlir {
 
-class BufferAssignmentTypeConverter;
+class BufferizeTypeConverter;
 
 namespace linalg {
 
@@ -51,7 +51,7 @@ void populateConvVectorizationPatterns(
 
 /// Populates the given list with patterns to bufferize linalg ops.
 void populateLinalgBufferizePatterns(MLIRContext *context,
-                                     BufferAssignmentTypeConverter &converter,
+                                     BufferizeTypeConverter &converter,
                                      OwningRewritePatternList &patterns);
 
 /// Performs standalone tiling of a single LinalgOp by `tileSizes`.
@@ -801,14 +801,13 @@ void populateLinalgToStandardConversionPatterns(
 // Buffer allocation patterns.
 //===----------------------------------------------------------------------===//
 
-/// Generic BufferAssignmentConversionPattern that matches any Operation* and
+/// Generic BufferizeConversionPattern that matches any Operation* and
 /// dispatches internally. This avoids template instantiating one pattern for
 /// each LinalgOp op.
-class LinalgOpConverter : public BufferAssignmentConversionPattern {
+class LinalgOpConverter : public BufferizeConversionPattern {
 public:
-  LinalgOpConverter(MLIRContext *context,
-                    BufferAssignmentTypeConverter &converter)
-      : BufferAssignmentConversionPattern(context, converter) {}
+  LinalgOpConverter(MLIRContext *context, BufferizeTypeConverter &converter)
+      : BufferizeConversionPattern(context, converter) {}
 
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
@@ -819,10 +818,9 @@ class LinalgOpConverter : public BufferAssignmentConversionPattern {
 /// stored in memory. A linalg.reshape is introduced to convert to the desired
 /// n-D buffer form.
 class TensorConstantOpConverter
-    : public BufferAssignmentOpConversionPattern<ConstantOp> {
+    : public BufferizeOpConversionPattern<ConstantOp> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      ConstantOp>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<ConstantOp>::BufferizeOpConversionPattern;
 
   LogicalResult
   matchAndRewrite(ConstantOp op, ArrayRef<Value> operands,
@@ -831,10 +829,10 @@ class TensorConstantOpConverter
 
 /// TensorCastOp converts 1-1 to MemRefCastOp.
 class TensorCastOpConverter
-    : public BufferAssignmentOpConversionPattern<TensorCastOp> {
+    : public BufferizeOpConversionPattern<TensorCastOp> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      TensorCastOp>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<
+      TensorCastOp>::BufferizeOpConversionPattern;
 
   LogicalResult
   matchAndRewrite(TensorCastOp op, ArrayRef<Value> operands,

mlir/include/mlir/Dialect/Shape/Transforms/Passes.h

@@ -17,7 +17,7 @@
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
-class BufferAssignmentTypeConverter;
+class BufferizeTypeConverter;
 } // namespace mlir
 
 namespace mlir {
@@ -40,9 +40,9 @@ void populateRemoveShapeConstraintsPatterns(OwningRewritePatternList &patterns,
                                             MLIRContext *ctx);
 std::unique_ptr<FunctionPass> createRemoveShapeConstraintsPass();
 
-void populateShapeTypeConversionPatterns(
-    MLIRContext *ctx, BufferAssignmentTypeConverter &converter,
-    OwningRewritePatternList &patterns);
+void populateShapeTypeConversionPatterns(MLIRContext *ctx,
+                                         BufferizeTypeConverter &converter,
+                                         OwningRewritePatternList &patterns);
 // Bufferizes shape dialect ops.
 //
 // Note that most shape dialect ops must be converted to std before

mlir/include/mlir/Transforms/Bufferize.h

@@ -29,15 +29,15 @@ namespace mlir {
 /// A helper type converter class for using inside Buffer Assignment operation
 /// conversion patterns. The default constructor keeps all the types intact
 /// except for the ranked-tensor types which is converted to memref types.
-class BufferAssignmentTypeConverter : public TypeConverter {
+class BufferizeTypeConverter : public TypeConverter {
 public:
   /// This enum is for showing how buffer placement operation converters should
   /// conduct with certain result type after type conversion. This value can be
   /// set/get for each specific type using setResultConversionKind or
   /// getResultConversionKind.
   enum ResultConversionKind { AppendToArgumentsList, KeepAsFunctionResult };
 
-  BufferAssignmentTypeConverter();
+  BufferizeTypeConverter();
 
   /// This method tries to decompose a value of a certain type using provided
   /// decompose callback functions. If it is unable to do so, the original value
@@ -131,46 +131,43 @@ class BufferAssignmentTypeConverter : public TypeConverter {
   SmallVector<DecomposeTypeConversionCallFn, 2> decomposeTypeConversions;
 };
 
-/// Helper conversion pattern that encapsulates a BufferAssignmentTypeConverter
+/// Helper conversion pattern that encapsulates a BufferizeTypeConverter
 /// instance.
 template <typename SourceOp>
-class BufferAssignmentOpConversionPattern
-    : public OpConversionPattern<SourceOp> {
+class BufferizeOpConversionPattern : public OpConversionPattern<SourceOp> {
 public:
-  explicit BufferAssignmentOpConversionPattern(
-      MLIRContext *context, BufferAssignmentTypeConverter &converter,
-      PatternBenefit benefit = 1)
+  explicit BufferizeOpConversionPattern(MLIRContext *context,
+                                        BufferizeTypeConverter &converter,
+                                        PatternBenefit benefit = 1)
       : OpConversionPattern<SourceOp>(context, benefit), converter(converter) {}
 
 protected:
-  BufferAssignmentTypeConverter &converter;
+  BufferizeTypeConverter &converter;
 };
 
-/// Helper conversion pattern that encapsulates a BufferAssignmentTypeConverter
+/// Helper conversion pattern that encapsulates a BufferizeTypeConverter
 /// instance and that operates on Operation* to be compatible with OpInterfaces.
 /// This allows avoiding to instantiate N patterns for ops that can be subsumed
 /// by a single op interface (e.g. Linalg named ops).
-class BufferAssignmentConversionPattern : public ConversionPattern {
+class BufferizeConversionPattern : public ConversionPattern {
 public:
-  explicit BufferAssignmentConversionPattern(
-      MLIRContext *context, BufferAssignmentTypeConverter &converter,
-      PatternBenefit benefit = 1)
+  explicit BufferizeConversionPattern(MLIRContext *context,
+                                      BufferizeTypeConverter &converter,
+                                      PatternBenefit benefit = 1)
       : ConversionPattern(benefit, converter, MatchAnyOpTypeTag()),
         converter(converter) {}
 
 protected:
-  BufferAssignmentTypeConverter &converter;
+  BufferizeTypeConverter &converter;
 };
 
-/// Converts the signature of the function using BufferAssignmentTypeConverter.
+/// Converts the signature of the function using BufferizeTypeConverter.
 /// Each result type of the function is kept as a function result or appended to
 /// the function arguments list based on ResultConversionKind for the converted
 /// result type.
-class BufferAssignmentFuncOpConverter
-    : public BufferAssignmentOpConversionPattern<FuncOp> {
+class BufferizeFuncOpConverter : public BufferizeOpConversionPattern<FuncOp> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      FuncOp>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<FuncOp>::BufferizeOpConversionPattern;
 
   /// Performs the actual signature rewriting step.
   LogicalResult matchAndRewrite(mlir::FuncOp, ArrayRef<Value>,
@@ -183,11 +180,11 @@ class BufferAssignmentFuncOpConverter
 /// operation from the operand to the target function argument is inserted.
 template <typename ReturnOpSourceTy, typename ReturnOpTargetTy,
           typename CopyOpTy>
-class BufferAssignmentReturnOpConverter
-    : public BufferAssignmentOpConversionPattern<ReturnOpSourceTy> {
+class BufferizeReturnOpConverter
+    : public BufferizeOpConversionPattern<ReturnOpSourceTy> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      ReturnOpSourceTy>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<
+      ReturnOpSourceTy>::BufferizeOpConversionPattern;
 
   /// Performs the actual return-op conversion step.
   LogicalResult
@@ -212,10 +209,10 @@ class BufferAssignmentReturnOpConverter
         Type origin = originTypes[value.index()];
         Type converted = value.value().getType();
         auto kind = this->converter.getResultConversionKind(origin, converted);
-        if (kind == BufferAssignmentTypeConverter::KeepAsFunctionResult)
+        if (kind == BufferizeTypeConverter::KeepAsFunctionResult)
           newOperands.push_back(value.value());
         else
-          // kind = BufferAssignmentTypeConverter::AppendToArgumentsList
+          // kind = BufferizeTypeConverter::AppendToArgumentsList
           needCopyOperands.push_back(value.value());
       }
     }
@@ -242,12 +239,10 @@ class BufferAssignmentReturnOpConverter
 
 /// Rewrites the `CallOp` to match its operands and results with the signature
 /// of the callee after rewriting the callee with
-/// BufferAssignmentFuncOpConverter.
-class BufferAssignmentCallOpConverter
-    : public BufferAssignmentOpConversionPattern<CallOp> {
+/// BufferizeFuncOpConverter.
+class BufferizeCallOpConverter : public BufferizeOpConversionPattern<CallOp> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      CallOp>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<CallOp>::BufferizeOpConversionPattern;
 
   /// Performs the actual rewriting step.
   LogicalResult matchAndRewrite(CallOp, ArrayRef<Value>,
@@ -258,14 +253,15 @@ class BufferAssignmentCallOpConverter
 /// assignment.
 template <typename ReturnOpSourceTy, typename ReturnOpTargetTy,
           typename CopyOpTy>
-static void populateWithBufferAssignmentOpConversionPatterns(
-    MLIRContext *context, BufferAssignmentTypeConverter &converter,
-    OwningRewritePatternList &patterns) {
+static void
+populateWithBufferizeOpConversionPatterns(MLIRContext *context,
+                                          BufferizeTypeConverter &converter,
+                                          OwningRewritePatternList &patterns) {
   // clang-format off
   patterns.insert<
-    BufferAssignmentCallOpConverter,
-    BufferAssignmentFuncOpConverter,
-    BufferAssignmentReturnOpConverter
+    BufferizeCallOpConverter,
+    BufferizeFuncOpConverter,
+    BufferizeReturnOpConverter
       <ReturnOpSourceTy, ReturnOpTargetTy, CopyOpTy>
   >(context, converter);
   // clang-format on

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

@@ -122,8 +122,7 @@ allocateBuffersForResults(Location loc, LinalgOp linalgOp,
 
 // Specialization for `linalg::GenericOp`.
 /// A pattern to convert Generic Linalg operations which work on tensors to
-/// use buffers. A buffer is allocated using BufferAssignmentPlacer for
-/// each operation result. BufferPlacement pass should be later used to move
+/// use buffers. BufferPlacement pass should be later used to move
 /// Alloc operations to the correct positions and insert the missing Dealloc
 /// operations in the correct places.
 static void finalizeBufferAllocation(ConversionPatternRewriter &rewriter,
@@ -294,7 +293,7 @@ struct LinalgBufferizePass : public LinalgBufferizeBase<LinalgBufferizePass> {
   void runOnOperation() override {
     MLIRContext &context = getContext();
     ConversionTarget target(context);
-    BufferAssignmentTypeConverter converter;
+    BufferizeTypeConverter converter;
 
     // Mark all Standard operations legal.
     target.addLegalDialect<StandardOpsDialect, vector::VectorDialect>();
@@ -344,13 +343,13 @@ struct LinalgBufferizePass : public LinalgBufferizeBase<LinalgBufferizePass> {
     });
 
     converter.setResultConversionKind<RankedTensorType, MemRefType>(
-        BufferAssignmentTypeConverter::AppendToArgumentsList);
+        BufferizeTypeConverter::AppendToArgumentsList);
 
     OwningRewritePatternList patterns;
     populateLinalgBufferizePatterns(&context, converter, patterns);
-    populateWithBufferAssignmentOpConversionPatterns<
-        mlir::ReturnOp, mlir::ReturnOp, linalg::CopyOp>(&context, converter,
-                                                        patterns);
+    populateWithBufferizeOpConversionPatterns<mlir::ReturnOp, mlir::ReturnOp,
+                                              linalg::CopyOp>(
+        &context, converter, patterns);
     if (failed(applyFullConversion(this->getOperation(), target, patterns)))
       this->signalPassFailure();
   }
@@ -361,7 +360,7 @@ std::unique_ptr<OperationPass<ModuleOp>> mlir::createLinalgBufferizePass() {
   return std::make_unique<LinalgBufferizePass>();
 }
 void mlir::linalg::populateLinalgBufferizePatterns(
-    MLIRContext *context, BufferAssignmentTypeConverter &converter,
+    MLIRContext *context, BufferizeTypeConverter &converter,
     OwningRewritePatternList &patterns) {
   patterns.insert<
       // clang-format off

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

@@ -21,10 +21,10 @@ using namespace mlir::shape;
 namespace {
 // Propagate tensor to memref conversions through shape.assuming ops.
 class TypeConversionAssumingOpConverter
-    : public BufferAssignmentOpConversionPattern<shape::AssumingOp> {
+    : public BufferizeOpConversionPattern<shape::AssumingOp> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      shape::AssumingOp>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<
+      shape::AssumingOp>::BufferizeOpConversionPattern;
 
   LogicalResult
   matchAndRewrite(shape::AssumingOp assumingOp, ArrayRef<Value> operands,
@@ -53,7 +53,7 @@ struct ShapeBufferizePass : public ShapeBufferizeBase<ShapeBufferizePass> {
     MLIRContext &ctx = getContext();
 
     OwningRewritePatternList patterns;
-    BufferAssignmentTypeConverter converter;
+    BufferizeTypeConverter converter;
     populateShapeTypeConversionPatterns(&ctx, converter, patterns);
 
     ConversionTarget target(getContext());
@@ -75,7 +75,7 @@ struct ShapeBufferizePass : public ShapeBufferizeBase<ShapeBufferizePass> {
 //
 // TODO: Change this to work generally with any type conversions.
 void mlir::populateShapeTypeConversionPatterns(
-    MLIRContext *context, BufferAssignmentTypeConverter &converter,
+    MLIRContext *context, BufferizeTypeConverter &converter,
     OwningRewritePatternList &patterns) {
   patterns.insert<TypeConversionAssumingOpConverter>(context, converter);
 }