Add printString to CRunnerUtils and use that instead

I've also defined this in RunnerUtils so linking either or both gives
you printString, this avoids the need to update a bunch of tests that
use cf.assert.

Author: MacDue

mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h

@@ -38,8 +38,8 @@ LLVM::LLVMFuncOp lookupOrCreatePrintF16Fn(ModuleOp moduleOp);
 LLVM::LLVMFuncOp lookupOrCreatePrintBF16Fn(ModuleOp moduleOp);
 LLVM::LLVMFuncOp lookupOrCreatePrintF32Fn(ModuleOp moduleOp);
 LLVM::LLVMFuncOp lookupOrCreatePrintF64Fn(ModuleOp moduleOp);
-LLVM::LLVMFuncOp lookupOrCreatePrintCStringFn(ModuleOp moduleOp,
-                                              bool opaquePointers);
+LLVM::LLVMFuncOp lookupOrCreatePrintStringFn(ModuleOp moduleOp,
+                                             bool opaquePointers);
 LLVM::LLVMFuncOp lookupOrCreatePrintOpenFn(ModuleOp moduleOp);
 LLVM::LLVMFuncOp lookupOrCreatePrintCloseFn(ModuleOp moduleOp);
 LLVM::LLVMFuncOp lookupOrCreatePrintCommaFn(ModuleOp moduleOp);

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

@@ -465,6 +465,7 @@ extern "C" MLIR_CRUNNERUTILS_EXPORT void printI64(int64_t i);
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printU64(uint64_t u);
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printF32(float f);
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printF64(double d);
+extern "C" MLIR_CRUNNERUTILS_EXPORT void printString(char const *s);
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printOpen();
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printClose();
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printComma();

mlir/lib/Conversion/LLVMCommon/PrintCallHelper.cpp

@@ -60,7 +60,7 @@ void mlir::LLVM::createPrintStrCall(OpBuilder &builder, Location loc,
   Value gep = builder.create<LLVM::GEPOp>(
       loc, typeConverter.getPointerType(builder.getI8Type()), arrayTy, msgAddr,
       indices);
-  Operation *printer = LLVM::lookupOrCreatePrintCStringFn(
+  Operation *printer = LLVM::lookupOrCreatePrintStringFn(
       moduleOp, typeConverter.useOpaquePointers());
   builder.create<LLVM::CallOp>(loc, TypeRange(), SymbolRefAttr::get(printer),
                                gep);

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

@@ -30,7 +30,7 @@ static constexpr llvm::StringRef kPrintF16 = "printF16";
 static constexpr llvm::StringRef kPrintBF16 = "printBF16";
 static constexpr llvm::StringRef kPrintF32 = "printF32";
 static constexpr llvm::StringRef kPrintF64 = "printF64";
-static constexpr llvm::StringRef kPrintCString = "printCString";
+static constexpr llvm::StringRef kPrintString = "printString";
 static constexpr llvm::StringRef kPrintOpen = "printOpen";
 static constexpr llvm::StringRef kPrintClose = "printClose";
 static constexpr llvm::StringRef kPrintComma = "printComma";
@@ -107,9 +107,9 @@ static LLVM::LLVMPointerType getVoidPtr(MLIRContext *context,
   return getCharPtr(context, opaquePointers);
 }
 
-LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreatePrintCStringFn(ModuleOp moduleOp,
-                                                          bool opaquePointers) {
-  return lookupOrCreateFn(moduleOp, kPrintCString,
+LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreatePrintStringFn(ModuleOp moduleOp,
+                                                         bool opaquePointers) {
+  return lookupOrCreateFn(moduleOp, kPrintString,
                           getCharPtr(moduleOp->getContext(), opaquePointers),
                           LLVM::LLVMVoidType::get(moduleOp->getContext()));
 }

mlir/lib/ExecutionEngine/CRunnerUtils.cpp

@@ -52,6 +52,7 @@ extern "C" void printI64(int64_t i) { fprintf(stdout, "%" PRId64, i); }
 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 printString(char const *s) { fputs(s, stdout); }
 extern "C" void printOpen() { fputs("( ", stdout); }
 extern "C" void printClose() { fputs(" )", stdout); }
 extern "C" void printComma() { fputs(", ", stdout); }

mlir/lib/ExecutionEngine/RunnerUtils.cpp

@@ -158,7 +158,10 @@ extern "C" void printMemrefC64(int64_t rank, void *ptr) {
   _mlir_ciface_printMemrefC64(&descriptor);
 }
 
-extern "C" void printCString(char *str) { printf("%s", str); }
+extern "C" void printCString(char *str) { fputs(str, stdout); }
+extern "C" void printString(char const *str) {
+  printCString(const_cast<char *>(str));
+}
 
 extern "C" void _mlir_ciface_printMemref0dF32(StridedMemRefType<float, 0> *M) {
   impl::printMemRef(*M);

mlir/test/Conversion/ControlFlowToLLVM/assert.mlir

@@ -10,12 +10,12 @@ func.func @main() {
   return
 }
 
-// CHECK: llvm.func @printCString(!llvm.ptr)
+// CHECK: llvm.func @printString(!llvm.ptr)
 
 // CHECK-LABEL: @main
 // CHECK: llvm.cond_br %{{.*}}, ^{{.*}}, ^[[FALSE_BRANCH:[[:alnum:]]+]]
 
 // CHECK: ^[[FALSE_BRANCH]]:
 // CHECK: %[[ADDRESS_OF:.*]] = llvm.mlir.addressof @{{.*}} : !llvm.ptr{{$}}
 // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDRESS_OF]][0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<{{[0-9]+}} x i8>
-// CHECK: llvm.call @printCString(%[[GEP]]) : (!llvm.ptr) -> ()
+// CHECK: llvm.call @printString(%[[GEP]]) : (!llvm.ptr) -> ()

mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir

@@ -1069,12 +1069,12 @@ func.func @vector_print_scalar_f64(%arg0: f64) {
 // -----
 
 // CHECK-LABEL: module {
-// CHECK: llvm.func @printCString(!llvm.ptr)
+// CHECK: llvm.func @printString(!llvm.ptr)
 // CHECK: llvm.mlir.global private constant @[[GLOBAL_STR:.*]]({{.*}})
 // CHECK: @vector_print_string
 //       CHECK-NEXT: %[[GLOBAL_ADDR:.*]] = llvm.mlir.addressof @[[GLOBAL_STR]] : !llvm.ptr
 //       CHECK-NEXT: %[[STR_PTR:.*]] = llvm.getelementptr %[[GLOBAL_ADDR]][0] : (!llvm.ptr) -> !llvm.ptr
-//       CHECK-NEXT: llvm.call @printCString(%[[STR_PTR]]) : (!llvm.ptr) -> ()
+//       CHECK-NEXT: llvm.call @printString(%[[STR_PTR]]) : (!llvm.ptr) -> ()
 func.func @vector_print_string() {
   vector.print str "Hello, World!"
   return