[MLIR] Rename the generic LLVM allocation and deallocation functions

[mscuttari]

Summary

The generic allocation and deallocation instructions, which are optionally used during the MemRef -> LLVM conversion, should have a name that is specifically bound to their origin, that is the conversion pass itself.

[silvas]

:)

[mscuttari]

In D130588#3680438, @silvas wrote:

:)

As in the previous review I need you or Alex to commit for me. Thanks

[silvas]

@ftynse could you merge this for @mscuttari ? - my arc is locally broken and I'm still debugging how to fix it

[mscuttari]

Ping :)

[ftynse]

Sorry, I missed this. Once approved by someone, the patch disappears from the "attention list".

mlir/docs/TargetLLVMIR.md

 
 ### Generic alloction and deallocation functions
 
 When converting the Memref dialect, allocations and deallocations are converted
 into calls to `malloc` (`aligned_alloc` if aligned allocations are requested)
 and `free`. However, it is possible to convert them to more generic functions
 which can be implemented by a runtime library, thus allowing custom allocation
 strategies or runtime profiling. When the conversion pass is  instructed to
-perform such operation, the names of the calles are `_mlir_alloc`,
-`_mlir_aligned_alloc` and `_mlir_free`. Their signatures are the same of
-`malloc`, `aligned_alloc` and `free`.
+perform such operation, the names of the calles are
+`_mlir_memref_to_llvm_alloc`, `_mlir_memref_to_llvm_aligned_alloc` and
+`_mlir_memref_to_llvm_free`. Their signatures are the same of `malloc`,
+`aligned_alloc` and `free`.
 
 ### C-compatible wrapper emission
 
 In practical cases, it may be desirable to have externally-facing functions with
 a single attribute corresponding to a MemRef argument. When interfacing with
 LLVM IR produced from C, the code needs to respect the corresponding calling
 convention. The conversion to the LLVM dialect provides an option to generate
 wrapper functions that take memref descriptors as pointers-to-struct compatible

mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp

 static constexpr llvm::StringRef kPrintF64 = "printF64";
 static constexpr llvm::StringRef kPrintOpen = "printOpen";
 static constexpr llvm::StringRef kPrintClose = "printClose";
 static constexpr llvm::StringRef kPrintComma = "printComma";
 static constexpr llvm::StringRef kPrintNewline = "printNewline";
 static constexpr llvm::StringRef kMalloc = "malloc";
 static constexpr llvm::StringRef kAlignedAlloc = "aligned_alloc";
 static constexpr llvm::StringRef kFree = "free";
-static constexpr llvm::StringRef kGenericAlloc = "_mlir_alloc";
-static constexpr llvm::StringRef kGenericAlignedAlloc = "_mlir_aligned_alloc";
-static constexpr llvm::StringRef kGenericFree = "_mlir_free";
+static constexpr llvm::StringRef kGenericAlloc = "_mlir_memref_to_llvm_alloc";
+static constexpr llvm::StringRef kGenericAlignedAlloc =
+    "_mlir_memref_to_llvm_aligned_alloc";
+static constexpr llvm::StringRef kGenericFree = "_mlir_memref_to_llvm_free";
 static constexpr llvm::StringRef kMemRefCopy = "memrefCopy";
 
 /// Generic print function lookupOrCreate helper.
 LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateFn(ModuleOp moduleOp, StringRef name,
                                               ArrayRef<Type> paramTypes,
                                               Type resultType) {
   auto func = moduleOp.lookupSymbol<LLVM::LLVMFuncOp>(name);
   if (func)

mlir/test/Conversion/MemRefToLLVM/generic-functions.mlir

 // RUN: mlir-opt -pass-pipeline="convert-memref-to-llvm{use-generic-functions=1}" -split-input-file %s \
 // RUN: | FileCheck %s --check-prefix="CHECK-NOTALIGNED"
 
 // RUN: mlir-opt -pass-pipeline="convert-memref-to-llvm{use-generic-functions=1 use-aligned-alloc=1}" -split-input-file %s \
 // RUN: | FileCheck %s --check-prefix="CHECK-ALIGNED"
 
 // CHECK-LABEL: func @alloc()
 func.func @zero_d_alloc() -> memref<f32> {
-// CHECK-NOTALIGNED: llvm.call @_mlir_alloc(%{{.*}}) : (i64) -> !llvm.ptr<i8>
-// CHECK-ALIGNED: llvm.call @_mlir_aligned_alloc(%{{.*}}, %{{.*}}) : (i64, i64) -> !llvm.ptr<i8>
+// CHECK-NOTALIGNED: llvm.call @_mlir_memref_to_llvm_alloc(%{{.*}}) : (i64) -> !llvm.ptr<i8>
+// CHECK-ALIGNED: llvm.call @_mlir_memref_to_llvm_aligned_alloc(%{{.*}}, %{{.*}}) : (i64, i64) -> !llvm.ptr<i8>
   %0 = memref.alloc() : memref<f32>
   return %0 : memref<f32>
 }
 
 // -----
 
 // CHECK-LABEL: func @dealloc()
 func.func @dealloc(%arg0: memref<f32>) {
-// CHECK-NOTALIGNED: llvm.call @_mlir_free(%{{.*}}) : (!llvm.ptr<i8>) -> ()
-// CHECK-ALIGNED: llvm.call @_mlir_free(%{{.*}}) : (!llvm.ptr<i8>) -> ()
+// CHECK-NOTALIGNED: llvm.call @_mlir_memref_to_llvm_free(%{{.*}}) : (!llvm.ptr<i8>) -> ()
+// CHECK-ALIGNED: llvm.call @_mlir_memref_to_llvm_free(%{{.*}}) : (!llvm.ptr<i8>) -> ()
   memref.dealloc %arg0 : memref<f32>
   return
 }