[mlir] Fix the names of exported functions

[stella.stamenova]

Summary

The names of the functions that are supposed to be exported do not match the implementations. This is due in part to https://github.com/llvm/llvm-project/commit/cac7aabbd8236bef2909bfc0dbba17644f7aaade.

This change makes the implementations and declarations match and adds a couple missing declarations.

The new names follow the pattern of the existing verify functions where the prefix is maintained as _mlir_ciface_ but the suffix follows the new naming convention.

[stella.stamenova]

@mehdi_amini : This patch does not quite work because of the built-in calling convention (https://github.com/llvm/llvm-project-staging/blob/cc926dc3a87af7023aa9b6c392347a0a8ed6949b/mlir/docs/LLVMDialectMemRefConvention.md). Was the goal with the clang-tidy change to also change the convention? I could fix it the other way and undo the clang-tidy to these specific functions instead. This would be a smaller change.

I found this while trying to get the python bindings working on Windows. Since the function declarations are the only place where dllexport is applied, I ran into undefined functions. This is not the case on Ubuntu because all the function definitions also have export "C", so they were being exported despite the function declarations not matching.

[rriddle]

This change LGTM, standardizing around the camelCase naming convention seems desirable here.

[mehdi_amini]

Thanks for fixing this!

mlir/include/mlir/ExecutionEngine/RunnerUtils.h

 }
 
 } // namespace impl
 
 ////////////////////////////////////////////////////////////////////////////////
 // Currently exposed C API.
 ////////////////////////////////////////////////////////////////////////////////
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemrefShapeI8(UnrankedMemRefType<int8_t> *m);
+_mlir_ciface_printMemrefShapeI8(UnrankedMemRefType<int8_t> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemrefShapeI32(UnrankedMemRefType<int32_t> *m);
+_mlir_ciface_printMemrefShapeI32(UnrankedMemRefType<int32_t> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemrefShapeI64(UnrankedMemRefType<int64_t> *m);
+_mlir_ciface_printMemrefShapeI64(UnrankedMemRefType<int64_t> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemrefShapeF32(UnrankedMemRefType<float> *m);
+_mlir_ciface_printMemrefShapeF32(UnrankedMemRefType<float> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemrefShapeF64(UnrankedMemRefType<double> *m);
+_mlir_ciface_printMemrefShapeF64(UnrankedMemRefType<double> *m);
 
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemrefI8(UnrankedMemRefType<int8_t> *m);
+_mlir_ciface_printMemrefI8(UnrankedMemRefType<int8_t> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemrefI32(UnrankedMemRefType<int32_t> *m);
+_mlir_ciface_printMemrefI32(UnrankedMemRefType<int32_t> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemrefF32(UnrankedMemRefType<float> *m);
+_mlir_ciface_printMemrefI64(UnrankedMemRefType<int64_t> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemrefF64(UnrankedMemRefType<double> *m);
+_mlir_ciface_printMemrefF32(UnrankedMemRefType<float> *m);
+extern "C" MLIR_RUNNERUTILS_EXPORT void
+_mlir_ciface_printMemrefF64(UnrankedMemRefType<double> *m);
+
+extern "C" MLIR_RUNNERUTILS_EXPORT int64_t _mlir_ciface_nanoTime();
 
 extern "C" MLIR_RUNNERUTILS_EXPORT void printMemrefI32(int64_t rank, void *ptr);
 extern "C" MLIR_RUNNERUTILS_EXPORT void printMemrefI64(int64_t rank, void *ptr);
 extern "C" MLIR_RUNNERUTILS_EXPORT void printMemrefF32(int64_t rank, void *ptr);
 extern "C" MLIR_RUNNERUTILS_EXPORT void printMemrefF64(int64_t rank, void *ptr);
+extern "C" MLIR_RUNNERUTILS_EXPORT void printCString(char *str);
 
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemref0dF32(StridedMemRefType<float, 0> *m);
+_mlir_ciface_printMemref0dF32(StridedMemRefType<float, 0> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemref1dF32(StridedMemRefType<float, 1> *m);
+_mlir_ciface_printMemref1dF32(StridedMemRefType<float, 1> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemref2dF32(StridedMemRefType<float, 2> *m);
+_mlir_ciface_printMemref2dF32(StridedMemRefType<float, 2> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemref3dF32(StridedMemRefType<float, 3> *m);
+_mlir_ciface_printMemref3dF32(StridedMemRefType<float, 3> *m);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
-mlirCifacePrintMemref4dF32(StridedMemRefType<float, 4> *m);
+_mlir_ciface_printMemref4dF32(StridedMemRefType<float, 4> *m);
 
-extern "C" MLIR_RUNNERUTILS_EXPORT void mlirCifacePrintMemrefVector4x4xf32(
+extern "C" MLIR_RUNNERUTILS_EXPORT void _mlir_ciface_printMemrefVector4x4xf32(
     StridedMemRefType<Vector2D<4, 4, float>, 2> *m);
 
-extern "C" MLIR_RUNNERUTILS_EXPORT int64_t mlirCifaceVerifyMemRefI32(
+extern "C" MLIR_RUNNERUTILS_EXPORT int64_t _mlir_ciface_verifyMemRefI32(
     UnrankedMemRefType<int32_t> *actual, UnrankedMemRefType<int32_t> *expected);
-extern "C" MLIR_RUNNERUTILS_EXPORT int64_t mlirCifaceVerifyMemRefF32(
+extern "C" MLIR_RUNNERUTILS_EXPORT int64_t _mlir_ciface_verifyMemRefF32(
     UnrankedMemRefType<float> *actual, UnrankedMemRefType<float> *expected);
-extern "C" MLIR_RUNNERUTILS_EXPORT int64_t mlirCifaceVerifyMemRefF64(
+extern "C" MLIR_RUNNERUTILS_EXPORT int64_t _mlir_ciface_verifyMemRefF64(
     UnrankedMemRefType<double> *actual, UnrankedMemRefType<double> *expected);
 
 extern "C" MLIR_RUNNERUTILS_EXPORT int64_t verifyMemRefI32(int64_t rank,
                                                            void *actualPtr,
                                                            void *expectedPtr);
 extern "C" MLIR_RUNNERUTILS_EXPORT int64_t verifyMemRefF32(int64_t rank,
                                                            void *actualPtr,
                                                            void *expectedPtr);
 extern "C" MLIR_RUNNERUTILS_EXPORT int64_t verifyMemRefF64(int64_t rank,
                                                            void *actualPtr,
                                                            void *expectedPtr);
 
 #endif // MLIR_EXECUTIONENGINE_RUNNERUTILS_H

mlir/lib/ExecutionEngine/CRunnerUtils.cpp

 extern "C" void printU64(uint64_t u) { fprintf(stdout, "%" PRIu64, u); }
 extern "C" void printF32(float f) { fprintf(stdout, "%g", f); }
 extern "C" void printF64(double d) { fprintf(stdout, "%lg", d); }
 extern "C" void printOpen() { fputs("( ", stdout); }
 extern "C" void printClose() { fputs(" )", stdout); }
 extern "C" void printComma() { fputs(", ", stdout); }
 extern "C" void printNewline() { fputc('\n', stdout); }
 
-extern "C" MLIR_CRUNNERUTILS_EXPORT void
-memrefCopy(int64_t elemSize, UnrankedMemRefType<char> *srcArg,
+extern "C" void memrefCopy(int64_t elemSize, UnrankedMemRefType<char> *srcArg,
                            UnrankedMemRefType<char> *dstArg) {
   DynamicMemRefType<char> src(*srcArg);
   DynamicMemRefType<char> dst(*dstArg);
 
   int64_t rank = src.rank;
   MLIR_MSAN_MEMORY_IS_INITIALIZED(src.sizes, rank * sizeof(int64_t));
 
   // Handle empty shapes -> nothing to copy.
   for (int rankp = 0; rankp < rank; ++rankp)
for (int64_t axis = rank - 1; axis >= 0; --axis) {
       indices[axis] = 0;
       readIndex -= src.sizes[axis] * srcStrides[axis];
       writeIndex -= dst.sizes[axis] * dstStrides[axis];
     }
   }
 }
 
 /// Prints GFLOPS rating.
-extern "C" void print_flops(double flops) {
+extern "C" void printFlops(double flops) {
   fprintf(stderr, "%lf GFLOPS\n", flops / 1.0E9);
 }
 
 /// Returns the number of seconds since Epoch 1970-01-01 00:00:00 +0000 (UTC).
 extern "C" double rtclock() {
 #ifndef _WIN32
   struct timeval tp;
   int stat = gettimeofday(&tp, nullptr);

mlir/lib/ExecutionEngine/RunnerUtils.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/ExecutionEngine/RunnerUtils.h"
 #include <chrono>
 
 // NOLINTBEGIN(*-identifier-naming)
 
-extern "C" void
-_mlir_ciface_print_memref_shape_i8(UnrankedMemRefType<int8_t> *M) {
+extern "C" void _mlir_ciface_printMemrefShapeI8(UnrankedMemRefType<int8_t> *M) {
   std::cout << "Unranked Memref ";
   printMemRefMetaData(std::cout, DynamicMemRefType<int8_t>(*M));
   std::cout << "\n";
 }
 
 extern "C" void
-_mlir_ciface_print_memref_shape_i32(UnrankedMemRefType<int32_t> *M) {
+_mlir_ciface_printMemrefShapeI32(UnrankedMemRefType<int32_t> *M) {
   std::cout << "Unranked Memref ";
   printMemRefMetaData(std::cout, DynamicMemRefType<int32_t>(*M));
   std::cout << "\n";
 }
 
 extern "C" void
-_mlir_ciface_print_memref_shape_i64(UnrankedMemRefType<int64_t> *M) {
+_mlir_ciface_printMemrefShapeI64(UnrankedMemRefType<int64_t> *M) {
   std::cout << "Unranked Memref ";
   printMemRefMetaData(std::cout, DynamicMemRefType<int64_t>(*M));
   std::cout << "\n";
 }
 
-extern "C" void
-_mlir_ciface_print_memref_shape_f32(UnrankedMemRefType<float> *M) {
+extern "C" void _mlir_ciface_printMemrefShapeF32(UnrankedMemRefType<float> *M) {
   std::cout << "Unranked Memref ";
   printMemRefMetaData(std::cout, DynamicMemRefType<float>(*M));
   std::cout << "\n";
 }
 
 extern "C" void
-_mlir_ciface_print_memref_shape_f64(UnrankedMemRefType<double> *M) {
+_mlir_ciface_printMemrefShapeF64(UnrankedMemRefType<double> *M) {
   std::cout << "Unranked Memref ";
   printMemRefMetaData(std::cout, DynamicMemRefType<double>(*M));
   std::cout << "\n";
 }
 
-extern "C" void _mlir_ciface_print_memref_vector_4x4xf32(
+extern "C" void _mlir_ciface_printMemrefVector4x4xf32(
     StridedMemRefType<Vector2D<4, 4, float>, 2> *M) {
   impl::printMemRef(*M);
 }
 
-extern "C" void _mlir_ciface_print_memref_i8(UnrankedMemRefType<int8_t> *M) {
+extern "C" void _mlir_ciface_printMemrefI8(UnrankedMemRefType<int8_t> *M) {
   impl::printMemRef(*M);
 }
 
-extern "C" void _mlir_ciface_print_memref_i32(UnrankedMemRefType<int32_t> *M) {
+extern "C" void _mlir_ciface_printMemrefI32(UnrankedMemRefType<int32_t> *M) {
   impl::printMemRef(*M);
 }
 
-extern "C" void _mlir_ciface_print_memref_i64(UnrankedMemRefType<int64_t> *M) {
+extern "C" void _mlir_ciface_printMemrefI64(UnrankedMemRefType<int64_t> *M) {
   impl::printMemRef(*M);
 }
 
-extern "C" void _mlir_ciface_print_memref_f32(UnrankedMemRefType<float> *M) {
+extern "C" void _mlir_ciface_printMemrefF32(UnrankedMemRefType<float> *M) {
   impl::printMemRef(*M);
 }
 
-extern "C" void _mlir_ciface_print_memref_f64(UnrankedMemRefType<double> *M) {
+extern "C" void _mlir_ciface_printMemrefF64(UnrankedMemRefType<double> *M) {
   impl::printMemRef(*M);
 }
 
-extern "C" int64_t _mlir_ciface_nano_time() {
+extern "C" int64_t _mlir_ciface_nanoTime() {
   auto now = std::chrono::high_resolution_clock::now();
   auto duration = now.time_since_epoch();
   auto nanoseconds =
       std::chrono::duration_cast<std::chrono::nanoseconds>(duration);
   return nanoseconds.count();
 }
 
-extern "C" void print_memref_i32(int64_t rank, void *ptr) {
+extern "C" void printMemrefI32(int64_t rank, void *ptr) {
   UnrankedMemRefType<int32_t> descriptor = {rank, ptr};
-  _mlir_ciface_print_memref_i32(&descriptor);
+  _mlir_ciface_printMemrefI32(&descriptor);
 }
 
-extern "C" void print_memref_i64(int64_t rank, void *ptr) {
+extern "C" void printMemrefI64(int64_t rank, void *ptr) {
   UnrankedMemRefType<int64_t> descriptor = {rank, ptr};
-  _mlir_ciface_print_memref_i64(&descriptor);
+  _mlir_ciface_printMemrefI64(&descriptor);
 }
 
-extern "C" void print_memref_f32(int64_t rank, void *ptr) {
+extern "C" void printMemrefF32(int64_t rank, void *ptr) {
   UnrankedMemRefType<float> descriptor = {rank, ptr};
-  _mlir_ciface_print_memref_f32(&descriptor);
+  _mlir_ciface_printMemrefF32(&descriptor);
 }
 
-extern "C" void print_memref_f64(int64_t rank, void *ptr) {
+extern "C" void printMemrefF64(int64_t rank, void *ptr) {
   UnrankedMemRefType<double> descriptor = {rank, ptr};
-  _mlir_ciface_print_memref_f64(&descriptor);
+  _mlir_ciface_printMemrefF64(&descriptor);
 }
 
-extern "C" void print_c_string(char *str) { printf("%s", str); }
+extern "C" void printCString(char *str) { printf("%s", str); }
 
-extern "C" void
-_mlir_ciface_print_memref_0d_f32(StridedMemRefType<float, 0> *M) {
+extern "C" void _mlir_ciface_printMemref0dF32(StridedMemRefType<float, 0> *M) {
   impl::printMemRef(*M);
 }
-extern "C" void
-_mlir_ciface_print_memref_1d_f32(StridedMemRefType<float, 1> *M) {
+extern "C" void _mlir_ciface_printMemref1dF32(StridedMemRefType<float, 1> *M) {
   impl::printMemRef(*M);
 }
-extern "C" void
-_mlir_ciface_print_memref_2d_f32(StridedMemRefType<float, 2> *M) {
+extern "C" void _mlir_ciface_printMemref2dF32(StridedMemRefType<float, 2> *M) {
   impl::printMemRef(*M);
 }
-extern "C" void
-_mlir_ciface_print_memref_3d_f32(StridedMemRefType<float, 3> *M) {
+extern "C" void _mlir_ciface_printMemref3dF32(StridedMemRefType<float, 3> *M) {
   impl::printMemRef(*M);
 }
-extern "C" void
-_mlir_ciface_print_memref_4d_f32(StridedMemRefType<float, 4> *M) {
+extern "C" void _mlir_ciface_printMemref4dF32(StridedMemRefType<float, 4> *M) {
   impl::printMemRef(*M);
 }
 
 extern "C" int64_t
 _mlir_ciface_verifyMemRefI32(UnrankedMemRefType<int32_t> *actual,
                              UnrankedMemRefType<int32_t> *expected) {
   return impl::verifyMemRef(*actual, *expected);
 }

mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize.mlir

func.func @main() {
 
   // CHECK-NEXT:   call @init_and_dot(%[[cA]], %[[cB]], %[[cC]])
   %res = call @init_and_dot(%AA, %BB, %CC) :
     (tensor<64xf32>, tensor<64xf32>, tensor<f32>) -> tensor<f32>
 
   // CHECK-NEXT:   %[[dC:.*]] = memref.cast %[[C]] : memref<f32> to memref<*xf32>
   %res2 = tensor.cast %res: tensor<f32> to tensor<*xf32>
 
-  // CHECK-NEXT:   call @print_memref_f32(%[[dC]]) : (memref<*xf32>) -> ()
-  call @print_memref_f32(%res2) : (tensor<*xf32>) -> ()
+  // CHECK-NEXT:   call @printMemrefF32(%[[dC]]) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%res2) : (tensor<*xf32>) -> ()
 
   // CHECK-DAG:   memref.dealloc %[[A]] : memref<64xf32>
   // CHECK-DAG:   memref.dealloc %[[B]] : memref<64xf32>
   // CHECK-DAG:   memref.dealloc %[[C]] : memref<f32>
   // CHECK-NEXT:   return
   return
 }
 
-//     CHECK:   func private @print_memref_f32(memref<*xf32>)
-func.func private @print_memref_f32(tensor<*xf32>)
+//     CHECK:   func private @printMemrefF32(memref<*xf32>)
+func.func private @printMemrefF32(tensor<*xf32>)
 
 // -----
 
 // CHECK: #[[$DYNAMIC:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
 
 // CHECK: func private @external_func(memref<?xf32, #[[$DYNAMIC]]>)
 func.func private @external_func(tensor<?xf32>)
 

mlir/test/Dialect/Linalg/library-calls.mlir

 // RUN: mlir-opt %s -convert-linalg-to-std | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 // CHECK:  func private @linalg_fill_f32_viewsxsxf32(f32, memref<?x?xf32, {{.*}}>) attributes {llvm.emit_c_interface}
 // CHECK:  func private @linalg_matmul_viewsxsxf32_viewsxsxf32_viewsxsxf32(memref<?x?xf32, {{.*}}>, memref<?x?xf32, {{.*}}>, memref<?x?xf32, {{.*}}>) attributes {llvm.emit_c_interface}
 
 func.func @matmul(%A: memref<?x?xf32>, %B: memref<?x?xf32>) -> (memref<?x?xf32>) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %f0 = arith.constant 0.0 : f32

mlir/test/Integration/Dialect/Async/CPU/microbench-linalg-async-parallel-for.mlir

func.func @entry() {
   %RHS = memref.cast %RHS10 : memref<1x10xf32> to memref<?x?xf32>
   %DST = memref.cast %DST10 : memref<1x10xf32> to memref<?x?xf32>
 
   call @linalg_generic(%LHS, %RHS, %DST)
     : (memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>) -> ()
 
   // CHECK: [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
   %U = memref.cast %DST10 :  memref<1x10xf32> to memref<*xf32>
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   memref.dealloc %LHS10: memref<1x10xf32>
   memref.dealloc %RHS10: memref<1x10xf32>
   memref.dealloc %DST10: memref<1x10xf32>
 
   //
   // Allocate data for microbenchmarks.
   //
func.func @entry() {
   memref.dealloc %RHS1024: memref<1024x1024xf32>
   memref.dealloc %DST1024: memref<1024x1024xf32>
 
   return
 }
 
 func.func private @rtclock() -> f64
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
   attributes { llvm.emit_c_interface }

mlir/test/Integration/Dialect/Async/CPU/microbench-scf-async-parallel-for.mlir

func.func @entry() {
   %RHS = memref.cast %RHS10 : memref<1x10xf32> to memref<?x?xf32>
   %DST = memref.cast %DST10 : memref<1x10xf32> to memref<?x?xf32>
 
   call @scf_parallel(%LHS, %RHS, %DST)
     : (memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>) -> ()
 
   // CHECK: [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
   %U = memref.cast %DST10 :  memref<1x10xf32> to memref<*xf32>
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   memref.dealloc %LHS10: memref<1x10xf32>
   memref.dealloc %RHS10: memref<1x10xf32>
   memref.dealloc %DST10: memref<1x10xf32>
 
   //
   // Allocate data for microbenchmarks.
   //
func.func @entry() {
   memref.dealloc %RHS1024: memref<1024x1024xf32>
   memref.dealloc %DST1024: memref<1024x1024xf32>
 
   return
 }
 
 func.func private @rtclock() -> f64
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
   attributes { llvm.emit_c_interface }

mlir/test/Integration/Dialect/Async/CPU/test-async-parallel-for-1d.mlir

func.func @entry() {
   scf.parallel (%i) = (%lb) to (%ub) step (%c1) {
     %0 = arith.index_cast %i : index to i32
     %1 = arith.sitofp %0 : i32 to f32
     %2 = memref.load %A[%i] : memref<9xf32>
     %3 = arith.addf %1, %2 : f32
     memref.store %3, %A[%i] : memref<9xf32>
   }
   // CHECK: [0, 1, 2, 3, 4, 5, 6, 7, 8]
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   scf.parallel (%i) = (%lb) to (%ub) step (%c1) {
     memref.store %c0, %A[%i] : memref<9xf32>
   }
 
   // 2. %i = (0) to (9) step (2)
   scf.parallel (%i) = (%lb) to (%ub) step (%c2) {
     %0 = arith.index_cast %i : index to i32
     %1 = arith.sitofp %0 : i32 to f32
     %2 = memref.load %A[%i] : memref<9xf32>
     %3 = arith.addf %1, %2 : f32
     memref.store %3, %A[%i] : memref<9xf32>
   }
   // CHECK:  [0, 0, 2, 0, 4, 0, 6, 0, 8]
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   scf.parallel (%i) = (%lb) to (%ub) step (%c1) {
     memref.store %c0, %A[%i] : memref<9xf32>
   }
 
   // 3. %i = (-20) to (-11) step (3)
   %lb0 = arith.constant -20 : index
   %ub0 = arith.constant -11 : index
   scf.parallel (%i) = (%lb0) to (%ub0) step (%c3) {
     %0 = arith.index_cast %i : index to i32
     %1 = arith.sitofp %0 : i32 to f32
     %2 = arith.constant 20 : index
     %3 = arith.addi %i, %2 : index
     %4 = memref.load %A[%3] : memref<9xf32>
     %5 = arith.addf %1, %4 : f32
     memref.store %5, %A[%3] : memref<9xf32>
   }
   // CHECK: [-20, 0, 0, -17, 0, 0, -14, 0, 0]
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   // 4. Check that loop with zero iterations doesn't crash at runtime.
   %lb1 = call @zero(): () -> (index)
   %ub1 = call @zero(): () -> (index)
 
   scf.parallel (%i) = (%lb1) to (%ub1) step (%c1) {
     %false = arith.constant 0 : i1
     cf.assert %false, "should never be executed"
   }
 
   memref.dealloc %A : memref<9xf32>
   return
 }
 
-func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }

mlir/test/Integration/Dialect/Async/CPU/test-async-parallel-for-2d.mlir

func.func @entry() {
   // CHECK:      [0, 1, 2, 3, 4, 5, 6, 7]
   // CHECK-NEXT: [8, 9, 10, 11, 12, 13, 14, 15]
   // CHECK-NEXT: [16, 17, 18, 19, 20, 21, 22, 23]
   // CHECK-NEXT: [24, 25, 26, 27, 28, 29, 30, 31]
   // CHECK-NEXT: [32, 33, 34, 35, 36, 37, 38, 39]
   // CHECK-NEXT: [40, 41, 42, 43, 44, 45, 46, 47]
   // CHECK-NEXT: [48, 49, 50, 51, 52, 53, 54, 55]
   // CHECK-NEXT: [56, 57, 58, 59, 60, 61, 62, 63]
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   scf.parallel (%i, %j) = (%lb, %lb) to (%ub, %ub) step (%c1, %c1) {
     memref.store %c0, %A[%i, %j] : memref<8x8xf32>
   }
 
   // 2. (%i, %i) = (0, 8) to (8, 8) step (2, 1)
   scf.parallel (%i, %j) = (%lb, %lb) to (%ub, %ub) step (%c2, %c1) {
     %0 = arith.muli %i, %c8 : index
     %1 = arith.addi %j, %0  : index
     %2 = arith.index_cast %1 : index to i32
     %3 = arith.sitofp %2 : i32 to f32
     %4 = memref.load %A[%i, %j] : memref<8x8xf32>
     %5 = arith.addf %3, %4 : f32
     memref.store %5, %A[%i, %j] : memref<8x8xf32>
   }
 
   // CHECK:      [0, 1, 2, 3, 4, 5, 6, 7]
   // CHECK-NEXT: [0, 0, 0, 0, 0, 0, 0, 0]
   // CHECK-NEXT: [16, 17, 18, 19, 20, 21, 22, 23]
   // CHECK-NEXT: [0, 0, 0, 0, 0, 0, 0, 0]
   // CHECK-NEXT: [32, 33, 34, 35, 36, 37, 38, 39]
   // CHECK-NEXT: [0, 0, 0, 0, 0, 0, 0, 0]
   // CHECK-NEXT: [48, 49, 50, 51, 52, 53, 54, 55]
   // CHECK-NEXT: [0, 0, 0, 0, 0, 0, 0, 0]
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   scf.parallel (%i, %j) = (%lb, %lb) to (%ub, %ub) step (%c1, %c1) {
     memref.store %c0, %A[%i, %j] : memref<8x8xf32>
   }
 
   // 3. (%i, %i) = (0, 8) to (8, 8) step (1, 2)
   scf.parallel (%i, %j) = (%lb, %lb) to (%ub, %ub) step (%c1, %c2) {
     %0 = arith.muli %i, %c8 : index
     %1 = arith.addi %j, %0  : index
     %2 = arith.index_cast %1 : index to i32
     %3 = arith.sitofp %2 : i32 to f32
     %4 = memref.load %A[%i, %j] : memref<8x8xf32>
     %5 = arith.addf %3, %4 : f32
     memref.store %5, %A[%i, %j] : memref<8x8xf32>
   }
 
   // CHECK:      [0, 0, 2, 0, 4, 0, 6, 0]
   // CHECK-NEXT: [8, 0, 10, 0, 12, 0, 14, 0]
   // CHECK-NEXT: [16, 0, 18, 0, 20, 0, 22, 0]
   // CHECK-NEXT: [24, 0, 26, 0, 28, 0, 30, 0]
   // CHECK-NEXT: [32, 0, 34, 0, 36, 0, 38, 0]
   // CHECK-NEXT: [40, 0, 42, 0, 44, 0, 46, 0]
   // CHECK-NEXT: [48, 0, 50, 0, 52, 0, 54, 0]
   // CHECK-NEXT: [56, 0, 58, 0, 60, 0, 62, 0]
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   memref.dealloc %A : memref<8x8xf32>
 
   return
 }
 
-func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }

mlir/test/Integration/Dialect/Linalg/CPU/matmul-vs-matvec.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 func.func @matmul(%A: memref<?x?xf32>, %B: memref<?x?xf32>) -> (memref<?x?xf32>) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %f0 = arith.constant 0.0 : f32
   %x = memref.dim %A, %c0 : memref<?x?xf32>
   %y = memref.dim %B, %c1 : memref<?x?xf32>
   %C = memref.alloc(%x, %y) : memref<?x?xf32>
scf.for %i = %c0 to %m step %c1 {
     scf.for %j = %c0 to %n step %c1 {
       %e1 = memref.load %C1[%i, %j] : memref<?x?xf32>
       %e2 = memref.load %C2[%i, %j] : memref<?x?xf32>
       %c = arith.cmpf oeq, %e1, %e2 : f32
       cf.assert %c, "Matmul does not produce same output as matvec"
     }
   }
   %C2_ = memref.cast %C2 : memref<?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%C2_) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%C2_) : (memref<*xf32>) -> ()
   memref.dealloc %C1 : memref<?x?xf32>
   memref.dealloc %C2 : memref<?x?xf32>
   return
 }
 
 // CHECK: Unranked Memref base@ = {{.*}} rank = 2 offset = 0 sizes = [5, 2] strides = [2, 1] data =
 // CHECK-NEXT:      [
 // CHECK-SAME:  [611,   663],
 // CHECK-NEXT:  [611,   663],
 // CHECK-NEXT:  [611,   663],
 // CHECK-NEXT:  [611,   663],
 // CHECK-NEXT:  [611,   663]
 // CHECK-SAME: ]

mlir/test/Integration/Dialect/Linalg/CPU/rank-reducing-subview.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 func.func @main() {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c2 = arith.constant 2 : index
   %f0 = arith.constant 0.0 : f32
   %f1 = arith.constant 1.0 : f32
   %f2 = arith.constant 2.0 : f32
   %f3 = arith.constant 3.0 : f32
   %A = memref.alloc(%c2, %c2) : memref<?x?xf32>
   memref.store %f0, %A[%c0, %c0] : memref<?x?xf32>
   memref.store %f1, %A[%c0, %c1] : memref<?x?xf32>
   memref.store %f2, %A[%c1, %c0] : memref<?x?xf32>
   memref.store %f3, %A[%c1, %c1] : memref<?x?xf32>
   %B = memref.subview %A[%c1, 0][1, %c2][1, 1] : memref<?x?xf32> to memref<?xf32, offset: ?, strides: [1]>
   %C = memref.subview %A[0, %c1][%c2, 1][1, 1] : memref<?x?xf32> to memref<?xf32, offset: ?, strides: [?]>
   %A_ = memref.cast %A : memref<?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%A_) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%A_) : (memref<*xf32>) -> ()
   %B_ = memref.cast %B : memref<?xf32, offset: ?, strides: [1]> to memref<*xf32>
-  call @print_memref_f32(%B_) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%B_) : (memref<*xf32>) -> ()
   %C_ = memref.cast %C : memref<?xf32, offset: ?, strides: [?]> to memref<*xf32>
-  call @print_memref_f32(%C_) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%C_) : (memref<*xf32>) -> ()
   memref.dealloc %A : memref<?x?xf32>
   return
 }
 
 // CHECK: Unranked Memref base@ = {{.*}} rank = 2 offset = 0 sizes = [2, 2] strides = [2, 1] data =
 // CHECK-NEXT:      [
 // CHECK-SAME:  [0,   1],
 // CHECK-NEXT:  [2,   3]
 // CHECK-SAME: ]
 // CHECK: [2,  3]
 // CHECK: [1,  3]

mlir/test/Integration/Dialect/Linalg/CPU/test-collapse-tensor.mlir

 // RUN: mlir-opt %s -linalg-bufferize \
 // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
 // RUN: -finalizing-bufferize -buffer-deallocation -convert-linalg-to-llvm \
 // RUN: -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 
 func.func @main() {
   %const = arith.constant dense<[[[[-3.9058,0.9072],[-2.9470,-2.2055],[18.3946,8.2997]],[[3.4700,5.9006],[-17.2267,4.9777],[1.0450,-0.8201]]],[[[17.6996,-11.1763],[26.7775,-3.8823],[-4.2492,-5.8966]],[[2.1259,13.1794],[-10.7136,0.8428],[16.4233,9.4589]]]]> : tensor<2x2x3x2xf32>
   %dynamic = tensor.cast %const: tensor<2x2x3x2xf32> to tensor<2x?x?x?xf32>
   %collapsed = call @collapse_dynamic_shape(%dynamic) : (tensor<2x?x?x?xf32>) -> (tensor<2x?x?xf32>)
   %unranked = tensor.cast %collapsed: tensor<2x?x?xf32> to tensor<*xf32>
-  call @print_memref_f32(%unranked) : (tensor<*xf32>) -> ()
+  call @printMemrefF32(%unranked) : (tensor<*xf32>) -> ()
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 3 offset = 0 sizes = [2, 6, 2] strides = [12, 2, 1] data =
   // CHECK-NEXT{LITERAL}: [[[-3.9058,    0.9072],
   // CHECK-NEXT: [-2.947,    -2.2055],
   // CHECK-NEXT: [18.3946,    8.2997],
   // CHECK-NEXT: [3.47,    5.9006],
   // CHECK-NEXT: [-17.2267,    4.9777],
   // CHECK-NEXT: [1.045,    -0.8201]],
   // CHECK-NEXT{LITERAL}: [[17.6996,    -11.1763],
   // CHECK-NEXT: [26.7775,    -3.8823],
   // CHECK-NEXT: [-4.2492,    -5.8966],
   // CHECK-NEXT: [2.1259,    13.1794],
   // CHECK-NEXT: [-10.7136,    0.8428],
   // CHECK-NEXT: [16.4233,    9.4589]]]
   return
 }
 
-func.func private @print_memref_f32(%ptr : tensor<*xf32>)
+func.func private @printMemrefF32(%ptr : tensor<*xf32>)
 
 func.func @collapse_dynamic_shape(%arg0 : tensor<2x?x?x?xf32>) -> tensor<2x?x?xf32> {
   %0 = tensor.collapse_shape %arg0 [[0], [1, 2], [3]]: tensor<2x?x?x?xf32> into tensor<2x?x?xf32>
   return %0 : tensor<2x?x?xf32>
 }

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-call.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 // RUN: mlir-opt %s -linalg-tile="tile-sizes=4" -convert-linalg-to-loops -convert-scf-to-cf \
 // RUN:   -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 // Creates and returns a 1-D buffer of size %s1 filled with the value %f
 func.func @alloc_1d_filled_f32(%s1 : index, %f : f32) -> memref<?xf32> {
   %buf = memref.alloc(%s1) : memref<?xf32>
   linalg.fill ins(%f : f32) outs(%buf : memref<?xf32>)
   return %buf : memref<?xf32>
 }
 
func.func @main() {
 
   %filter1D = call @alloc_1d_filled_f32(%c3, %val) : (index, f32) -> (memref<?xf32>)
   %in1D = call @alloc_1d_filled_f32(%c8, %val) : (index, f32) -> (memref<?xf32>)
   %out1D = call @alloc_1d_filled_f32(%c6, %zero) : (index, f32) -> (memref<?xf32>)
 
   memref.store %f10, %in1D[%c3] : memref<?xf32>
   call @conv_1d(%in1D, %filter1D, %out1D) : (memref<?xf32>, memref<?xf32>, memref<?xf32>) -> ()
   %out1D_ = memref.cast %out1D : memref<?xf32> to memref<*xf32>
-  call @print_memref_f32(%out1D_): (memref<*xf32>) -> ()
+  call @printMemrefF32(%out1D_): (memref<*xf32>) -> ()
 
   memref.dealloc %filter1D : memref<?xf32>
   memref.dealloc %in1D : memref<?xf32>
   memref.dealloc %out1D : memref<?xf32>
   return
 }
 
 // CHECK:       Unranked Memref {{.*}}
 // CHECK-NEXT:  [12, 28, 28, 28, 12, 12]

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-nwc-wcf-call.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 // RUN: mlir-opt %s -linalg-tile="tile-sizes=2,4" -convert-linalg-to-loops -convert-scf-to-cf \
 // RUN:   -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 // Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f
 func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> {
   %buf = memref.alloc(%s1, %s2, %s3) : memref<?x?x?xf32>
   linalg.fill ins(%f : f32) outs(%buf : memref<?x?x?xf32>)
   return %buf : memref<?x?x?xf32>
 }
 
func.func @main() {
 
   %filter1D_nwc = call @alloc_3d_filled_f32(%c3, %c1, %c1, %val) : (index, index, index, f32) -> (memref<?x?x?xf32>)
   %in1D_nwc = call @alloc_3d_filled_f32(%c3, %c8, %c1, %val) : (index, index, index, f32) -> (memref<?x?x?xf32>)
   %out1D_nwc = call @alloc_3d_filled_f32(%c3, %c6, %c1, %zero) : (index, index, index, f32) -> (memref<?x?x?xf32>)
 
   memref.store %f10, %in1D_nwc[%c0, %c3, %c0] : memref<?x?x?xf32>
   call @conv_1d_nwc_wcf(%in1D_nwc, %filter1D_nwc, %out1D_nwc) : (memref<?x?x?xf32>, memref<?x?x?xf32>, memref<?x?x?xf32>) -> ()
   %out1D_nwc_ = memref.cast %out1D_nwc : memref<?x?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%out1D_nwc_): (memref<*xf32>) -> ()
+  call @printMemrefF32(%out1D_nwc_): (memref<*xf32>) -> ()
 
   memref.dealloc %filter1D_nwc : memref<?x?x?xf32>
   memref.dealloc %in1D_nwc : memref<?x?x?xf32>
   memref.dealloc %out1D_nwc : memref<?x?x?xf32>
   return
 }
 
 // CHECK:       Unranked Memref {{.*}}

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-call.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 // RUN: mlir-opt %s -linalg-tile="tile-sizes=2,2" -convert-linalg-to-loops -convert-scf-to-cf \
 // RUN:   -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 // Creates and returns a 2-D buffer of size (%s1, %s2) filled with the value %f
 func.func @alloc_2d_filled_f32(%s1 : index, %s2 : index, %f : f32) -> memref<?x?xf32> {
   %buf = memref.alloc(%s1, %s2) : memref<?x?xf32>
   linalg.fill ins(%f : f32) outs(%buf : memref<?x?xf32>)
   return %buf : memref<?x?xf32>
 }
 
func.func @main() {
 
   %filter2D = call @alloc_2d_filled_f32(%c3, %c3, %val) : (index, index, f32) -> (memref<?x?xf32>)
   %in2D = call @alloc_2d_filled_f32(%c8, %c8, %val) : (index, index, f32) -> (memref<?x?xf32>)
   %out2D = call @alloc_2d_filled_f32(%c6, %c6, %zero) : (index, index, f32) -> (memref<?x?xf32>)
 
   memref.store %f10, %in2D[%c0, %c3] : memref<?x?xf32>
   call @conv_2d(%in2D, %filter2D, %out2D) : (memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>) -> ()
   %out2D_ = memref.cast %out2D : memref<?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%out2D_): (memref<*xf32>) -> ()
+  call @printMemrefF32(%out2D_): (memref<*xf32>) -> ()
 
   memref.dealloc %filter2D : memref<?x?xf32>
   memref.dealloc %in2D : memref<?x?xf32>
   memref.dealloc %out2D : memref<?x?xf32>
   return
 }
 
 // CHECK:        Unranked Memref {{.*}}
 // CHECK-NEXT:   [
 // CHECK-SAME:    [36,   52,   52,   52,   36,   36],
 // CHECK-COUNT-5: [36,   36,   36,   36,   36,   36]
 // CHECK-SAME:   ]

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-nhwc-hwcf-call.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 // RUN: mlir-opt %s -linalg-tile="tile-sizes=2,3,3,2" -convert-linalg-to-loops -convert-scf-to-cf \
 // RUN:   -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 // Creates and returns 4-D buffer of size (%s1, %s2, %s3, %s4) filled with the value %f
 func.func @alloc_4d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %f : f32) -> memref<?x?x?x?xf32> {
   %buf = memref.alloc(%s1, %s2, %s3, %s4) : memref<?x?x?x?xf32>
   linalg.fill ins(%f : f32) outs(%buf : memref<?x?x?x?xf32>)
   return %buf : memref<?x?x?x?xf32>
 }
 
func.func @main() {
 
   %filter2D_nhwc = call @alloc_4d_filled_f32(%c3, %c3, %c3, %c1, %val) :(index, index, index, index, f32) -> (memref<?x?x?x?xf32>)
   %in2D_nhwc = call @alloc_4d_filled_f32(%c3, %c8, %c8, %c3, %val) : (index, index, index, index, f32) -> (memref<?x?x?x?xf32>)
   %out2D_nhwc = call @alloc_4d_filled_f32(%c3, %c6, %c6, %c1, %zero) : (index, index, index, index, f32) -> (memref<?x?x?x?xf32>)
 
   memref.store %f10, %in2D_nhwc[%c0, %c0, %c3, %c0] : memref<?x?x?x?xf32>
   call @conv_2d_nhwc_hwcf(%in2D_nhwc, %filter2D_nhwc, %out2D_nhwc) : (memref<?x?x?x?xf32>, memref<?x?x?x?xf32>, memref<?x?x?x?xf32>) -> ()
   %out2D_nhwc_ = memref.cast %out2D_nhwc : memref<?x?x?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%out2D_nhwc_): (memref<*xf32>) -> ()
+  call @printMemrefF32(%out2D_nhwc_): (memref<*xf32>) -> ()
 
   memref.dealloc %filter2D_nhwc : memref<?x?x?x?xf32>
   memref.dealloc %in2D_nhwc : memref<?x?x?x?xf32>
   memref.dealloc %out2D_nhwc : memref<?x?x?x?xf32>
   return
 }
 
 // CHECK:       Unranked Memref {{.*}}

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-call.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 // RUN: mlir-opt %s -linalg-tile="tile-sizes=2,2,2" -convert-linalg-to-loops -convert-scf-to-cf \
 // RUN:   -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 // Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f
 func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> {
   %buf = memref.alloc(%s1, %s2, %s3) : memref<?x?x?xf32>
   linalg.fill ins(%f : f32) outs(%buf : memref<?x?x?xf32>)
   return %buf : memref<?x?x?xf32>
 }
 
func.func @main() {
 
   %filter3D = call @alloc_3d_filled_f32(%c3, %c3, %c3, %val) : (index, index, index, f32) -> (memref<?x?x?xf32>)
   %in3D = call @alloc_3d_filled_f32(%c8, %c8, %c8, %val) : (index, index, index, f32) -> (memref<?x?x?xf32>)
   %out3D = call @alloc_3d_filled_f32(%c6, %c6, %c6, %zero) : (index, index, index, f32) -> (memref<?x?x?xf32>)
 
   memref.store %f10, %in3D[%c0, %c0, %c3] : memref<?x?x?xf32>
   call @conv_3d(%in3D, %filter3D, %out3D) : (memref<?x?x?xf32>, memref<?x?x?xf32>, memref<?x?x?xf32>) -> ()
   %out3D_ = memref.cast %out3D : memref<?x?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%out3D_): (memref<*xf32>) -> ()
+  call @printMemrefF32(%out3D_): (memref<*xf32>) -> ()
 
   memref.dealloc %filter3D : memref<?x?x?xf32>
   memref.dealloc %in3D : memref<?x?x?xf32>
   memref.dealloc %out3D : memref<?x?x?xf32>
   return
 }
 
 // CHECK:       Unranked Memref {{.*}}

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-ndhwc-dhwcf-call.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 // RUN: mlir-opt %s -linalg-tile="tile-sizes=0,5,5,5" -convert-linalg-to-loops -convert-scf-to-cf \
 // RUN:   -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 // Creates and returns 5-D buffer of size (%s1, %s2, %s3, %s4, %s5) filled with the value %f
 func.func @alloc_5d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %s5 : index, %f : f32) -> memref<?x?x?x?x?xf32> {
   %buf = memref.alloc(%s1, %s2, %s3, %s4, %s5) : memref<?x?x?x?x?xf32>
   linalg.fill ins(%f : f32) outs(%buf : memref<?x?x?x?x?xf32>)
   return %buf : memref<?x?x?x?x?xf32>
 }
 
func.func @main() {
 
   %filter3D_ndhwc = call @alloc_5d_filled_f32(%c3, %c3, %c3, %c1, %c1, %val) : (index, index, index, index, index, f32) -> (memref<?x?x?x?x?xf32>)
   %in3D_ndhwc = call @alloc_5d_filled_f32(%c1, %c8, %c8, %c8, %c1, %val) : (index, index, index, index, index, f32) -> (memref<?x?x?x?x?xf32>)
   %out3D_ndhwc = call @alloc_5d_filled_f32(%c1, %c6, %c6, %c6, %c1, %zero) : (index, index, index, index, index, f32) -> (memref<?x?x?x?x?xf32>)
 
   memref.store %f10, %in3D_ndhwc[%c0, %c0, %c0, %c3, %c0] : memref<?x?x?x?x?xf32>
   call @conv_3d_ndhwc_dhwcf(%in3D_ndhwc, %filter3D_ndhwc, %out3D_ndhwc) : (memref<?x?x?x?x?xf32>, memref<?x?x?x?x?xf32>, memref<?x?x?x?x?xf32>) -> ()
   %out3D_ndhwc_ = memref.cast %out3D_ndhwc : memref<?x?x?x?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%out3D_ndhwc_): (memref<*xf32>) -> ()
+  call @printMemrefF32(%out3D_ndhwc_): (memref<*xf32>) -> ()
 
   memref.dealloc %filter3D_ndhwc : memref<?x?x?x?x?xf32>
   memref.dealloc %in3D_ndhwc : memref<?x?x?x?x?xf32>
   memref.dealloc %out3D_ndhwc : memref<?x?x?x?x?xf32>
   return
 }
 
 // CHECK:       Unranked Memref {{.*}}

mlir/test/Integration/Dialect/Linalg/CPU/test-elementwise.mlir

 // RUN: mlir-opt %s -convert-elementwise-to-linalg \
 // RUN: -arith-bufferize -linalg-bufferize -tensor-bufferize \
 // RUN: -func-bufferize -buffer-deallocation -convert-linalg-to-loops \
 // RUN: -convert-linalg-to-llvm --convert-memref-to-llvm -convert-func-to-llvm \
 // RUN: -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 func.func @main() {
   %a = arith.constant dense<[1.0, 2.0, 3.0]> : tensor<3xf32>
   %b = arith.constant dense<[10.0, 20.0, 30.0]> : tensor<3xf32>
 
   %addf = arith.addf %a, %b : tensor<3xf32>
   %addf_unranked = tensor.cast %addf : tensor<3xf32> to tensor<*xf32>
-  call @print_memref_f32(%addf_unranked) : (tensor<*xf32>) -> ()
+  call @printMemrefF32(%addf_unranked) : (tensor<*xf32>) -> ()
   // CHECK: Unranked Memref base@ = {{.*}} rank = 1 offset = 0 sizes = [3] strides = [1] data =
   // CHECK-NEXT: [11,  22,  33]
 
   return
 }
 
-func.func private @print_memref_f32(%ptr : tensor<*xf32>)
+func.func private @printMemrefF32(%ptr : tensor<*xf32>)

mlir/test/Integration/Dialect/Linalg/CPU/test-expand-tensor.mlir

 // RUN: mlir-opt %s -linalg-bufferize \
 // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
 // RUN: -finalizing-bufferize -buffer-deallocation -convert-linalg-to-llvm \
 // RUN: -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 
 func.func @main() {
   %const = arith.constant dense<[[[-3.9058,0.9072],[-2.9470,-2.2055],[18.3946,8.2997],[3.4700,5.9006],[-17.2267,4.9777],[1.0450,-0.8201]],[[17.6996,-11.1763],[26.7775,-3.8823],[-4.2492,-5.8966],[2.1259,13.1794],[-10.7136,0.8428],[16.4233,9.4589]]]> : tensor<2x6x2xf32>
   %dynamic = tensor.cast %const: tensor<2x6x2xf32> to tensor<2x?x?xf32>
   %expanded = call @expand_dynamic_shape(%dynamic) : (tensor<2x?x?xf32>) -> (tensor<2x2x?x1x?xf32>)
   %unranked = tensor.cast %expanded: tensor<2x2x?x1x?xf32> to tensor<*xf32>
-  call @print_memref_f32(%unranked) : (tensor<*xf32>) -> ()
+  call @printMemrefF32(%unranked) : (tensor<*xf32>) -> ()
 
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 5 offset = 0 sizes = [2, 2, 3, 1, 2] strides = [12, 6, 2, 2, 1] data =
   // CHECK-NEXT{LITERAL}: [[[[[-3.9058,      0.9072]],
   // CHECK-NEXT{LITERAL}:   [[-2.947,      -2.2055]],
   // CHECK-NEXT{LITERAL}:   [[18.3946,      8.2997]]],
   // CHECK-NEXT{LITERAL}:  [[[3.47,      5.9006]],
   // CHECK-NEXT{LITERAL}:   [[-17.2267,      4.9777]],
   // CHECK-NEXT{LITERAL}:   [[1.045,      -0.8201]]]],
   // CHECK-NEXT{LITERAL}: [[[[17.6996,      -11.1763]],
   // CHECK-NEXT{LITERAL}:   [[26.7775,      -3.8823]],
   // CHECK-NEXT{LITERAL}:   [[-4.2492,      -5.8966]]],
   // CHECK-NEXT{LITERAL}:  [[[2.1259,      13.1794]],
   // CHECK-NEXT{LITERAL}:   [[-10.7136,      0.8428]],
   // CHECK-NEXT{LITERAL}:   [[16.4233,      9.4589]]]]]
   return
 }
 
-func.func private @print_memref_f32(%ptr : tensor<*xf32>)
+func.func private @printMemrefF32(%ptr : tensor<*xf32>)
 
 func.func @expand_dynamic_shape(%arg0 : tensor<2x?x?xf32>) -> tensor<2x2x?x1x?xf32> {
   %0 = tensor.expand_shape %arg0 [[0], [1, 2, 3], [4]]: tensor<2x?x?xf32> into tensor<2x2x?x1x?xf32>
   return %0 : tensor<2x2x?x1x?xf32>
 }

mlir/test/Integration/Dialect/Linalg/CPU/test-one-shot-bufferize.mlir

%3 = scf.for %arg3 = %c0 to %c64 step %c2 iter_args(%arg4 = %2) -> (tensor<?x2xf32>) {
     ^bb0(%arg5: index):
       tensor.yield %cst : f32
     } : tensor<?xf32> to tensor<2xf32>
     %12 = tensor.insert_slice %11 into %arg4[%8, 0] [1, 2] [1, 1] : tensor<2xf32> into tensor<?x2xf32>
     scf.yield %12 : tensor<?x2xf32>
   }
 
   // %B = tensor.cast %3 : tensor<?x2xf32> to tensor<*xf32>
-  // call @print_memref_f32(%B) : (tensor<*xf32>) -> ()
+  // call @printMemrefF32(%B) : (tensor<*xf32>) -> ()
 
   %4 = affine.apply #map0(%c0, %c64)[%c2]
   %5 = linalg.init_tensor [%4, 2] : tensor<?x2xf32>
   %6 = scf.for %arg3 = %c0 to %c64 step %c2 iter_args(%arg4 = %5) -> (tensor<?x2xf32>) {
     %8 = affine.apply #map1(%arg3, %c0)[%c2]
     %9 = tensor.extract_slice %arg0[%arg3] [2] [1] : tensor<64xf32> to tensor<2xf32>
     %10 = tensor.cast %9 : tensor<2xf32> to tensor<?xf32>
     %11 = tensor.pad %10 low[%c0] high[%c0]  {
     ^bb0(%arg5: index):  
       tensor.yield %cst : f32
     } : tensor<?xf32> to tensor<2xf32>
     %12 = tensor.insert_slice %11 into %arg4[%8, 0] [1, 2] [1, 1] : tensor<2xf32> into tensor<?x2xf32>
     scf.yield %12 : tensor<?x2xf32>
   }
 
   // %A = tensor.cast %6 : tensor<?x2xf32> to tensor<*xf32>
-  // call @print_memref_f32(%A) : (tensor<*xf32>) -> ()
+  // call @printMemrefF32(%A) : (tensor<*xf32>) -> ()
 
   // %C = tensor.cast %0 : tensor<f32> to tensor<*xf32>
-  // call @print_memref_f32(%C) : (tensor<*xf32>) -> ()
+  // call @printMemrefF32(%C) : (tensor<*xf32>) -> ()
 
   %7 = scf.for %arg3 = %c0 to %c64 step %c2 iter_args(%arg4 = %0) -> (tensor<f32>) {
     %8 = tensor.extract_slice %arg0[%arg3] [2] [1] : tensor<64xf32> to tensor<2xf32>
     %9 = tensor.cast %8 : tensor<2xf32> to tensor<?xf32>
     %10 = tensor.extract_slice %arg1[%arg3] [2] [1] : tensor<64xf32> to tensor<2xf32>
     %11 = tensor.cast %10 : tensor<2xf32> to tensor<?xf32>
     %12 = affine.apply #map1(%arg3, %c0)[%c2]
     %13 = tensor.extract_slice %6[%12, 0] [1, 2] [1, 1] : tensor<?x2xf32> to tensor<2xf32>
     %14 = affine.apply #map1(%arg3, %c0)[%c2]
     %15 = tensor.extract_slice %3[%14, 0] [1, 2] [1, 1] : tensor<?x2xf32> to tensor<2xf32>
     %16 = linalg.dot ins(%13, %15 : tensor<2xf32>, tensor<2xf32>) outs(%arg4 : tensor<f32>) -> tensor<f32>
 
     // %AA = tensor.cast %13 : tensor<2xf32> to tensor<*xf32>
-    // call @print_memref_f32(%AA) : (tensor<*xf32>) -> ()
+    // call @printMemrefF32(%AA) : (tensor<*xf32>) -> ()
     // %BB = tensor.cast %15 : tensor<2xf32> to tensor<*xf32>
-    // call @print_memref_f32(%BB) : (tensor<*xf32>) -> ()
+    // call @printMemrefF32(%BB) : (tensor<*xf32>) -> ()
     // %CC = tensor.cast %16 : tensor<f32> to tensor<*xf32>
-    // call @print_memref_f32(%CC) : (tensor<*xf32>) -> ()
+    // call @printMemrefF32(%CC) : (tensor<*xf32>) -> ()
 
     scf.yield %16 : tensor<f32>
   }
   return %7 : tensor<f32>
 }
 
 func.func @main() {
   %v0 = arith.constant 0.0 : f32
func.func @main() {
 
   %res = call @init_and_dot(%AA, %BB, %CC) :
     (tensor<64xf32>, tensor<64xf32>, tensor<f32>) -> tensor<f32>
 
   %res2 = tensor.cast %res: tensor<f32> to tensor<*xf32>
 
 //      CHECK: Unranked Memref base@ = {{.*}} rank = 0 offset = 0 sizes = [] strides = [] data =
 // CHECK-NEXT: [128]
-  call @print_memref_f32(%res2) : (tensor<*xf32>) -> ()
+  call @printMemrefF32(%res2) : (tensor<*xf32>) -> ()
 
   return
 }
 
-func.func private @print_memref_f32(tensor<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(tensor<*xf32>) attributes { llvm.emit_c_interface }

mlir/test/Integration/Dialect/Linalg/CPU/test-padtensor.mlir

func.func @main() {
   %offset = arith.constant 2 : index
   %cst = arith.constant 2.3 : f32
   %c0 = arith.constant 0 : index
   %out = tensor.pad %dynamic low[%c0, %offset, %c0] high[%c0, %c0, %offset]  {
   ^bb0(%gen_arg1: index, %gen_arg2: index, %gen_arg3: index):
     tensor.yield %cst : f32
   } : tensor<1x?x3xf32> to tensor<1x?x?xf32>
   %unranked = tensor.cast %out: tensor<1x?x?xf32> to tensor<*xf32>
-  call @print_memref_f32(%unranked) : (tensor<*xf32>) -> ()
+  call @printMemrefF32(%unranked) : (tensor<*xf32>) -> ()
 
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 3 offset = 0 sizes = [1, 4, 5] strides = [20, 5, 1] data =
   // CHECK-NEXT{LITERAL}: [[[2.3,    2.3,    2.3,    2.3,    2.3],
   // CHECK-NEXT: [2.3,    2.3,    2.3,    2.3,    2.3],
   // CHECK-NEXT: [1,    2,    3,    2.3,    2.3],
   // CHECK-NEXT: [2,    3,    4,    2.3,    2.3]]]
 
   return
 }
 
-func.func private @print_memref_f32(%ptr : tensor<*xf32>)
+func.func private @printMemrefF32(%ptr : tensor<*xf32>)

mlir/test/Integration/Dialect/Linalg/CPU/test-subtensor-insert-multiple-uses.mlir

func.func @main() {
   // Both of these insert_slice ops insert into the same original tensor
   // value `%const`. This can easily cause bugs if at the memref level
   // we attempt to write in-place into the memref that %const has been
   // converted into.
   %inserted_at_position_0 = tensor.insert_slice %insert_val into %const[0][1][1] : tensor<1xf32> into tensor<2xf32>
   %inserted_at_position_1 = tensor.insert_slice %insert_val into %const[1][1][1] : tensor<1xf32> into tensor<2xf32>
 
   %unranked_at_position_0 = tensor.cast %inserted_at_position_0 : tensor<2xf32> to tensor<*xf32>
-  call @print_memref_f32(%unranked_at_position_0) : (tensor<*xf32>) -> ()
+  call @printMemrefF32(%unranked_at_position_0) : (tensor<*xf32>) -> ()
 
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 1 offset = 0 sizes = [2] strides = [1] data =
   // CHECK-NEXT: [20, 10]
 
   %unranked_at_position_1 = tensor.cast %inserted_at_position_1 : tensor<2xf32> to tensor<*xf32>
-  call @print_memref_f32(%unranked_at_position_1) : (tensor<*xf32>) -> ()
+  call @printMemrefF32(%unranked_at_position_1) : (tensor<*xf32>) -> ()
 
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 1 offset = 0 sizes = [2] strides = [1] data =
   // CHECK-NEXT: [10, 20]
 
   return
 }
 
-func.func private @print_memref_f32(%ptr : tensor<*xf32>)
+func.func private @printMemrefF32(%ptr : tensor<*xf32>)

mlir/test/Integration/Dialect/Linalg/CPU/test-subtensor-insert.mlir

 // RUN: mlir-opt %s -linalg-bufferize \
 // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
 // RUN: -finalizing-bufferize -buffer-deallocation \
 // RUN: -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 func.func @main() {
   %const = arith.constant dense<10.0> : tensor<2xf32>
   %insert_val = arith.constant dense<20.0> : tensor<1xf32>
   %inserted = tensor.insert_slice %insert_val into %const[0][1][1] : tensor<1xf32> into tensor<2xf32>
 
   %unranked = tensor.cast %inserted : tensor<2xf32> to tensor<*xf32>
-  call @print_memref_f32(%unranked) : (tensor<*xf32>) -> ()
+  call @printMemrefF32(%unranked) : (tensor<*xf32>) -> ()
 
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 1 offset = 0 sizes = [2] strides = [1] data =
   // CHECK-NEXT: [20, 10]
 
   return
 }
 
-func.func private @print_memref_f32(%ptr : tensor<*xf32>)
+func.func private @printMemrefF32(%ptr : tensor<*xf32>)

mlir/test/Integration/Dialect/Linalg/CPU/test-tensor-e2e.mlir

 // RUN: mlir-opt %s -arith-bufferize -linalg-bufferize \
 // RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -buffer-deallocation -convert-linalg-to-loops \
 // RUN: -convert-linalg-to-llvm --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 func.func @foo() -> tensor<4xf32> {
   %0 = arith.constant dense<[1.0, 2.0, 3.0, 4.0]> : tensor<4xf32>
   return %0 : tensor<4xf32>
 }
 
 func.func @main() {
   %0 = call @foo() : () -> tensor<4xf32>
 
   // Instead of relying on tensor_store which introduces aliasing, we rely on
-  // the conversion of print_memref_f32(tensor<*xf32>) to
-  // print_memref_f32(memref<*xf32>).
+  // the conversion of printMemrefF32(tensor<*xf32>) to
+  // printMemrefF32(memref<*xf32>).
   // Note that this is skipping a step and we would need at least some function
   // attribute to declare that this conversion is valid (e.g. when we statically
   // know that things will play nicely at the C ABI boundary).
   %unranked = tensor.cast %0 : tensor<4xf32> to tensor<*xf32>
-  call @print_memref_f32(%unranked) : (tensor<*xf32>) -> ()
+  call @printMemrefF32(%unranked) : (tensor<*xf32>) -> ()
 
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 1 offset = 0 sizes = [4] strides = [1] data =
   // CHECK-NEXT: [1, 2, 3, 4]
 
   return
 }
 
 // This gets converted to a function operating on memref<*xf32>.
 // Note that this is skipping a step and we would need at least some function
 // attribute to declare that this conversion is valid (e.g. when we statically
 // know that things will play nicely at the C ABI boundary).
-func.func private @print_memref_f32(%ptr : tensor<*xf32>)
+func.func private @printMemrefF32(%ptr : tensor<*xf32>)

mlir/test/Integration/Dialect/Linalg/CPU/test-tensor-matmul.mlir

%B = arith.constant dense<[[1.0, 2.0, 3.0, 4.0],
                        [5.0, 6.0, 7.0, 8.0],
                        [9.0, 10.0, 11.0, 12.0]]> : tensor<3x4xf32>
   %C = arith.constant dense<1000.0> : tensor<2x4xf32>
 
   %D = linalg.matmul ins(%A, %B: tensor<2x3xf32>, tensor<3x4xf32>)
                      outs(%C: tensor<2x4xf32>) -> tensor<2x4xf32>
 
   %unranked = tensor.cast %D : tensor<2x4xf32> to tensor<*xf32>
-  call @print_memref_f32(%unranked) : (tensor<*xf32>) -> ()
+  call @printMemrefF32(%unranked) : (tensor<*xf32>) -> ()
 
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 2 offset = 0 sizes = [2, 4] strides = [4, 1] data =
   // CHECK-NEXT: [1038,   1044,   1050,   1056]
   // CHECK-NEXT: [1083,   1098,   1113,   1128]
 
   return
 }
 
-func.func private @print_memref_f32(%ptr : tensor<*xf32>)
+func.func private @printMemrefF32(%ptr : tensor<*xf32>)

mlir/test/Integration/Dialect/Standard/CPU/test_subview.mlir

dense<[[0.0, 1.0, 2.0],
        [12.0, 13.0, 14.0]]>
 
 func.func @main() {
   %0 = memref.get_global @__constant_5x3xf32 : memref<5x3xf32>
 
   /// Subview with only leading operands.
   %1 = memref.subview %0[2, 0][3, 3][1, 1]: memref<5x3xf32> to memref<3x3xf32, offset: 6, strides: [3, 1]>
   %unranked = memref.cast %1 : memref<3x3xf32, offset: 6, strides: [3, 1]> to memref<*xf32>
-  call @print_memref_f32(%unranked) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked) : (memref<*xf32>) -> ()
 
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 2 offset = 6 sizes = [3, 3] strides = [3, 1] data =
   // CHECK-NEXT: [
   // CHECK-SAME:  [6,   7,   8],
   // CHECK-NEXT:  [9,   10,   11],
   // CHECK-NEXT:  [12,   13,   14]
   // CHECK-SAME: ]
 
   /// Regular subview.
   %2 = memref.subview %0[0, 2][5, 1][1, 1]: memref<5x3xf32> to memref<5x1xf32, offset: 2, strides: [3, 1]>
   %unranked2 = memref.cast %2 : memref<5x1xf32, offset: 2, strides: [3, 1]> to memref<*xf32>
-  call @print_memref_f32(%unranked2) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked2) : (memref<*xf32>) -> ()
 
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 2 offset = 2 sizes = [5, 1] strides = [3, 1] data =
   // CHECK-NEXT: [
   // CHECK-SAME:  [2],
   // CHECK-NEXT:  [5],
   // CHECK-NEXT:  [8],
   // CHECK-NEXT:  [11],
   // CHECK-NEXT:  [14]
   // CHECK-SAME: ]
 
   /// Rank-reducing subview.
   %3 = memref.subview %0[0, 2][5, 1][1, 1]: memref<5x3xf32> to memref<5xf32, offset: 2, strides: [3]>
   %unranked3 = memref.cast %3 : memref<5xf32, offset: 2, strides: [3]> to memref<*xf32>
-  call @print_memref_f32(%unranked3) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked3) : (memref<*xf32>) -> ()
 
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 1 offset = 2 sizes = [5] strides = [3] data =
   // CHECK-NEXT: [2,  5,  8,  11,  14]
 
   /// Rank-reducing subview with only leading operands.
   %4 = memref.subview %0[1, 0][1, 3][1, 1]: memref<5x3xf32> to memref<3xf32, offset: 3, strides: [1]>
   %unranked4 = memref.cast %4 : memref<3xf32, offset: 3, strides: [1]> to memref<*xf32>
-  call @print_memref_f32(%unranked4) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked4) : (memref<*xf32>) -> ()
   //      CHECK: Unranked Memref base@ = {{0x[-9a-f]*}}
   // CHECK-SAME: rank = 1 offset = 3 sizes = [3] strides = [1] data =
   // CHECK-NEXT: [3,  4,  5]
 
   return
 }
 
-func.func private @print_memref_f32(%ptr : memref<*xf32>)
+func.func private @printMemrefF32(%ptr : memref<*xf32>)

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-to-loops.mlir

 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void  \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void  \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
 #map0 = affine_map<(d0, d1) -> (d1, d0)>
 #map1 = affine_map<(d0, d1) -> (d1)>
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 func.func @alloc_2d_filled_f32(%arg0: index, %arg1: index) -> memref<?x?xf32> {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c10 = arith.constant 10 : index
   %c100 = arith.constant 100 : index
   %0 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
   scf.for %arg5 = %c0 to %arg0 step %c1 {
func.func @main() {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c2 = arith.constant 2 : index
   %c3 = arith.constant 3 : index
   %c6 = arith.constant 6 : index
   %cst = arith.constant -4.2e+01 : f32
   %0 = call @alloc_2d_filled_f32(%c6, %c6) : (index, index) -> memref<?x?xf32>
   %converted = memref.cast %0 : memref<?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%converted): (memref<*xf32>) -> ()
+  call @printMemrefF32(%converted): (memref<*xf32>) -> ()
   // CHECK:      Unranked{{.*}}data =
   // CHECK:      [
   // CHECK-SAME:  [0,   100,   200,   300,   400,   500],
   // CHECK-NEXT:  [1,   101,   201,   301,   401,   501],
   // CHECK-NEXT:  [2,   102,   202,   302,   402,   502],
   // CHECK-NEXT:  [3,   103,   203,   303,   403,   503],
   // CHECK-NEXT:  [4,   104,   204,   304,   404,   504],
   // CHECK-NEXT:  [5,   105,   205,   305,   405,   505]]

mlir/test/Integration/Dialect/Vector/CPU/test-vector-distribute.mlir

 // RUN: mlir-opt %s -pass-pipeline="func.func(test-vector-to-forloop,convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
 // RUN: mlir-cpu-runner -e main -entry-point-result=void  \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e main \
 // RUN: -entry-point-result=void \
 // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
 // RUN: mlir-opt %s -pass-pipeline="func.func(test-vector-to-forloop)" | FileCheck %s -check-prefix=TRANSFORM
 
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
 
 func.func @alloc_1d_filled_inc_f32(%arg0: index, %arg1: f32) -> memref<?xf32> {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %0 = memref.alloc(%arg0) : memref<?xf32>
   scf.for %arg2 = %c0 to %arg0 step %c1 {
     %tmp = arith.index_cast %arg2 : index to i32
     %tmp1 = arith.sitofp %tmp : i32 to f32
func.func @main() {
   // TRANSFORM:   %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<2xf32>
   // TRANSFORM:   vector.transfer_write {{.*}} : vector<2xf32>, memref<?xf32>
   // TRANSFORM: }
   %a = vector.transfer_read %in1[%c0], %cf0: memref<?xf32>, vector<64xf32>
   %b = vector.transfer_read %in2[%c0], %cf0: memref<?xf32>, vector<64xf32>
   %acc = arith.addf %a, %b: vector<64xf32>
   vector.transfer_write %acc, %out[%c0]: vector<64xf32>, memref<?xf32>
   %converted = memref.cast %out : memref<?xf32> to memref<*xf32>
-  call @print_memref_f32(%converted): (memref<*xf32>) -> ()
+  call @printMemrefF32(%converted): (memref<*xf32>) -> ()
   // CHECK:      Unranked{{.*}}data =
   // CHECK:      [
   // CHECK-SAME:  3,  5,  7,  9,  11,  13,  15,  17,  19,  21,  23,  25,  27,
   // CHECK-SAME:  29,  31,  33,  35,  37,  39,  41,  43,  45,  47,  49,  51,
   // CHECK-SAME:  53,  55,  57,  59,  61,  63,  65,  67,  69,  71,  73,  75,
   // CHECK-SAME:  77,  79,  81,  83,  85,  87,  89,  91,  93,  95,  97,  99,
   // CHECK-SAME:  101,  103,  105,  107,  109,  111,  113,  115,  117,  119,
   // CHECK-SAME:  121,  123,  125,  127,  129]
   memref.dealloc %out : memref<?xf32>
   memref.dealloc %in1 : memref<?xf32>
   memref.dealloc %in2 : memref<?xf32>
   return
 }

mlir/test/Integration/GPU/CUDA/TensorCore/wmma-matmul-f16.mlir

scf.for %arg0 = %c0 to %c16 step %c1 {
     scf.for %arg1 = %c0 to %c16 step %c1 {
       %6 = memref.load %0[%arg0, %arg1] : memref<16x16xf16>
       %7 = arith.extf %6 : f16 to f32
       memref.store %7, %1[%arg0, %arg1] : memref<16x16xf32>
     }
   }
 
   // Print the memref after computation.
-  call @print_memref_f32(%3) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%3) : (memref<*xf32>) -> ()
   // CHECK: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16]
   return
 }
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)

mlir/test/Integration/GPU/CUDA/TensorCore/wmma-matmul-f32.mlir

gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c1, %grid_y = %c1, %grid_z = %c1)
     %C = gpu.subgroup_mma_load_matrix %22[%c0, %c0] {leadDimension = 16 : index} : memref<16x16xf32> -> !gpu.mma_matrix<16x16xf32, "COp">
 
     %R = gpu.subgroup_mma_compute %A, %B, %C : !gpu.mma_matrix<16x16xf16, "AOp">, !gpu.mma_matrix<16x16xf16, "BOp"> -> !gpu.mma_matrix<16x16xf32, "COp">
 
     gpu.subgroup_mma_store_matrix %R, %22[%c0, %c0] {leadDimension = 16 : index}: !gpu.mma_matrix<16x16xf32, "COp">, memref<16x16xf32>
     gpu.terminator
   }
   // Print the memref after computation.
-  call @print_memref_f32(%33) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%33) : (memref<*xf32>) -> ()
   // CHECK: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16],
   // CHECK-NEXT: [16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16,   16]
   return
 }
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)

mlir/test/Integration/GPU/CUDA/all-reduce-and.mlir

func.func @main() {
   gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c2, %grid_y = %c1, %grid_z = %c1)
              threads(%tx, %ty, %tz) in (%block_x = %c6, %block_y = %c1, %block_z = %c1) {
     %val = memref.load %data[%bx, %tx] : memref<2x6xi32>
     %reduced = gpu.all_reduce and %val {} : (i32) -> (i32)
     memref.store %reduced, %sum[%bx] : memref<2xi32>
     gpu.terminator
   }
 
-  call @print_memref_i32(%cast_sum) : (memref<*xi32>) -> ()
+  call @printMemrefI32(%cast_sum) : (memref<*xi32>) -> ()
   // CHECK: [0, 2]
 
   return
 }
 
-func.func private @print_memref_i32(memref<*xi32>)
+func.func private @printMemrefI32(memref<*xi32>)
 

mlir/test/Integration/GPU/CUDA/all-reduce-max.mlir

func.func @main() {
   gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c2, %grid_y = %c1, %grid_z = %c1)
              threads(%tx, %ty, %tz) in (%block_x = %c6, %block_y = %c1, %block_z = %c1) {
     %val = memref.load %data[%bx, %tx] : memref<2x6xi32>
     %reduced = gpu.all_reduce max %val {} : (i32) -> (i32)
     memref.store %reduced, %sum[%bx] : memref<2xi32>
     gpu.terminator
   }
 
-  call @print_memref_i32(%cast_sum) : (memref<*xi32>) -> ()
+  call @printMemrefI32(%cast_sum) : (memref<*xi32>) -> ()
   // CHECK: [16, 11]
 
   return
 }
 
-func.func private @print_memref_i32(memref<*xi32>)
+func.func private @printMemrefI32(memref<*xi32>)
 

mlir/test/Integration/GPU/CUDA/all-reduce-min.mlir

func.func @main() {
   gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c2, %grid_y = %c1, %grid_z = %c1)
              threads(%tx, %ty, %tz) in (%block_x = %c6, %block_y = %c1, %block_z = %c1) {
     %val = memref.load %data[%bx, %tx] : memref<2x6xi32>
     %reduced = gpu.all_reduce min %val {} : (i32) -> (i32)
     memref.store %reduced, %sum[%bx] : memref<2xi32>
     gpu.terminator
   }
 
-  call @print_memref_i32(%cast_sum) : (memref<*xi32>) -> ()
+  call @printMemrefI32(%cast_sum) : (memref<*xi32>) -> ()
   // CHECK: [0, 2]
 
   return
 }
 
-func.func private @print_memref_i32(memref<*xi32>)
+func.func private @printMemrefI32(memref<*xi32>)
 

mlir/test/Integration/GPU/CUDA/all-reduce-op.mlir

gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c1, %grid_y = %c1, %grid_z = %c1)
     %t2 = arith.muli %t1, %block_x : index
     %idx = arith.addi %tx, %t2 : index
     %t3 = arith.index_cast %idx : index to i32
     %val = arith.sitofp %t3 : i32 to f32
     %sum = gpu.all_reduce add %val {} : (f32) -> (f32)
     memref.store %sum, %dst[%tz, %ty, %tx] : memref<?x?x?xf32>
     gpu.terminator
   }
-  call @print_memref_f32(%cast_dst) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%cast_dst) : (memref<*xf32>) -> ()
   return
 }
 
-func.func private @print_memref_f32(%ptr : memref<*xf32>)
+func.func private @printMemrefF32(%ptr : memref<*xf32>)

mlir/test/Integration/GPU/CUDA/all-reduce-or.mlir

func.func @main() {
   gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c2, %grid_y = %c1, %grid_z = %c1)
              threads(%tx, %ty, %tz) in (%block_x = %c6, %block_y = %c1, %block_z = %c1) {
     %val = memref.load %data[%bx, %tx] : memref<2x6xi32>
     %reduced = gpu.all_reduce or %val {} : (i32) -> (i32)
     memref.store %reduced, %sum[%bx] : memref<2xi32>
     gpu.terminator
   }
 
-  call @print_memref_i32(%cast_sum) : (memref<*xi32>) -> ()
+  call @printMemrefI32(%cast_sum) : (memref<*xi32>) -> ()
   // CHECK: [31, 15]
 
   return
 }
 
-func.func private @print_memref_i32(memref<*xi32>)
+func.func private @printMemrefI32(memref<*xi32>)
 

mlir/test/Integration/GPU/CUDA/all-reduce-region.mlir

gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %one, %grid_y = %one, %grid_z = %one)
     ^bb(%lhs : i32, %rhs : i32):
       %xor = arith.xori %lhs, %rhs : i32
       "gpu.yield"(%xor) : (i32) -> ()
     } : (i32) -> (i32)
     %res = arith.sitofp %xor : i32 to f32
     memref.store %res, %dst[%tx] : memref<?xf32>
     gpu.terminator
   }
-  call @print_memref_f32(%cast_dst) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%cast_dst) : (memref<*xf32>) -> ()
   return
 }
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)

mlir/test/Integration/GPU/CUDA/all-reduce-xor.mlir

func.func @main() {
   gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c2, %grid_y = %c1, %grid_z = %c1)
              threads(%tx, %ty, %tz) in (%block_x = %c6, %block_y = %c1, %block_z = %c1) {
     %val = memref.load %data[%bx, %tx] : memref<2x6xi32>
     %reduced = gpu.all_reduce xor %val {} : (i32) -> (i32)
     memref.store %reduced, %sum[%bx] : memref<2xi32>
     gpu.terminator
   }
 
-  call @print_memref_i32(%cast_sum) : (memref<*xi32>) -> ()
+  call @printMemrefI32(%cast_sum) : (memref<*xi32>) -> ()
   // CHECK: [31, 1]
 
   return
 }
 
-func.func private @print_memref_i32(memref<*xi32>)
+func.func private @printMemrefI32(memref<*xi32>)
 

mlir/test/Integration/GPU/CUDA/async.mlir

gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c1, %grid_y = %c1, %grid_z = %c1)
       memref.store %sum, %h0[%tx] : memref<?xi32>
       gpu.terminator
     }
     async.yield
   }
 
   async.await %t3 : !async.token
   // CHECK: [84, 84]
-  call @print_memref_i32(%h0_unranked) : (memref<*xi32>) -> ()
+  call @printMemrefI32(%h0_unranked) : (memref<*xi32>) -> ()
   return
 }
 
-func.func private @print_memref_i32(memref<*xi32>)
+func.func private @printMemrefI32(memref<*xi32>)

mlir/test/Integration/GPU/CUDA/gpu-to-cubin.mlir

 func.func @main() {
   %v0 = arith.constant 0.0 : f32
   %c0 = arith.constant 0: index
   %arg0 = memref.alloc() : memref<5xf32>
   %21 = arith.constant 5 : i32
   %22 = memref.cast %arg0 : memref<5xf32> to memref<?xf32>
   %23 = memref.cast %22 : memref<?xf32> to memref<*xf32>
   gpu.host_register %23 : memref<*xf32>
-  call @print_memref_f32(%23) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%23) : (memref<*xf32>) -> ()
   %24 = arith.constant 1.0 : f32
   call @other_func(%24, %22) : (f32, memref<?xf32>) -> ()
-  call @print_memref_f32(%23) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%23) : (memref<*xf32>) -> ()
   %val1 = vector.transfer_read %arg0[%c0], %v0: memref<5xf32>, vector<2xf32>
   vector.print %val1: vector<2xf32>
   return
 }
 
-func.func private @print_memref_f32(%ptr : memref<*xf32>)
+func.func private @printMemrefF32(%ptr : memref<*xf32>)

mlir/test/Integration/GPU/CUDA/multiple-all-reduce.mlir

gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c2, %grid_y = %c1, %grid_z = %c1)
     %val = memref.load %data[%bx, %tx] : memref<2x6xf32>
     %reduced0 = gpu.all_reduce add %val {} : (f32) -> (f32)
     memref.store %reduced0, %sum[%bx] : memref<2xf32>
     %reduced1 = gpu.all_reduce mul %val {} : (f32) -> (f32)
     memref.store %reduced1, %mul[%bx] : memref<2xf32>
     gpu.terminator
   }
 
-  call @print_memref_f32(%cast_sum) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%cast_sum) : (memref<*xf32>) -> ()
   // CHECK: [31, 39]
 
-  call @print_memref_f32(%cast_mul) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%cast_mul) : (memref<*xf32>) -> ()
   // CHECK: [0, 27720]
 
   return
 }
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)

mlir/test/Integration/GPU/CUDA/shuffle.mlir

gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %one, %grid_y = %one, %grid_z = %one)
     cf.cond_br %valid, ^bb1(%shfl : f32), ^bb0
   ^bb0:
     %m1 = arith.constant -1.0 : f32
     cf.br ^bb1(%m1 : f32)
   ^bb1(%value : f32):
     memref.store %value, %dst[%tx] : memref<?xf32>
     gpu.terminator
   }
-  call @print_memref_f32(%cast_dst) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%cast_dst) : (memref<*xf32>) -> ()
   return
 }
 
-func.func private @print_memref_f32(%ptr : memref<*xf32>)
+func.func private @printMemrefF32(%ptr : memref<*xf32>)

mlir/test/Integration/GPU/CUDA/two-modules.mlir

gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %one, %grid_y = %one, %grid_z = %one)
     gpu.terminator
   }
   gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %one, %grid_y = %one, %grid_z = %one)
              threads(%tx, %ty, %tz) in (%block_x = %sx, %block_y = %one, %block_z = %one) {
     %t0 = arith.index_cast %tx : index to i32
     memref.store %t0, %dst[%tx] : memref<?xi32>
     gpu.terminator
   }
-  call @print_memref_i32(%cast_dst) : (memref<*xi32>) -> ()
+  call @printMemrefI32(%cast_dst) : (memref<*xi32>) -> ()
   return
 }
 
-func.func private @print_memref_i32(%memref : memref<*xi32>)
+func.func private @printMemrefI32(%memref : memref<*xi32>)

mlir/test/Integration/GPU/ROCM/gpu-to-hsaco.mlir

 // CHECK: [1, 1, 1, 1, 1]
 func.func @main() {
   %arg0 = memref.alloc() : memref<5xf32>
   %21 = arith.constant 5 : i32
   %22 = memref.cast %arg0 : memref<5xf32> to memref<?xf32>
   %cast = memref.cast %22 : memref<?xf32> to memref<*xf32>
   gpu.host_register %cast : memref<*xf32>
   %23 = memref.cast %22 : memref<?xf32> to memref<*xf32>
-  call @print_memref_f32(%23) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%23) : (memref<*xf32>) -> ()
   %24 = arith.constant 1.0 : f32
   %25 = call @mgpuMemGetDeviceMemRef1dFloat(%22) : (memref<?xf32>) -> (memref<?xf32>)
   call @other_func(%24, %25) : (f32, memref<?xf32>) -> ()
-  call @print_memref_f32(%23) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%23) : (memref<*xf32>) -> ()
   return
 }
 
 func.func private @mgpuMemGetDeviceMemRef1dFloat(%ptr : memref<?xf32>) -> (memref<?xf32>)
-func.func private @print_memref_f32(%ptr : memref<*xf32>)
+func.func private @printMemrefF32(%ptr : memref<*xf32>)

mlir/test/Integration/GPU/ROCM/two-modules.mlir

gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c1, %grid_y = %c1, %grid_z = %c1)
     gpu.terminator
   }
   gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c1, %grid_y = %c1, %grid_z = %c1)
              threads(%tx, %ty, %tz) in (%block_x = %sx, %block_y = %c1, %block_z = %c1) {
     %t0 = arith.index_cast %tx : index to i32
     memref.store %t0, %dst_device[%tx] : memref<?xi32>
     gpu.terminator
   }
-  call @print_memref_i32(%cast_dst) : (memref<*xi32>) -> ()
+  call @printMemrefI32(%cast_dst) : (memref<*xi32>) -> ()
   return
 }
 
 func.func private @mgpuMemGetDeviceMemRef1dInt32(%ptr : memref<?xi32>) -> (memref<?xi32>)
-func.func private @print_memref_i32(%ptr : memref<*xi32>)
+func.func private @printMemrefI32(%ptr : memref<*xi32>)

mlir/test/Integration/GPU/ROCM/vecadd.mlir

func.func @main() {
   gpu.host_register %6 : memref<*xf32>
   gpu.host_register %7 : memref<*xf32>
   gpu.host_register %8 : memref<*xf32>
   %9 = call @mgpuMemGetDeviceMemRef1dFloat(%3) : (memref<?xf32>) -> (memref<?xf32>)
   %10 = call @mgpuMemGetDeviceMemRef1dFloat(%4) : (memref<?xf32>) -> (memref<?xf32>)
   %11 = call @mgpuMemGetDeviceMemRef1dFloat(%5) : (memref<?xf32>) -> (memref<?xf32>)
 
   call @vecadd(%9, %10, %11) : (memref<?xf32>, memref<?xf32>, memref<?xf32>) -> ()
-  call @print_memref_f32(%8) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%8) : (memref<*xf32>) -> ()
   return
 }
 
 func.func private @mgpuMemGetDeviceMemRef1dFloat(%ptr : memref<?xf32>) -> (memref<?xf32>)
-func.func private @print_memref_f32(%ptr : memref<*xf32>)
+func.func private @printMemrefF32(%ptr : memref<*xf32>)

mlir/test/Integration/GPU/ROCM/vector-transferops.mlir

func.func @main() {
   gpu.host_register %cast0 : memref<*xf32>
   gpu.host_register %cast1 : memref<*xf32>
 
   %24 = call @mgpuMemGetDeviceMemRef1dFloat(%22) : (memref<?xf32>) -> (memref<?xf32>)
   %26 = call @mgpuMemGetDeviceMemRef1dFloat(%23) : (memref<?xf32>) -> (memref<?xf32>)
 
   // CHECK: [1.23, 2.46, 2.46, 1.23]
   call @vectransferx2(%24, %26) : (memref<?xf32>,  memref<?xf32>) -> ()
-  call @print_memref_f32(%cast1) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%cast1) : (memref<*xf32>) -> ()
 
   // CHECK: [2.46, 2.46, 2.46, 2.46]
   call @vectransferx4(%24, %26) : (memref<?xf32>,  memref<?xf32>) -> ()
-  call @print_memref_f32(%cast1) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%cast1) : (memref<*xf32>) -> ()
   return
 }
 
 func.func private @mgpuMemGetDeviceMemRef1dFloat(%ptr : memref<?xf32>) -> (memref<?xf32>)
-func.func private @print_memref_f32(%ptr : memref<*xf32>)
+func.func private @printMemrefF32(%ptr : memref<*xf32>)

mlir/test/mlir-cpu-runner/async-value.mlir

%token2, %result2 = async.execute[%token0] -> !async.value<memref<f32>> {
     async.yield %5 : memref<f32>
   }
   %6 = async.await %result2 : !async.value<memref<f32>>
   %7 = memref.cast %6 :  memref<f32> to memref<*xf32>
 
   // CHECK: Unranked Memref
   // CHECK-SAME: rank = 0 offset = 0 sizes = [] strides = []
   // CHECK-NEXT: [0.25]
-  call @print_memref_f32(%7): (memref<*xf32>) -> ()
+  call @printMemrefF32(%7): (memref<*xf32>) -> ()
 
   // ------------------------------------------------------------------------ //
   // Memref passed as async.execute operand.
   // ------------------------------------------------------------------------ //
   %token3 = async.execute(%result2 as %unwrapped : !async.value<memref<f32>>) {
     %8 = memref.load %unwrapped[]: memref<f32>
     %9 = arith.addf %8, %8 : f32
     memref.store %9, %unwrapped[]: memref<f32>
     async.yield
   }
   async.await %token3 : !async.token
 
   // CHECK: Unranked Memref
   // CHECK-SAME: rank = 0 offset = 0 sizes = [] strides = []
   // CHECK-NEXT: [0.5]
-  call @print_memref_f32(%7): (memref<*xf32>) -> ()
+  call @printMemrefF32(%7): (memref<*xf32>) -> ()
 
   memref.dealloc %6 : memref<f32>
 
   return
 }
 
-func.func private @print_memref_f32(memref<*xf32>)
+func.func private @printMemrefF32(memref<*xf32>)
   attributes { llvm.emit_c_interface }

mlir/test/mlir-cpu-runner/async.mlir

func.func @main() {
   %c3 = arith.constant 3.0 : f32
   %c4 = arith.constant 4.0 : f32
 
   %A = memref.alloc() : memref<4xf32>
   linalg.fill ins(%c0 : f32) outs(%A : memref<4xf32>)
 
   // CHECK: [0, 0, 0, 0]
   %U = memref.cast %A :  memref<4xf32> to memref<*xf32>
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   // CHECK: Current thread id: [[MAIN:.*]]
   // CHECK: [1, 0, 0, 0]
   memref.store %c1, %A[%i0]: memref<4xf32>
   call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   %outer = async.execute {
     // CHECK: Current thread id: [[THREAD0:.*]]
     // CHECK: [1, 2, 0, 0]
     memref.store %c2, %A[%i1]: memref<4xf32>
     func.call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
-    func.call @print_memref_f32(%U): (memref<*xf32>) -> ()
+    func.call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
     // No op async region to create a token for testing async dependency.
     %noop = async.execute {
       // CHECK: Current thread id: [[THREAD1:.*]]
       func.call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
       async.yield
     }
 
     %inner = async.execute [%noop] {
       // CHECK: Current thread id: [[THREAD2:.*]]
       // CHECK: [1, 2, 3, 0]
       memref.store %c3, %A[%i2]: memref<4xf32>
       func.call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
-      func.call @print_memref_f32(%U): (memref<*xf32>) -> ()
+      func.call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
       async.yield
     }
     async.await %inner : !async.token
 
     // CHECK: Current thread id: [[THREAD3:.*]]
     // CHECK: [1, 2, 3, 4]
     memref.store %c4, %A[%i3]: memref<4xf32>
     func.call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
-    func.call @print_memref_f32(%U): (memref<*xf32>) -> ()
+    func.call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
     async.yield
   }
   async.await %outer : !async.token
 
   // CHECK: Current thread id: [[MAIN]]
   // CHECK: [1, 2, 3, 4]
   call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   memref.dealloc %A : memref<4xf32>
 
   return
 }
 
 func.func private @mlirAsyncRuntimePrintCurrentThreadId() -> ()
 
-func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }

mlir/test/mlir-cpu-runner/copy.mlir

 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" \
 // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
 // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
 
 func.func @main() -> () {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c42 = arith.constant 42.0 : f32
 
   // Initialize input.
   %input = memref.alloc() : memref<2x3xf32>
   %dim_x = memref.dim %input, %c0 : memref<2x3xf32>
   %dim_y = memref.dim %input, %c1 : memref<2x3xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%dim_x, %dim_y) step (%c1, %c1) {
     %prod = arith.muli %i,  %dim_y : index
     %val = arith.addi %prod, %j : index
     %val_i64 = arith.index_cast %val : index to i64
     %val_f32 = arith.sitofp %val_i64 : i64 to f32
     memref.store %val_f32, %input[%i, %j] : memref<2x3xf32>
   }
   %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
-  call @print_memref_f32(%unranked_input) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_input) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [2, 3] strides = [3, 1]
   // CHECK-NEXT: [0,   1,   2]
   // CHECK-NEXT: [3,   4,   5]
 
   %copy = memref.alloc() : memref<2x3xf32>
   memref.copy %input, %copy : memref<2x3xf32> to memref<2x3xf32>
   %unranked_copy = memref.cast %copy : memref<2x3xf32> to memref<*xf32>
-  call @print_memref_f32(%unranked_copy) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_copy) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [2, 3] strides = [3, 1]
   // CHECK-NEXT: [0,   1,   2]
   // CHECK-NEXT: [3,   4,   5]
 
   %copy_two = memref.alloc() : memref<3x2xf32>
   %copy_two_casted = memref.reinterpret_cast %copy_two to offset: [0], sizes: [2, 3], strides: [1, 2]
     : memref<3x2xf32> to memref<2x3xf32, offset: 0, strides: [1, 2]>
   memref.copy %input, %copy_two_casted : memref<2x3xf32> to memref<2x3xf32, offset: 0, strides: [1, 2]>
   %unranked_copy_two = memref.cast %copy_two : memref<3x2xf32> to memref<*xf32>
-  call @print_memref_f32(%unranked_copy_two) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_copy_two) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [3, 2] strides = [2, 1]
   // CHECK-NEXT: [0,   3]
   // CHECK-NEXT: [1,   4]
   // CHECK-NEXT: [2,   5]
 
   %input_empty = memref.alloc() : memref<3x0x1xf32>
   %copy_empty = memref.alloc() : memref<3x0x1xf32>
   // Copying an empty shape should do nothing (and should not crash).
   memref.copy %input_empty, %copy_empty : memref<3x0x1xf32> to memref<3x0x1xf32>
 
   %input_empty_casted = memref.reinterpret_cast %input_empty to offset: [0], sizes: [0, 3, 1], strides: [3, 1, 1]
     : memref<3x0x1xf32> to memref<0x3x1xf32, offset: 0, strides: [3, 1, 1]>
   %copy_empty_casted = memref.alloc() : memref<0x3x1xf32>
   // Copying a casted empty shape should do nothing (and should not crash).
   memref.copy %input_empty_casted, %copy_empty_casted : memref<0x3x1xf32, offset: 0, strides: [3, 1, 1]> to memref<0x3x1xf32>
 
   %scalar = memref.alloc() : memref<f32>
   memref.store %c42, %scalar[] : memref<f32>
   %scalar_copy = memref.alloc() : memref<f32>
   memref.copy %scalar, %scalar_copy : memref<f32> to memref<f32>
   %unranked_scalar_copy = memref.cast %scalar_copy : memref<f32> to memref<*xf32>
-  call @print_memref_f32(%unranked_scalar_copy) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_scalar_copy) : (memref<*xf32>) -> ()
   // CHECK: rank = 0 offset = 0 sizes = [] strides = []
   // CHECK-NEXT [42]
 
   memref.dealloc %copy_empty : memref<3x0x1xf32>
   memref.dealloc %copy_empty_casted : memref<0x3x1xf32>
   memref.dealloc %input_empty : memref<3x0x1xf32>
   memref.dealloc %copy_two : memref<3x2xf32>
   memref.dealloc %copy : memref<2x3xf32>
   memref.dealloc %input : memref<2x3xf32>
   memref.dealloc %scalar : memref<f32>
   memref.dealloc %scalar_copy : memref<f32>
   return
 }

mlir/test/mlir-cpu-runner/global-memref.mlir

 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
-func.func private @print_memref_i32(memref<*xi32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefI32(memref<*xi32>) attributes { llvm.emit_c_interface }
 func.func private @printNewline() -> ()
 
 memref.global "private" @gv0 : memref<4xf32> = dense<[0.0, 1.0, 2.0, 3.0]>
 func.func @test1DMemref() {
   %0 = memref.get_global @gv0 : memref<4xf32>
   %U = memref.cast %0 : memref<4xf32> to memref<*xf32>
   // CHECK: rank = 1
   // CHECK: offset = 0
   // CHECK: sizes = [4]
   // CHECK: strides = [1]
   // CHECK: [0,  1,  2,  3]
-  call @print_memref_f32(%U) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%U) : (memref<*xf32>) -> ()
   call @printNewline() : () -> ()
 
   // Overwrite some of the elements.
   %c0 = arith.constant 0 : index
   %c2 = arith.constant 2 : index
   %fp0 = arith.constant 4.0 : f32
   %fp1 = arith.constant 5.0 : f32
   memref.store %fp0, %0[%c0] : memref<4xf32>
   memref.store %fp1, %0[%c2] : memref<4xf32>
   // CHECK: rank = 1
   // CHECK: offset = 0
   // CHECK: sizes = [4]
   // CHECK: strides = [1]
   // CHECK: [4,  1,  5,  3]
-  call @print_memref_f32(%U) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%U) : (memref<*xf32>) -> ()
   call @printNewline() : () -> ()
   return
 }
 
 memref.global constant @gv1 : memref<3x2xi32> = dense<[[0, 1],[2, 3],[4, 5]]>
 func.func @testConstantMemref() {
   %0 = memref.get_global @gv1 : memref<3x2xi32>
   %U = memref.cast %0 : memref<3x2xi32> to memref<*xi32>
   // CHECK: rank = 2
   // CHECK: offset = 0
   // CHECK: sizes = [3, 2]
   // CHECK: strides = [2, 1]
   // CHECK: [0,   1]
   // CHECK: [2,   3]
   // CHECK: [4,   5]
-  call @print_memref_i32(%U) : (memref<*xi32>) -> ()
+  call @printMemrefI32(%U) : (memref<*xi32>) -> ()
   call @printNewline() : () -> ()
   return
 }
 
 memref.global "private" @gv2 : memref<4x2xf32> = dense<[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0], [6.0, 7.0]]>
 func.func @test2DMemref() {
   %0 = memref.get_global @gv2 : memref<4x2xf32>
   %U = memref.cast %0 : memref<4x2xf32> to memref<*xf32>
   // CHECK: rank = 2
   // CHECK: offset = 0
   // CHECK: sizes = [4, 2]
   // CHECK: strides = [2, 1]
   // CHECK: [0,   1]
   // CHECK: [2,   3]
   // CHECK: [4,   5]
   // CHECK: [6,   7]
-  call @print_memref_f32(%U) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%U) : (memref<*xf32>) -> ()
   call @printNewline() : () -> ()
 
   // Overwrite the 1.0 (at index [0, 1]) with 10.0
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %fp10 = arith.constant 10.0 : f32
   memref.store %fp10, %0[%c0, %c1] : memref<4x2xf32>
   // CHECK: rank = 2
   // CHECK: offset = 0
   // CHECK: sizes = [4, 2]
   // CHECK: strides = [2, 1]
   // CHECK: [0,   10]
   // CHECK: [2,   3]
   // CHECK: [4,   5]
   // CHECK: [6,   7]
-  call @print_memref_f32(%U) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%U) : (memref<*xf32>) -> ()
   call @printNewline() : () -> ()
   return
 }
 
 memref.global @gv3 : memref<i32> = dense<11>
 func.func @testScalarMemref() {
   %0 = memref.get_global @gv3 : memref<i32>
   %U = memref.cast %0 : memref<i32> to memref<*xi32>
   // CHECK: rank = 0
   // CHECK: offset = 0
   // CHECK: sizes = []
   // CHECK: strides = []
   // CHECK: [11]
-  call @print_memref_i32(%U) : (memref<*xi32>) -> ()
+  call @printMemrefI32(%U) : (memref<*xi32>) -> ()
   call @printNewline() : () -> ()
   return
 }
 
 func.func @main() -> () {
   call @test1DMemref() : () -> ()
   call @testConstantMemref() : () -> ()
   call @test2DMemref() : () -> ()
   call @testScalarMemref() : () -> ()
   return
 }
 
 

mlir/test/mlir-cpu-runner/memref-reinterpret-cast.mlir

 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf),convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \
 // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
 // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
-func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
 
 func.func @main() -> () {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
 
   // Initialize input.
   %input = memref.alloc() : memref<2x3xf32>
   %dim_x = memref.dim %input, %c0 : memref<2x3xf32>
   %dim_y = memref.dim %input, %c1 : memref<2x3xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%dim_x, %dim_y) step (%c1, %c1) {
     %prod = arith.muli %i,  %dim_y : index
     %val = arith.addi %prod, %j : index
     %val_i64 = arith.index_cast %val : index to i64
     %val_f32 = arith.sitofp %val_i64 : i64 to f32
     memref.store %val_f32, %input[%i, %j] : memref<2x3xf32>
   }
   %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
-  call @print_memref_f32(%unranked_input) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_input) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [2, 3] strides = [3, 1]
   // CHECK-NEXT: [0,   1,   2]
   // CHECK-NEXT: [3,   4,   5]
 
   // Test cases.
   call @cast_ranked_memref_to_static_shape(%input) : (memref<2x3xf32>) -> ()
   call @cast_ranked_memref_to_dynamic_shape(%input) : (memref<2x3xf32>) -> ()
   call @cast_unranked_memref_to_static_shape(%input) : (memref<2x3xf32>) -> ()
   call @cast_unranked_memref_to_dynamic_shape(%input) : (memref<2x3xf32>) -> ()
   memref.dealloc %input : memref<2x3xf32>
   return
 }
 
 func.func @cast_ranked_memref_to_static_shape(%input : memref<2x3xf32>) {
   %output = memref.reinterpret_cast %input to
            offset: [0], sizes: [6, 1], strides: [1, 1]
            : memref<2x3xf32> to memref<6x1xf32>
 
   %unranked_output = memref.cast %output
       : memref<6x1xf32> to memref<*xf32>
-  call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [6, 1] strides = [1, 1] data =
   // CHECK-NEXT: [0],
   // CHECK-NEXT: [1],
   // CHECK-NEXT: [2],
   // CHECK-NEXT: [3],
   // CHECK-NEXT: [4],
   // CHECK-NEXT: [5]
   return
 }
 
 func.func @cast_ranked_memref_to_dynamic_shape(%input : memref<2x3xf32>) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c6 = arith.constant 6 : index
   %output = memref.reinterpret_cast %input to
            offset: [%c0], sizes: [%c1, %c6], strides: [%c6, %c1]
            : memref<2x3xf32> to memref<?x?xf32, offset: ?, strides: [?, ?]>
 
   %unranked_output = memref.cast %output
       : memref<?x?xf32, offset: ?, strides: [?, ?]> to memref<*xf32>
-  call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [1, 6] strides = [6, 1] data =
   // CHECK-NEXT: [0,   1,   2,   3,   4,   5]
   return
 }
 
 func.func @cast_unranked_memref_to_static_shape(%input : memref<2x3xf32>) {
   %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
   %output = memref.reinterpret_cast %unranked_input to
            offset: [0], sizes: [6, 1], strides: [1, 1]
            : memref<*xf32> to memref<6x1xf32>
 
   %unranked_output = memref.cast %output
       : memref<6x1xf32> to memref<*xf32>
-  call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [6, 1] strides = [1, 1] data =
   // CHECK-NEXT: [0],
   // CHECK-NEXT: [1],
   // CHECK-NEXT: [2],
   // CHECK-NEXT: [3],
   // CHECK-NEXT: [4],
   // CHECK-NEXT: [5]
   return
 }
 
 func.func @cast_unranked_memref_to_dynamic_shape(%input : memref<2x3xf32>) {
   %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c6 = arith.constant 6 : index
   %output = memref.reinterpret_cast %unranked_input to
            offset: [%c0], sizes: [%c1, %c6], strides: [%c6, %c1]
            : memref<*xf32> to memref<?x?xf32, offset: ?, strides: [?, ?]>
 
   %unranked_output = memref.cast %output
       : memref<?x?xf32, offset: ?, strides: [?, ?]> to memref<*xf32>
-  call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [1, 6] strides = [6, 1] data =
   // CHECK-NEXT: [0,   1,   2,   3,   4,   5]
   return
 }

mlir/test/mlir-cpu-runner/memref-reshape.mlir

 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf,memref-expand,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" \
 // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
 // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 
-func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
 
 func.func @main() -> () {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
 
   // Initialize input.
   %input = memref.alloc() : memref<2x3xf32>
   %dim_x = memref.dim %input, %c0 : memref<2x3xf32>
   %dim_y = memref.dim %input, %c1 : memref<2x3xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%dim_x, %dim_y) step (%c1, %c1) {
     %prod = arith.muli %i,  %dim_y : index
     %val = arith.addi %prod, %j : index
     %val_i64 = arith.index_cast %val : index to i64
     %val_f32 = arith.sitofp %val_i64 : i64 to f32
     memref.store %val_f32, %input[%i, %j] : memref<2x3xf32>
   }
   %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
-  call @print_memref_f32(%unranked_input) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_input) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [2, 3] strides = [3, 1]
   // CHECK-NEXT: [0,   1,   2]
   // CHECK-NEXT: [3,   4,   5]
 
   // Initialize shape.
   %shape = memref.alloc() : memref<2xindex>
   %c2 = arith.constant 2 : index
   %c3 = arith.constant 3 : index

 }
 
 func.func @reshape_ranked_memref_to_ranked(%input : memref<2x3xf32>,
                                       %shape : memref<2xindex>) {
   %output = memref.reshape %input(%shape)
                 : (memref<2x3xf32>, memref<2xindex>) -> memref<?x?xf32>
 
   %unranked_output = memref.cast %output : memref<?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [3, 2] strides = [2, 1] data =
   // CHECK: [0,   1],
   // CHECK: [2,   3],
   // CHECK: [4,   5]
   return
 }
 
 func.func @reshape_unranked_memref_to_ranked(%input : memref<2x3xf32>,
                                         %shape : memref<2xindex>) {
   %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
   %output = memref.reshape %input(%shape)
                 : (memref<2x3xf32>, memref<2xindex>) -> memref<?x?xf32>
 
   %unranked_output = memref.cast %output : memref<?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [3, 2] strides = [2, 1] data =
   // CHECK: [0,   1],
   // CHECK: [2,   3],
   // CHECK: [4,   5]
   return
 }
 
 func.func @reshape_ranked_memref_to_unranked(%input : memref<2x3xf32>,
                                         %shape : memref<2xindex>) {
   %dyn_size_shape = memref.cast %shape : memref<2xindex> to memref<?xindex>
   %output = memref.reshape %input(%dyn_size_shape)
                 : (memref<2x3xf32>, memref<?xindex>) -> memref<*xf32>
 
-  call @print_memref_f32(%output) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [3, 2] strides = [2, 1] data =
   // CHECK: [0,   1],
   // CHECK: [2,   3],
   // CHECK: [4,   5]
   return
 }
 
 func.func @reshape_unranked_memref_to_unranked(%input : memref<2x3xf32>,
                                           %shape : memref<2xindex>) {
   %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
   %dyn_size_shape = memref.cast %shape : memref<2xindex> to memref<?xindex>
   %output = memref.reshape %input(%dyn_size_shape)
                 : (memref<2x3xf32>, memref<?xindex>) -> memref<*xf32>
 
-  call @print_memref_f32(%output) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [3, 2] strides = [2, 1] data =
   // CHECK: [0,   1],
   // CHECK: [2,   3],
   // CHECK: [4,   5]
   return
 }

mlir/test/mlir-cpu-runner/print.mlir

 // RUN: mlir-opt %s -pass-pipeline="convert-func-to-llvm,reconcile-unrealized-casts" \
 // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
 // RUN:   -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 
 llvm.mlir.global internal constant @str_global("String to print\0A")
-llvm.func @print_c_string(!llvm.ptr<i8>)
+llvm.func @printCString(!llvm.ptr<i8>)
 
 func.func @main() {
   %0 = llvm.mlir.addressof @str_global : !llvm.ptr<array<16 x i8>>
   %1 = llvm.mlir.constant(0 : index) : i64
   %2 = llvm.getelementptr %0[%1, %1]
     : (!llvm.ptr<array<16 x i8>>, i64, i64) -> !llvm.ptr<i8>
-  llvm.call @print_c_string(%2) : (!llvm.ptr<i8>) -> ()
+  llvm.call @printCString(%2) : (!llvm.ptr<i8>) -> ()
   return
 }
 
 // CHECK: String to print

mlir/test/mlir-cpu-runner/sgemm-naive-codegen.mlir

func.func @main() {
   %f2 = arith.muli %f1, %K : index
 
   // 2*M*N*K.
   %f3 = arith.muli %c2, %f2 : index
   %num_flops = arith.muli %reps, %f3 : index
   %num_flops_i = arith.index_cast %num_flops : index to i16
   %num_flops_f = arith.sitofp %num_flops_i : i16 to f64
   %flops = arith.divf %num_flops_f, %t : f64
-  call @print_flops(%flops) : (f64) -> ()
+  call @printFlops(%flops) : (f64) -> ()
 
   memref.dealloc %A : memref<16x16xf32>
   memref.dealloc %B : memref<16x16xf32>
   memref.dealloc %C : memref<16x16xf32>
   return
 }
 // CHECK: 17
 
affine.for %arg4 = 0 to 16 {
       %s = affine.load %m[%c0] : memref<1xf32>
       affine.store %s, %arg2[%arg3, %arg4] : memref<16x16xf32>
       memref.dealloc %m : memref<1xf32>
     }
   }
   return
 }
 
-func.func private @print_flops(f64)
+func.func private @printFlops(f64)
 func.func private @rtclock() -> f64

mlir/test/mlir-cpu-runner/unranked-memref.mlir

func.func @main() -> () {
     %A = memref.alloc() : memref<10x3xf32, 0>
     %f2 = arith.constant 2.00000e+00 : f32
     %f5 = arith.constant 5.00000e+00 : f32
     %f10 = arith.constant 10.00000e+00 : f32
 
     %V = memref.cast %A : memref<10x3xf32, 0> to memref<?x?xf32>
     linalg.fill ins(%f10 : f32) outs(%V : memref<?x?xf32, 0>)
     %U = memref.cast %A : memref<10x3xf32, 0> to memref<*xf32>
-    call @print_memref_f32(%U) : (memref<*xf32>) -> ()
+    call @printMemrefF32(%U) : (memref<*xf32>) -> ()
 
     %V2 = memref.cast %U : memref<*xf32> to memref<?x?xf32>
     linalg.fill ins(%f5 : f32) outs(%V2 : memref<?x?xf32, 0>)
     %U2 = memref.cast %V2 : memref<?x?xf32, 0> to memref<*xf32>
-    call @print_memref_f32(%U2) : (memref<*xf32>) -> ()
+    call @printMemrefF32(%U2) : (memref<*xf32>) -> ()
 
     %V3 = memref.cast %V2 : memref<?x?xf32> to memref<*xf32>
     %V4 = memref.cast %V3 : memref<*xf32> to memref<?x?xf32>
     linalg.fill ins(%f2 : f32) outs(%V4 : memref<?x?xf32, 0>)
     %U3 = memref.cast %V2 : memref<?x?xf32> to memref<*xf32>
-    call @print_memref_f32(%U3) : (memref<*xf32>) -> ()
+    call @printMemrefF32(%U3) : (memref<*xf32>) -> ()
 
     // 122 is ASCII for 'z'.
     %i8_z = arith.constant 122 : i8
     %I8 = memref.alloc() : memref<i8>
     memref.store %i8_z, %I8[]: memref<i8>
     %U4 = memref.cast %I8 : memref<i8> to memref<*xi8>
-    call @print_memref_i8(%U4) : (memref<*xi8>) -> ()
+    call @printMemrefI8(%U4) : (memref<*xi8>) -> ()
 
     memref.dealloc %U4 : memref<*xi8>
     memref.dealloc %A : memref<10x3xf32, 0>
 
     call @return_var_memref_caller() : () -> ()
     call @return_two_var_memref_caller() : () -> ()
     call @dim_op_of_unranked() : () -> ()
     return
 }
 
-func.func private @print_memref_i8(memref<*xi8>) attributes { llvm.emit_c_interface }
-func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefI8(memref<*xi8>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
 
 func.func @return_two_var_memref_caller() {
   %0 = memref.alloca() : memref<4x3xf32>
   %c0f32 = arith.constant 1.0 : f32
   linalg.fill ins(%c0f32 : f32) outs(%0 : memref<4x3xf32>)
   %1:2 = call @return_two_var_memref(%0) : (memref<4x3xf32>) -> (memref<*xf32>, memref<*xf32>)
-  call @print_memref_f32(%1#0) : (memref<*xf32>) -> ()
-  call @print_memref_f32(%1#1) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%1#0) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%1#1) : (memref<*xf32>) -> ()
   return
  }
 
  func.func @return_two_var_memref(%arg0: memref<4x3xf32>) -> (memref<*xf32>, memref<*xf32>) {
   %0 = memref.cast %arg0 : memref<4x3xf32> to memref<*xf32>
   return %0, %0 : memref<*xf32>, memref<*xf32>
 }
 
 func.func @return_var_memref_caller() {
   %0 = memref.alloca() : memref<4x3xf32>
   %c0f32 = arith.constant 1.0 : f32
   linalg.fill ins(%c0f32 : f32) outs(%0 : memref<4x3xf32>)
   %1 = call @return_var_memref(%0) : (memref<4x3xf32>) -> memref<*xf32>
-  call @print_memref_f32(%1) : (memref<*xf32>) -> ()
+  call @printMemrefF32(%1) : (memref<*xf32>) -> ()
   return
 }
 
 func.func @return_var_memref(%arg0: memref<4x3xf32>) -> memref<*xf32> {
   %0 = memref.cast %arg0: memref<4x3xf32> to memref<*xf32>
   return %0 : memref<*xf32>
 }
 

mlir/test/mlir-cpu-runner/utils.mlir

 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D
 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D
 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D
 // RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D
 
 func.func @print_0d() {
   %f = arith.constant 2.00000e+00 : f32
   %A = memref.alloc() : memref<f32>
   memref.store %f, %A[]: memref<f32>
   %U = memref.cast %A :  memref<f32> to memref<*xf32>
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
   memref.dealloc %A : memref<f32>
   return
 }
 // PRINT-0D: Unranked Memref base@ = {{.*}} rank = 0 offset = 0 sizes = [] strides = [] data =
 // PRINT-0D: [2]
 
 func.func @print_1d() {
   %f = arith.constant 2.00000e+00 : f32
   %A = memref.alloc() : memref<16xf32>
   %B = memref.cast %A: memref<16xf32> to memref<?xf32>
   linalg.fill ins(%f : f32) outs(%B : memref<?xf32>)
   %U = memref.cast %B :  memref<?xf32> to memref<*xf32>
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
   memref.dealloc %A : memref<16xf32>
   return
 }
 // PRINT-1D: Unranked Memref base@ = {{.*}} rank = 1 offset = 0 sizes = [16] strides = [1] data =
 // PRINT-1D-NEXT: [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
 
 func.func @print_3d() {
   %f = arith.constant 2.00000e+00 : f32
   %f4 = arith.constant 4.00000e+00 : f32
   %A = memref.alloc() : memref<3x4x5xf32>
   %B = memref.cast %A: memref<3x4x5xf32> to memref<?x?x?xf32>
   linalg.fill ins(%f : f32) outs(%B : memref<?x?x?xf32>)
 
   %c2 = arith.constant 2 : index
   memref.store %f4, %B[%c2, %c2, %c2]: memref<?x?x?xf32>
   %U = memref.cast %B : memref<?x?x?xf32> to memref<*xf32>
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
   memref.dealloc %A : memref<3x4x5xf32>
   return
 }
 // PRINT-3D: Unranked Memref base@ = {{.*}} rank = 3 offset = 0 sizes = [3, 4, 5] strides = [20, 5, 1] data =
 // PRINT-3D-COUNT-4: {{.*[[:space:]].*}}2,    2,    2,    2,    2
 // PRINT-3D-COUNT-4: {{.*[[:space:]].*}}2,    2,    2,    2,    2
 // PRINT-3D-COUNT-2: {{.*[[:space:]].*}}2,    2,    2,    2,    2
 //    PRINT-3D-NEXT: 2,    2,    4,    2,    2
 //    PRINT-3D-NEXT: 2,    2,    2,    2,    2
 
-func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
 
 !vector_type_C = type vector<4x4xf32>
 !matrix_type_CC = type memref<1x1x!vector_type_C>
 func.func @vector_splat_2d() {
   %c0 = arith.constant 0 : index
   %f10 = arith.constant 10.0 : f32
   %vf10 = vector.splat %f10: !vector_type_C
   %C = memref.alloc() : !matrix_type_CC
   memref.store %vf10, %C[%c0, %c0]: !matrix_type_CC
 
   %CC = memref.cast %C: !matrix_type_CC to memref<?x?x!vector_type_C>
-  call @print_memref_vector_4x4xf32(%CC): (memref<?x?x!vector_type_C>) -> ()
+  call @printMemrefVector4x4xf32(%CC): (memref<?x?x!vector_type_C>) -> ()
 
   memref.dealloc %C : !matrix_type_CC
   return
 }
 
 // PRINT-VECTOR-SPLAT-2D: Memref base@ = {{.*}} rank = 2 offset = 0 sizes = [1, 1] strides = [1, 1] data =
 // PRINT-VECTOR-SPLAT-2D-NEXT: [((10, 10, 10, 10),   (10, 10, 10, 10),   (10, 10, 10, 10),   (10, 10, 10, 10))]
 
-func.func private @print_memref_vector_4x4xf32(memref<?x?x!vector_type_C>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefVector4x4xf32(memref<?x?x!vector_type_C>) attributes { llvm.emit_c_interface }

mlir/test/mlir-opt/async.mlir

func.func @main() {
   %c2 = arith.constant 2.0 : f32
   %c3 = arith.constant 3.0 : f32
   %c4 = arith.constant 4.0 : f32
 
   %A = memref.alloc() : memref<4xf32>
   linalg.fill ins(%c0 : f32) outs(%A : memref<4xf32>)
 
   %U = memref.cast %A :  memref<4xf32> to memref<*xf32>
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   memref.store %c1, %A[%i0]: memref<4xf32>
   call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   %outer = async.execute {
     memref.store %c2, %A[%i1]: memref<4xf32>
     func.call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
-    func.call @print_memref_f32(%U): (memref<*xf32>) -> ()
+    func.call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
     // No op async region to create a token for testing async dependency.
     %noop = async.execute {
       func.call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
       async.yield
     }
 
     %inner = async.execute [%noop] {
       memref.store %c3, %A[%i2]: memref<4xf32>
       func.call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
-      func.call @print_memref_f32(%U): (memref<*xf32>) -> ()
+      func.call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
       async.yield
     }
     async.await %inner : !async.token
 
     memref.store %c4, %A[%i3]: memref<4xf32>
     func.call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
-    func.call @print_memref_f32(%U): (memref<*xf32>) -> ()
+    func.call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
     async.yield
   }
   async.await %outer : !async.token
 
   call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
-  call @print_memref_f32(%U): (memref<*xf32>) -> ()
+  call @printMemrefF32(%U): (memref<*xf32>) -> ()
 
   memref.dealloc %A : memref<4xf32>
 
   return
 }
 
 func.func private @mlirAsyncRuntimePrintCurrentThreadId() -> ()
 
-func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
+func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }

mlir/test/mlir-spirv-cpu-runner/double.mlir

func.func @main() {
     call @fillI32Buffer(%input_casted, %four) : (memref<?xi32>, i32) -> ()
     call @fillI32Buffer(%output_casted, %zero) : (memref<?xi32>, i32) -> ()
 
     %one = arith.constant 1 : index
     gpu.launch_func @kernels::@double
         blocks in (%one, %one, %one) threads in (%one, %one, %one)
         args(%input : memref<6xi32>, %output : memref<6xi32>)
     %result = memref.cast %output : memref<6xi32> to memref<*xi32>
-    call @print_memref_i32(%result) : (memref<*xi32>) -> ()
+    call @printMemrefI32(%result) : (memref<*xi32>) -> ()
     return
   }
 
   func.func private @fillI32Buffer(%arg0 : memref<?xi32>, %arg1 : i32)
-  func.func private @print_memref_i32(%ptr : memref<*xi32>)
+  func.func private @printMemrefI32(%ptr : memref<*xi32>)
 }

mlir/test/mlir-spirv-cpu-runner/simple_add.mlir

func.func @main() {
     call @fillF32Buffer2D(%input2_casted, %4) : (memref<?x?xf32>, f32) -> ()
     call @fillF32Buffer3D(%output_casted, %0) : (memref<?x?x?xf32>, f32) -> ()
 
     %one = arith.constant 1 : index
     gpu.launch_func @kernels::@sum
         blocks in (%one, %one, %one) threads in (%one, %one, %one)
         args(%input1 : memref<3xf32>, %input2 : memref<3x3xf32>, %output : memref<3x3x3xf32>)
     %result = memref.cast %output : memref<3x3x3xf32> to memref<*xf32>
-    call @print_memref_f32(%result) : (memref<*xf32>) -> ()
+    call @printMemrefF32(%result) : (memref<*xf32>) -> ()
     return
   }
   func.func private @fillF32Buffer1D(%arg0 : memref<?xf32>, %arg1 : f32)
   func.func private @fillF32Buffer2D(%arg0 : memref<?x?xf32>, %arg1 : f32)
   func.func private @fillF32Buffer3D(%arg0 : memref<?x?x?xf32>, %arg1 : f32)
-  func.func private @print_memref_f32(%arg0 : memref<*xf32>)
+  func.func private @printMemrefF32(%arg0 : memref<*xf32>)
 }

mlir/test/mlir-vulkan-runner/addf.mlir

func.func @main() {
     call @fillResource1DFloat(%arg5, %value0) : (memref<?xf32>, f32) -> ()
 
     %cst1 = arith.constant 1 : index
     %cst8 = arith.constant 8 : index
     gpu.launch_func @kernels::@kernel_add
         blocks in (%cst8, %cst1, %cst1) threads in (%cst1, %cst1, %cst1)
         args(%arg0 : memref<8xf32>, %arg1 : memref<8xf32>, %arg2 : memref<8xf32>)
     %arg6 = memref.cast %arg5 : memref<?xf32> to memref<*xf32>
-    call @print_memref_f32(%arg6) : (memref<*xf32>) -> ()
+    call @printMemrefF32(%arg6) : (memref<*xf32>) -> ()
     return
   }
   func.func private @fillResource1DFloat(%0 : memref<?xf32>, %1 : f32)
-  func.func private @print_memref_f32(%ptr : memref<*xf32>)
+  func.func private @printMemrefF32(%ptr : memref<*xf32>)
 }
 

mlir/test/mlir-vulkan-runner/addi.mlir

func.func @main() {
     call @fillResource3DInt(%arg5, %value0) : (memref<?x?x?xi32>, i32) -> ()
 
     %cst1 = arith.constant 1 : index
     %cst8 = arith.constant 8 : index
     gpu.launch_func @kernels::@kernel_addi
         blocks in (%cst8, %cst8, %cst8) threads in (%cst1, %cst1, %cst1)
         args(%arg0 : memref<8xi32>, %arg1 : memref<8x8xi32>, %arg2 : memref<8x8x8xi32>)
     %arg6 = memref.cast %arg5 : memref<?x?x?xi32> to memref<*xi32>
-    call @print_memref_i32(%arg6) : (memref<*xi32>) -> ()
+    call @printMemrefI32(%arg6) : (memref<*xi32>) -> ()
     return
   }
   func.func private @fillResource1DInt(%0 : memref<?xi32>, %1 : i32)
   func.func private @fillResource2DInt(%0 : memref<?x?xi32>, %1 : i32)
   func.func private @fillResource3DInt(%0 : memref<?x?x?xi32>, %1 : i32)
-  func.func private @print_memref_i32(%ptr : memref<*xi32>)
+  func.func private @printMemrefI32(%ptr : memref<*xi32>)
 }
 

mlir/test/mlir-vulkan-runner/addi8.mlir

func.func @main() {
     call @fillResource3DInt(%arg5, %value0) : (memref<?x?x?xi32>, i32) -> ()
 
     %cst1 = arith.constant 1 : index
     %cst8 = arith.constant 8 : index
     gpu.launch_func @kernels::@kernel_addi
         blocks in (%cst8, %cst8, %cst8) threads in (%cst1, %cst1, %cst1)
         args(%arg0 : memref<8xi8>, %arg1 : memref<8x8xi8>, %arg2 : memref<8x8x8xi32>)
     %arg6 = memref.cast %arg5 : memref<?x?x?xi32> to memref<*xi32>
-    call @print_memref_i32(%arg6) : (memref<*xi32>) -> ()
+    call @printMemrefI32(%arg6) : (memref<*xi32>) -> ()
     return
   }
   func.func private @fillResource1DInt8(%0 : memref<?xi8>, %1 : i8)
   func.func private @fillResource2DInt8(%0 : memref<?x?xi8>, %1 : i8)
   func.func private @fillResource3DInt(%0 : memref<?x?x?xi32>, %1 : i32)
-  func.func private @print_memref_i32(%ptr : memref<*xi32>)
+  func.func private @printMemrefI32(%ptr : memref<*xi32>)
 }

mlir/test/mlir-vulkan-runner/mulf.mlir

func.func @main() {
     call @fillResource2DFloat(%arg5, %value0) : (memref<?x?xf32>, f32) -> ()
 
     %cst1 = arith.constant 1 : index
     %cst4 = arith.constant 4 : index
     gpu.launch_func @kernels::@kernel_mul
         blocks in (%cst4, %cst4, %cst1) threads in(%cst1, %cst1, %cst1)
         args(%arg0 : memref<4x4xf32>, %arg1 : memref<4x4xf32>, %arg2 : memref<4x4xf32>)
     %arg6 = memref.cast %arg5 : memref<?x?xf32> to memref<*xf32>
-    call @print_memref_f32(%arg6) : (memref<*xf32>) -> ()
+    call @printMemrefF32(%arg6) : (memref<*xf32>) -> ()
     return
   }
   func.func private @fillResource2DFloat(%0 : memref<?x?xf32>, %1 : f32)
-  func.func private @print_memref_f32(%ptr : memref<*xf32>)
+  func.func private @printMemrefF32(%ptr : memref<*xf32>)
 }
 

mlir/test/mlir-vulkan-runner/subf.mlir

func.func @main() {
 
     %cst1 = arith.constant 1 : index
     %cst4 = arith.constant 4 : index
     %cst8 = arith.constant 8 : index
     gpu.launch_func @kernels::@kernel_sub
         blocks in (%cst8, %cst4, %cst4) threads in (%cst1, %cst1, %cst1)
         args(%arg0 : memref<8x4x4xf32>, %arg1 : memref<4x4xf32>, %arg2 : memref<8x4x4xf32>)
     %arg6 = memref.cast %arg5 : memref<?x?x?xf32> to memref<*xf32>
-    call @print_memref_f32(%arg6) : (memref<*xf32>) -> ()
+    call @printMemrefF32(%arg6) : (memref<*xf32>) -> ()
     return
   }
   func.func private @fillResource2DFloat(%0 : memref<?x?xf32>, %1 : f32)
   func.func private @fillResource3DFloat(%0 : memref<?x?x?xf32>, %1 : f32)
-  func.func private @print_memref_f32(%ptr : memref<*xf32>)
+  func.func private @printMemrefF32(%ptr : memref<*xf32>)
 }

mlir/test/mlir-vulkan-runner/time.mlir

func.func @main() {
     %cst128 = arith.constant 128 : index
     gpu.launch_func @kernels::@kernel_add
         blocks in (%cst128, %cst1, %cst1) threads in (%cst128, %cst1, %cst1)
         args(%arg0 : memref<16384xf32>, %arg1 : memref<16384xf32>, %arg2 : memref<16384xf32>)
     %arg6 = memref.cast %arg5 : memref<?xf32> to memref<*xf32>
     return
   }
   func.func private @fillResource1DFloat(%0 : memref<?xf32>, %1 : f32)
-  func.func private @print_memref_f32(%ptr : memref<*xf32>)
+  func.func private @printMemrefF32(%ptr : memref<*xf32>)
 }
 

mlir/test/python/execution_engine.py

def testSharedLibLoad():
   with Context():
     module = Module.parse("""
       module  {
       func.func @main(%arg0: memref<1xf32>) attributes { llvm.emit_c_interface } {
         %c0 = arith.constant 0 : index
         %cst42 = arith.constant 42.0 : f32
         memref.store %cst42, %arg0[%c0] : memref<1xf32>
         %u_memref = memref.cast %arg0 : memref<1xf32> to memref<*xf32>
-        call @print_memref_f32(%u_memref) : (memref<*xf32>) -> ()
+        call @printMemrefF32(%u_memref) : (memref<*xf32>) -> ()
         return
       }
-      func.func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
+      func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
      } """)
     arg0 = np.array([0.0]).astype(np.float32)
 
     arg0_memref_ptr = ctypes.pointer(
         ctypes.pointer(get_ranked_memref_descriptor(arg0)))
 
     execution_engine = ExecutionEngine(
         lowerToLLVM(module),

 
 #  Test that nano time clock is available.
 # CHECK-LABEL: TEST: testNanoTime
 def testNanoTime():
   with Context():
     module = Module.parse("""
       module {
       func.func @main() attributes { llvm.emit_c_interface } {
-        %now = call @nano_time() : () -> i64
+        %now = call @nanoTime() : () -> i64
         %memref = memref.alloca() : memref<1xi64>
         %c0 = arith.constant 0 : index
         memref.store %now, %memref[%c0] : memref<1xi64>
         %u_memref = memref.cast %memref : memref<1xi64> to memref<*xi64>
-        call @print_memref_i64(%u_memref) : (memref<*xi64>) -> ()
+        call @printMemrefI64(%u_memref) : (memref<*xi64>) -> ()
         return
       }
-      func.func private @nano_time() -> i64 attributes { llvm.emit_c_interface }
-      func.func private @print_memref_i64(memref<*xi64>) attributes { llvm.emit_c_interface }
+      func.func private @nanoTime() -> i64 attributes { llvm.emit_c_interface }
+      func.func private @printMemrefI64(memref<*xi64>) attributes { llvm.emit_c_interface }
     }""")
 
     execution_engine = ExecutionEngine(
         lowerToLLVM(module),
         opt_level=3,
         shared_libs=[
             "../../../../lib/libmlir_runner_utils.so",
             "../../../../lib/libmlir_c_runner_utils.so"
         ])
     execution_engine.invoke("main")
     # CHECK: Unranked Memref
     # CHECK: [{{.*}}]
 
 
 run(testNanoTime)