diff --git a/mlir/include/mlir/Conversion/LLVMCommon/PrintCallHelper.h b/mlir/include/mlir/Conversion/LLVMCommon/PrintCallHelper.h new file mode 100644 index 00000000000000..c2742b6fc1d737 --- /dev/null +++ b/mlir/include/mlir/Conversion/LLVMCommon/PrintCallHelper.h @@ -0,0 +1,35 @@ +//===- PrintCallHelper.h - Helper to emit runtime print calls ---*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef MLIR_DIALECT_LLVMIR_PRINTCALLHELPER_H_ +#define MLIR_DIALECT_LLVMIR_PRINTCALLHELPER_H_ + +#include "mlir/Dialect/LLVMIR/LLVMDialect.h" +#include "llvm/ADT/StringRef.h" +#include + +namespace mlir { + +class OpBuilder; +class LLVMTypeConverter; + +namespace LLVM { + +/// Generate IR that prints the given string to stdout. +/// If a custom runtime function is defined via `runtimeFunctionName`, it must +/// have the signature void(char const*). The default function is `printString`. +void createPrintStrCall(OpBuilder &builder, Location loc, ModuleOp moduleOp, + StringRef symbolName, StringRef string, + const LLVMTypeConverter &typeConverter, + bool addNewline = true, + std::optional runtimeFunctionName = {}); +} // namespace LLVM + +} // namespace mlir + +#endif diff --git a/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h b/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h index 17aa9a3c831c2e..9e69717f471bce 100644 --- a/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h +++ b/mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h @@ -16,6 +16,7 @@ #include "mlir/IR/Operation.h" #include "mlir/Support/LLVM.h" +#include namespace mlir { class Location; @@ -38,8 +39,12 @@ LLVM::LLVMFuncOp lookupOrCreatePrintF16Fn(ModuleOp moduleOp); LLVM::LLVMFuncOp lookupOrCreatePrintBF16Fn(ModuleOp moduleOp); LLVM::LLVMFuncOp lookupOrCreatePrintF32Fn(ModuleOp moduleOp); LLVM::LLVMFuncOp lookupOrCreatePrintF64Fn(ModuleOp moduleOp); -LLVM::LLVMFuncOp lookupOrCreatePrintStrFn(ModuleOp moduleOp, - bool opaquePointers); +/// Declares a function to print a C-string. +/// If a custom runtime function is defined via `runtimeFunctionName`, it must +/// have the signature void(char const*). The default function is `printString`. +LLVM::LLVMFuncOp +lookupOrCreatePrintStringFn(ModuleOp moduleOp, bool opaquePointers, + std::optional runtimeFunctionName = {}); LLVM::LLVMFuncOp lookupOrCreatePrintOpenFn(ModuleOp moduleOp); LLVM::LLVMFuncOp lookupOrCreatePrintCloseFn(ModuleOp moduleOp); LLVM::LLVMFuncOp lookupOrCreatePrintCommaFn(ModuleOp moduleOp); diff --git a/mlir/include/mlir/Dialect/Vector/IR/VectorOps.td b/mlir/include/mlir/Dialect/Vector/IR/VectorOps.td index 917b27a40f26f1..168ff45ca61542 100644 --- a/mlir/include/mlir/Dialect/Vector/IR/VectorOps.td +++ b/mlir/include/mlir/Dialect/Vector/IR/VectorOps.td @@ -26,6 +26,7 @@ include "mlir/Interfaces/InferTypeOpInterface.td" include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/VectorInterfaces.td" include "mlir/Interfaces/ViewLikeInterface.td" +include "mlir/IR/BuiltinAttributes.td" // TODO: Add an attribute to specify a different algebra with operators other // than the current set: {*, +}. @@ -2477,12 +2478,18 @@ def Vector_TransposeOp : } def Vector_PrintOp : - Vector_Op<"print", []>, + Vector_Op<"print", [ + PredOpTrait< + "`source` or `punctuation` are not set when printing strings", + CPred<"!getStringLiteral() || (!getSource() && getPunctuation() == PrintPunctuation::NewLine)"> + >, + ]>, Arguments<(ins Optional>>:$source, DefaultValuedAttr:$punctuation) + "::mlir::vector::PrintPunctuation::NewLine">:$punctuation, + OptionalAttr:$stringLiteral) > { let summary = "print operation (for testing and debugging)"; let description = [{ @@ -2521,6 +2528,13 @@ def Vector_PrintOp : ```mlir vector.print punctuation ``` + + Additionally, to aid with debugging and testing `vector.print` can also + print constant strings: + + ```mlir + vector.print str "Hello, World!" + ``` }]; let extraClassDeclaration = [{ Type getPrintType() { @@ -2529,11 +2543,26 @@ def Vector_PrintOp : }]; let builders = [ OpBuilder<(ins "PrintPunctuation":$punctuation), [{ - build($_builder, $_state, {}, punctuation); + build($_builder, $_state, {}, punctuation, {}); + }]>, + OpBuilder<(ins "::mlir::Value":$source), [{ + build($_builder, $_state, source, PrintPunctuation::NewLine); + }]>, + OpBuilder<(ins "::mlir::Value":$source, "PrintPunctuation":$punctuation), [{ + build($_builder, $_state, source, punctuation, {}); + }]>, + OpBuilder<(ins "::llvm::StringRef":$string), [{ + build($_builder, $_state, {}, PrintPunctuation::NewLine, $_builder.getStringAttr(string)); }]>, ]; - let assemblyFormat = "($source^ `:` type($source))? (`punctuation` $punctuation^)? attr-dict"; + let assemblyFormat = [{ + ($source^ `:` type($source))? + oilist( + `str` $stringLiteral + | `punctuation` $punctuation) + attr-dict + }]; } //===----------------------------------------------------------------------===// diff --git a/mlir/include/mlir/ExecutionEngine/CRunnerUtils.h b/mlir/include/mlir/ExecutionEngine/CRunnerUtils.h index e8f429463cb0b9..76b04145b482e4 100644 --- a/mlir/include/mlir/ExecutionEngine/CRunnerUtils.h +++ b/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(); diff --git a/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp b/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp index a4f146bbe475cc..433d8a01a1ac8a 100644 --- a/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp +++ b/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp @@ -16,6 +16,7 @@ #include "mlir/Conversion/ConvertToLLVM/ToLLVMInterface.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/Pattern.h" +#include "mlir/Conversion/LLVMCommon/PrintCallHelper.h" #include "mlir/Conversion/LLVMCommon/VectorPattern.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h" @@ -36,51 +37,6 @@ using namespace mlir; #define PASS_NAME "convert-cf-to-llvm" -static std::string generateGlobalMsgSymbolName(ModuleOp moduleOp) { - std::string prefix = "assert_msg_"; - int counter = 0; - while (moduleOp.lookupSymbol(prefix + std::to_string(counter))) - ++counter; - return prefix + std::to_string(counter); -} - -/// Generate IR that prints the given string to stderr. -static void createPrintMsg(OpBuilder &builder, Location loc, ModuleOp moduleOp, - StringRef msg, - const LLVMTypeConverter &typeConverter) { - auto ip = builder.saveInsertionPoint(); - builder.setInsertionPointToStart(moduleOp.getBody()); - MLIRContext *ctx = builder.getContext(); - - // Create a zero-terminated byte representation and allocate global symbol. - SmallVector elementVals; - elementVals.append(msg.begin(), msg.end()); - elementVals.push_back(0); - auto dataAttrType = RankedTensorType::get( - {static_cast(elementVals.size())}, builder.getI8Type()); - auto dataAttr = - DenseElementsAttr::get(dataAttrType, llvm::ArrayRef(elementVals)); - auto arrayTy = - LLVM::LLVMArrayType::get(IntegerType::get(ctx, 8), elementVals.size()); - std::string symbolName = generateGlobalMsgSymbolName(moduleOp); - auto globalOp = builder.create( - loc, arrayTy, /*constant=*/true, LLVM::Linkage::Private, symbolName, - dataAttr); - - // Emit call to `printStr` in runtime library. - builder.restoreInsertionPoint(ip); - auto msgAddr = builder.create( - loc, typeConverter.getPointerType(arrayTy), globalOp.getName()); - SmallVector indices(1, 0); - Value gep = builder.create( - loc, typeConverter.getPointerType(builder.getI8Type()), arrayTy, msgAddr, - indices); - Operation *printer = LLVM::lookupOrCreatePrintStrFn( - moduleOp, typeConverter.useOpaquePointers()); - builder.create(loc, TypeRange(), SymbolRefAttr::get(printer), - gep); -} - namespace { /// Lower `cf.assert`. The default lowering calls the `abort` function if the /// assertion is violated and has no effect otherwise. The failure message is @@ -105,7 +61,9 @@ struct AssertOpLowering : public ConvertOpToLLVMPattern { // Failed block: Generate IR to print the message and call `abort`. Block *failureBlock = rewriter.createBlock(opBlock->getParent()); - createPrintMsg(rewriter, loc, module, op.getMsg(), *getTypeConverter()); + LLVM::createPrintStrCall(rewriter, loc, module, "assert_msg", op.getMsg(), + *getTypeConverter(), /*addNewLine=*/false, + /*runtimeFunctionName=*/"puts"); if (abortOnFailedAssert) { // Insert the `abort` declaration if necessary. auto abortFunc = module.lookupSymbol("abort"); diff --git a/mlir/lib/Conversion/LLVMCommon/CMakeLists.txt b/mlir/lib/Conversion/LLVMCommon/CMakeLists.txt index 091cd539f0ae01..568d9339aaabcb 100644 --- a/mlir/lib/Conversion/LLVMCommon/CMakeLists.txt +++ b/mlir/lib/Conversion/LLVMCommon/CMakeLists.txt @@ -3,6 +3,7 @@ add_mlir_conversion_library(MLIRLLVMCommonConversion LoweringOptions.cpp MemRefBuilder.cpp Pattern.cpp + PrintCallHelper.cpp StructBuilder.cpp TypeConverter.cpp VectorPattern.cpp diff --git a/mlir/lib/Conversion/LLVMCommon/PrintCallHelper.cpp b/mlir/lib/Conversion/LLVMCommon/PrintCallHelper.cpp new file mode 100644 index 00000000000000..6293643ac6f034 --- /dev/null +++ b/mlir/lib/Conversion/LLVMCommon/PrintCallHelper.cpp @@ -0,0 +1,66 @@ +//===- PrintCallHelper.cpp - Helper to emit runtime print calls -----------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "mlir/Conversion/LLVMCommon/PrintCallHelper.h" +#include "mlir/Conversion/LLVMCommon/TypeConverter.h" +#include "mlir/Dialect/LLVMIR/FunctionCallUtils.h" +#include "mlir/Dialect/LLVMIR/LLVMDialect.h" +#include "mlir/IR/Builders.h" +#include "mlir/IR/BuiltinOps.h" +#include "llvm/ADT/ArrayRef.h" + +using namespace mlir; +using namespace llvm; + +static std::string ensureSymbolNameIsUnique(ModuleOp moduleOp, + StringRef symbolName) { + static int counter = 0; + std::string uniqueName = std::string(symbolName); + while (moduleOp.lookupSymbol(uniqueName)) { + uniqueName = std::string(symbolName) + "_" + std::to_string(counter++); + } + return uniqueName; +} + +void mlir::LLVM::createPrintStrCall( + OpBuilder &builder, Location loc, ModuleOp moduleOp, StringRef symbolName, + StringRef string, const LLVMTypeConverter &typeConverter, bool addNewline, + std::optional runtimeFunctionName) { + auto ip = builder.saveInsertionPoint(); + builder.setInsertionPointToStart(moduleOp.getBody()); + MLIRContext *ctx = builder.getContext(); + + // Create a zero-terminated byte representation and allocate global symbol. + SmallVector elementVals; + elementVals.append(string.begin(), string.end()); + if (addNewline) + elementVals.push_back('\n'); + elementVals.push_back('\0'); + auto dataAttrType = RankedTensorType::get( + {static_cast(elementVals.size())}, builder.getI8Type()); + auto dataAttr = + DenseElementsAttr::get(dataAttrType, llvm::ArrayRef(elementVals)); + auto arrayTy = + LLVM::LLVMArrayType::get(IntegerType::get(ctx, 8), elementVals.size()); + auto globalOp = builder.create( + loc, arrayTy, /*constant=*/true, LLVM::Linkage::Private, + ensureSymbolNameIsUnique(moduleOp, symbolName), dataAttr); + + // Emit call to `printStr` in runtime library. + builder.restoreInsertionPoint(ip); + auto msgAddr = builder.create( + loc, typeConverter.getPointerType(arrayTy), globalOp.getName()); + SmallVector indices(1, 0); + Value gep = builder.create( + loc, typeConverter.getPointerType(builder.getI8Type()), arrayTy, msgAddr, + indices); + Operation *printer = LLVM::lookupOrCreatePrintStringFn( + moduleOp, typeConverter.useOpaquePointers(), runtimeFunctionName); + builder.create(loc, TypeRange(), SymbolRefAttr::get(printer), + gep); +} diff --git a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp index 8427d60f14c0bc..4af58653c8227a 100644 --- a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp +++ b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp @@ -9,6 +9,7 @@ #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h" #include "mlir/Conversion/ArithCommon/AttrToLLVMConverter.h" +#include "mlir/Conversion/LLVMCommon/PrintCallHelper.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/VectorPattern.h" #include "mlir/Dialect/Arith/IR/Arith.h" @@ -1548,7 +1549,10 @@ class VectorPrintOpConversion : public ConvertOpToLLVMPattern { } auto punct = printOp.getPunctuation(); - if (punct != PrintPunctuation::NoPunctuation) { + if (auto stringLiteral = printOp.getStringLiteral()) { + LLVM::createPrintStrCall(rewriter, loc, parent, "vector_print_str", + *stringLiteral, *getTypeConverter()); + } else if (punct != PrintPunctuation::NoPunctuation) { emitCall(rewriter, printOp->getLoc(), [&] { switch (punct) { case PrintPunctuation::Close: diff --git a/mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp b/mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp index aef3a5a87e9bfe..7ed8296a22a457 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp +++ b/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 kPrintStr = "puts"; +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,10 @@ static LLVM::LLVMPointerType getVoidPtr(MLIRContext *context, return getCharPtr(context, opaquePointers); } -LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreatePrintStrFn(ModuleOp moduleOp, - bool opaquePointers) { - return lookupOrCreateFn(moduleOp, kPrintStr, +LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreatePrintStringFn( + ModuleOp moduleOp, bool opaquePointers, + std::optional runtimeFunctionName) { + return lookupOrCreateFn(moduleOp, runtimeFunctionName.value_or(kPrintString), getCharPtr(moduleOp->getContext(), opaquePointers), LLVM::LLVMVoidType::get(moduleOp->getContext())); } diff --git a/mlir/lib/ExecutionEngine/CRunnerUtils.cpp b/mlir/lib/ExecutionEngine/CRunnerUtils.cpp index c31ae3a1c7ce11..e28e75eb110303 100644 --- a/mlir/lib/ExecutionEngine/CRunnerUtils.cpp +++ b/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); } diff --git a/mlir/lib/ExecutionEngine/RunnerUtils.cpp b/mlir/lib/ExecutionEngine/RunnerUtils.cpp index ccf5309487637e..4618866f68a44b 100644 --- a/mlir/lib/ExecutionEngine/RunnerUtils.cpp +++ b/mlir/lib/ExecutionEngine/RunnerUtils.cpp @@ -158,7 +158,8 @@ extern "C" void printMemrefC64(int64_t rank, void *ptr) { _mlir_ciface_printMemrefC64(&descriptor); } -extern "C" void printCString(char *str) { printf("%s", str); } +/// Deprecated. This should be unified with printString from CRunnerUtils. +extern "C" void printCString(char *str) { fputs(str, stdout); } extern "C" void _mlir_ciface_printMemref0dF32(StridedMemRefType *M) { impl::printMemRef(*M); diff --git a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir index 9aa4d735681f57..05733214bc3ae8 100644 --- a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir +++ b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir @@ -1068,6 +1068,20 @@ func.func @vector_print_scalar_f64(%arg0: f64) { // ----- +// CHECK-LABEL: module { +// 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 @printString(%[[STR_PTR]]) : (!llvm.ptr) -> () +func.func @vector_print_string() { + vector.print str "Hello, World!" + return +} + +// ----- + func.func @extract_strided_slice1(%arg0: vector<4xf32>) -> vector<2xf32> { %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32> return %0 : vector<2xf32> diff --git a/mlir/test/Dialect/Vector/invalid.mlir b/mlir/test/Dialect/Vector/invalid.mlir index 504ac89659fdb7..edb2689364a987 100644 --- a/mlir/test/Dialect/Vector/invalid.mlir +++ b/mlir/test/Dialect/Vector/invalid.mlir @@ -1016,6 +1016,22 @@ func.func private @print_needs_vector(%arg0: tensor<8xf32>) { // ----- +func.func @cannot_print_string_with_punctuation_set() { + // expected-error@+1 {{`source` or `punctuation` are not set when printing strings}} + vector.print str "Whoops!" punctuation + return +} + +// ----- + +func.func @cannot_print_string_with_source_set(%vec: vector<[4]xf32>) { + // expected-error@+1 {{`source` or `punctuation` are not set when printing strings}} + vector.print %vec: vector<[4]xf32> str "Yay!" + return +} + +// ----- + func.func @reshape_bad_input_shape(%arg0 : vector<3x2x4xf32>) { %c2 = arith.constant 2 : index %c3 = arith.constant 3 : index diff --git a/mlir/test/Integration/Dialect/Vector/CPU/test-print-str.mlir b/mlir/test/Integration/Dialect/Vector/CPU/test-print-str.mlir new file mode 100644 index 00000000000000..78d6609ccaf9a9 --- /dev/null +++ b/mlir/test/Integration/Dialect/Vector/CPU/test-print-str.mlir @@ -0,0 +1,14 @@ +// RUN: mlir-opt %s -test-lower-to-llvm | \ +// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ +// RUN: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \ +// RUN: FileCheck %s + +/// This tests printing (multiple) string literals works. + +func.func @entry() { + // CHECK: Hello, World! + vector.print str "Hello, World!" + // CHECK-NEXT: Bye! + vector.print str "Bye!" + return +}