[MLIR] Use memref.copy ops in BufferResultsToOutParams pass.

[wenzhicui]

Summary

Both copy/alloc ops are using memref dialect after this change.

[mehdi_amini]

Can you remove the LinalgDialect from the getDependentDialects in the TableGen definition of this pass?
Also I suspect Linalg can be dropped as a dependency for the library in the CMakeLists.txt file at the same time?

[wenzhicui]

Remove Linalg dependencies.

[wenzhicui]

In D109480#2992204, @mehdi_amini wrote:

Can you remove the LinalgDialect from the getDependentDialects in the TableGen definition of this pass?
Also I suspect Linalg can be dropped as a dependency for the library in the CMakeLists.txt file at the same time?

I have removed Linalg dependency. PTAL.

[bondhugula]

Spell fix in the commit and revision title: Beffer -> Buffer

[wenzhicui]

Fix typo in commit message.

[wenzhicui]

In D109480#2997985, @bondhugula wrote:

Spell fix in the commit and revision title: Beffer -> Buffer

Done.

[akuegel]

This comment was removed by akuegel.

[akuegel]

Regarding the comment I removed: sorry, I had switched to the wrong tab and didn't realize I was posting my comment to the wrong review thread. The one I actually wanted to comment on is https://reviews.llvm.org/D108505

mlir/include/mlir/Transforms/Passes.td

let description = [{
 
     All memref-typed results are appended to the function argument list.
 
     The main issue with this pass (and the out-param calling convention) is that
     buffers for results need to be allocated in the caller. This currently only
     works for static shaped memrefs.
   }];
   let constructor = "mlir::createBufferResultsToOutParamsPass()";
-  let dependentDialects = ["linalg::LinalgDialect", "memref::MemRefDialect"];
+  let dependentDialects = ["memref::MemRefDialect"];
 }
 
 def Canonicalizer : Pass<"canonicalize"> {
   let summary = "Canonicalize operations";
   let description = [{
     This pass performs various types of canonicalizations over a set of
     operations. See [Operation Canonicalization](Canonicalization.md) for more
     details.

mlir/lib/Transforms/BufferResultsToOutParams.cpp

 //===- BufferResultsToOutParams.cpp - Calling convention conversion -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
-#include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
func.walk([&](ReturnOp op) {
     for (Value operand : op.getOperands()) {
       if (operand.getType().isa<BaseMemRefType>())
         copyIntoOutParams.push_back(operand);
       else
         keepAsReturnOperands.push_back(operand);
     }
     OpBuilder builder(op);
     for (auto t : llvm::zip(copyIntoOutParams, appendedEntryArgs))
-      builder.create<linalg::CopyOp>(op.getLoc(), std::get<0>(t),
+      builder.create<memref::CopyOp>(op.getLoc(), std::get<0>(t),
                                      std::get<1>(t));
     builder.create<ReturnOp>(op.getLoc(), keepAsReturnOperands);
     op.erase();
   });
 }
 
 // Updates all CallOps in the scope of the given ModuleOp by allocating
 // temporary buffers for newly introduced out params.

mlir/lib/Transforms/CMakeLists.txt

add_mlir_library(MLIRTransforms
   DEPENDS
   MLIRStandardOpsIncGen
   MLIRTransformsPassIncGen
 
   LINK_LIBS PUBLIC
   MLIRAffine
   MLIRAnalysis
   MLIRCopyOpInterface
-  MLIRLinalg
   MLIRLoopLikeInterface
   MLIRMemRef
   MLIRSCF
   MLIRPass
   MLIRSupport
   MLIRTransformUtils
   MLIRVector
   )

mlir/lib/Transforms/PassDetail.h

 
 namespace mlir {
 class AffineDialect;
 
 // Forward declaration from Dialect.h
 template <typename ConcreteDialect>
 void registerDialect(DialectRegistry &registry);
 
-namespace linalg {
-class LinalgDialect;
-} // end namespace linalg
-
 namespace memref {
 class MemRefDialect;
 } // end namespace memref
 
 #define GEN_PASS_CLASSES
 #include "mlir/Transforms/Passes.h.inc"
 
 } // end namespace mlir
 
 #endif // TRANSFORMS_PASSDETAIL_H_

mlir/test/Transforms/buffer-results-to-out-params.mlir

 // RUN: mlir-opt -buffer-results-to-out-params -split-input-file -verify-diagnostics %s | FileCheck %s
 
 // CHECK-LABEL:   func @basic(
 // CHECK-SAME:                %[[ARG:.*]]: memref<f32>) {
 // CHECK:           %[[RESULT:.*]] = "test.source"() : () -> memref<f32>
-// CHECK:           linalg.copy(%[[RESULT]], %[[ARG]]) : memref<f32>, memref<f32>
+// CHECK:           memref.copy %[[RESULT]], %[[ARG]]  : memref<f32> to memref<f32>
 // CHECK:           return
 // CHECK:         }
 func @basic() -> (memref<f32>) {
   %0 = "test.source"() : () -> (memref<f32>)
   return %0 : memref<f32>
 }
 
 // CHECK-LABEL:   func @presence_of_existing_arguments(
 // CHECK-SAME:                                         %[[ARG0:.*]]: memref<1xf32>,
 // CHECK-SAME:                                         %[[ARG1:.*]]: memref<2xf32>) {
 // CHECK:           %[[RESULT:.*]] = "test.source"() : () -> memref<2xf32>
-// CHECK:           linalg.copy(%[[RESULT]], %[[ARG1]]) : memref<2xf32>, memref<2xf32>
+// CHECK:           memref.copy %[[RESULT]], %[[ARG1]]  : memref<2xf32> to memref<2xf32>
 // CHECK:           return
 // CHECK:         }
 func @presence_of_existing_arguments(%arg0: memref<1xf32>) -> (memref<2xf32>) {
   %0 = "test.source"() : () -> (memref<2xf32>)
   return %0 : memref<2xf32>
 }
 
 // CHECK-LABEL:   func @multiple_results(
 // CHECK-SAME:                           %[[ARG0:.*]]: memref<1xf32>,
 // CHECK-SAME:                           %[[ARG1:.*]]: memref<2xf32>) {
 // CHECK:           %[[RESULTS:.*]]:2 = "test.source"() : () -> (memref<1xf32>, memref<2xf32>)
-// CHECK:           linalg.copy(%[[RESULTS]]#0, %[[ARG0]]) : memref<1xf32>, memref<1xf32>
-// CHECK:           linalg.copy(%[[RESULTS]]#1, %[[ARG1]]) : memref<2xf32>, memref<2xf32>
+// CHECK:           memref.copy %[[RESULTS]]#0, %[[ARG0]]  : memref<1xf32> to memref<1xf32>
+// CHECK:           memref.copy %[[RESULTS]]#1, %[[ARG1]]  : memref<2xf32> to memref<2xf32>
 // CHECK:           return
 // CHECK:         }
 func @multiple_results() -> (memref<1xf32>, memref<2xf32>) {
   %0, %1 = "test.source"() : () -> (memref<1xf32>, memref<2xf32>)
   return %0, %1 : memref<1xf32>, memref<2xf32>
 }
 
 // CHECK-LABEL:   func @non_memref_types(
 // CHECK-SAME:                           %[[OUTPARAM:.*]]: memref<f32>) -> (i1, i32) {
 // CHECK:           %[[RESULT1:.*]]:3 = "test.source"() : () -> (i1, memref<f32>, i32)
-// CHECK:           linalg.copy(%[[RESULT1]]#1, %[[OUTPARAM]]) : memref<f32>, memref<f32>
+// CHECK:           memref.copy %[[RESULT1]]#1, %[[OUTPARAM]]  : memref<f32> to memref<f32>
 // CHECK:           return %[[RESULT1]]#0, %[[RESULT1]]#2 : i1, i32
 // CHECK:         }
 func @non_memref_types() -> (i1, memref<f32>, i32) {
   %0, %1, %2 = "test.source"() : () -> (i1, memref<f32>, i32)
   return %0, %1, %2 : i1, memref<f32>, i32
 }
 
 // CHECK: func private @external_function(memref<f32>)