dialects: Add print_int, print_char ops.

tests/dialects/test_arith.py

@@ -260,7 +260,6 @@ def test_cmpi_incorrect_comparison():
 def test_cmpi_index_type():
     a = Constant.from_int_and_width(1, IndexType())
     b = Constant.from_int_and_width(2, IndexType())
-
     Cmpi(a, b, "eq").verify()
 
 
@@ -280,3 +279,17 @@ def test_extend_truncate_iops():
     assert extu_op.result.type == i64
     assert trunc_op.input == b.result
     assert trunc_op.result.type == i32
+
+
+def test_trunci_incorrect_bitwidth():
+    a = Constant.from_int_and_width(1, 16)
+    # bitwidth of b has to be smaller than the one of a
+    with pytest.raises(VerifyException):
+        _trunci_op = TruncIOp(a, i32).verify()
+
+
+def test_extui_incorrect_bitwidth():
+    a = Constant.from_int_and_width(1, 64)
+    # bitwidth of b has to be larger than the one of a
+    with pytest.raises(VerifyException):
+        _extui_op = ExtUIOp(a, i32).verify()

tests/dialects/test_printf.py

@@ -58,3 +58,13 @@ def test_global_symbol_name_generation():
     s3 = printf_to_llvm._key_from_str(")")  # pyright: ignore[reportPrivateUsage]
 
     assert s2 == s3
+
+
+def test_printchar_non_ascii():
+    with pytest.raises(ValueError):
+        print_dialect.PrintCharOp.from_constant_char("🔥")
+
+
+def test_printchar_no_char():
+    with pytest.raises(ValueError):
+        print_dialect.PrintCharOp.from_constant_char("This should not work")

tests/filecheck/dialects/arith/arith_ops.mlir

@@ -3,6 +3,7 @@
 "builtin.module"() ({
   %lhsi1, %rhsi1 = "test.op"() : () -> (i1, i1)
   %lhsi32, %rhsi32 = "test.op"() : () -> (i32, i32)
+  %lhsi64, %rhsi64 = "test.op"() : () -> (i64, i64)
   %lhsindex, %rhsindex = "test.op"() : () -> (index, index)
   %lhsf32, %rhsf32 = "test.op"() : () -> (f32, f32)
   %lhsf64, %rhsf64 = "test.op"() : () -> (f64, f64)
@@ -136,10 +137,18 @@
 
   // CHECK-NEXT: %extf = "arith.extf"(%lhsf32) : (f32) -> f64
 
+  %extui = "arith.extui"(%lhsi32) : (i32) -> i64
+
+  // CHECK-NEXT: %extui = "arith.extui"(%lhsi32) : (i32) -> i64
+
   %truncf = "arith.truncf"(%lhsf64) : (f64) -> f32
 
   // CHECK-NEXT: %truncf = "arith.truncf"(%lhsf64) : (f64) -> f32
 
+  %trunci = "arith.trunci"(%lhsi64) : (i64) -> i32
+
+  // CHECK-NEXT: %trunci = "arith.trunci"(%lhsi64) : (i64) -> i32
+
   %cmpf = "arith.cmpf"(%lhsf32, %rhsf32) {"predicate" = 2 : i64} : (f32, f32) -> i1
 
   // CHECK-NEXT: %cmpf = "arith.cmpf"(%lhsf32, %rhsf32) {"predicate" = 2 : i64} : (f32, f32) -> i1

tests/filecheck/dialects/print/print_basics.mlir

@@ -5,16 +5,21 @@ builtin.module {
 
     %144 = "test.op"() : () -> i32
     %12 = "test.op"() : () -> i32
+    %byte = "test.op"() : () -> i8
 
     printf.print_format "Uses vals twice {} {} {} {}", %12 : i32, %144 : i32, %12 : i32, %144 : i32
-
     printf.print_format "{}", %144 : i32
     printf.print_format "{}", %144 : i32 {unit}
+    "printf.print_char"(%byte) : (i8) -> ()
+    "printf.print_int"(%12) : (i32) -> ()
 }
 
 // CHECK:       printf.print_format "Hello world!"
 // CHECK-NEXT:  %0 = "test.op"() : () -> i32
 // CHECK-NEXT:  %1 = "test.op"() : () -> i32
+// CHECK-NEXT:  %byte = "test.op"() : () -> i8
 // CHECK-NEXT:  printf.print_format "Uses vals twice {} {} {} {}", %1 : i32, %0 : i32, %1 : i32, %0 : i32
 // CHECK-NEXT:  printf.print_format "{}", %0 : i32
 // CHECK-NEXT:  printf.print_format "{}", %0 : i32 {"unit"}
+// CHECK-NEXT:  "printf.print_char"(%{{.*}}) : (i8) -> ()
+// CHECK-NEXT:  "printf.print_int"(%{{.*}}) : (i32) -> ()

tests/filecheck/mlir-conversion/with-mlir/dialects/print/printf_to_putchar.mlir

@@ -0,0 +1,26 @@
+// RUN: xdsl-opt -p printf-to-putchar %s | mlir-opt --convert-math-to-funcs  --test-lower-to-llvm | mlir-cpu-runner --entry-point-result=void | filecheck %s
+
+builtin.module{
+    "func.func"() ({
+        %n = arith.constant 110 : i8
+        %i = arith.constant 105 : i8
+        %c = arith.constant 99 : i8
+        %e = arith.constant 101 : i8
+        %exclamation = arith.constant 33 : i8
+        %newline = arith.constant 10 : i8
+        %integer = arith.constant -2147483648: i32
+
+	"printf.print_char"(%n) : (i8) -> ()
+	"printf.print_char"(%i) : (i8) -> ()
+	"printf.print_char"(%c) : (i8) -> ()
+	"printf.print_char"(%e) : (i8) -> ()
+	"printf.print_char"(%exclamation) : (i8) -> ()
+	"printf.print_char"(%newline) : (i8) -> ()
+        "printf.print_int"(%integer) : (i32) -> ()
+	"printf.print_char"(%newline) : (i8) -> ()
+	"func.return"() : () -> ()
+    }) {"sym_name" = "main", "function_type" = () -> (), "sym_visibility" = "private"} : () -> ()
+}
+
+// CHECK: nice!
+// CHECK-NEXT: -2147483648

xdsl/dialects/arith.py

@@ -744,6 +744,14 @@ class TruncIOp(IRDLOperation):
     def __init__(self, op: SSAValue | Operation, target_type: IntegerType):
         return super().__init__(operands=[op], result_types=[target_type])
 
+    def verify_(self) -> None:
+        assert isinstance(self.input.type, IntegerType)
+        assert isinstance(self.result.type, IntegerType)
+        if not self.result.type.width.data < self.input.type.width.data:
+            raise VerifyException(
+                "Destination bit-width must be smaller than the input bit-width"
+            )
+
 
 @irdl_op_definition
 class ExtSIOp(IRDLOperation):
@@ -766,6 +774,14 @@ class ExtUIOp(IRDLOperation):
     def __init__(self, op: SSAValue | Operation, target_type: IntegerType):
         return super().__init__(operands=[op], result_types=[target_type])
 
+    def verify_(self) -> None:
+        assert isinstance(self.input.type, IntegerType)
+        assert isinstance(self.result.type, IntegerType)
+        if not self.result.type.width.data > self.input.type.width.data:
+            raise VerifyException(
+                "Destination bit-width must be larger than the input bit-width"
+            )
+
 
 Arith = Dialect(
     [

xdsl/dialects/printf.py

@@ -1,17 +1,21 @@
 from __future__ import annotations
 
-from xdsl.dialects import builtin
+from xdsl.dialects import arith, builtin
 from xdsl.ir import Dialect, Operation, SSAValue, VerifyException
 from xdsl.irdl import (
     IRDLOperation,
+    Operand,
     VarOperand,
     attr_def,
     irdl_op_definition,
+    operand_def,
     var_operand_def,
 )
 from xdsl.parser import Parser
 from xdsl.printer import Printer
 
+i8 = builtin.IntegerType(8)
+
 
 @irdl_op_definition
 class PrintFormatOp(IRDLOperation):
@@ -85,9 +89,54 @@ def parse(cls: type[PrintFormatOp], parser: Parser) -> PrintFormatOp:
         return op
 
 
+@irdl_op_definition
+class PrintCharOp(IRDLOperation):
+    """
+    Print a single character
+
+    Equivalent to putchar in C, but uses signless bytes as input (instead of ui32).
+    Unlike the C implementation, this op does not return anything.
+    """
+
+    name = "printf.print_char"
+    char: Operand = operand_def(i8)
+
+    def __init__(self, char: SSAValue | Operation):
+        super().__init__(
+            operands=[char],
+        )
+
+    @staticmethod
+    def from_constant_char(char: str) -> PrintCharOp:
+        """
+        This constructor returns a PrintCharOp that prints the value supplied
+        in "char" as a python char.
+        """
+        if len(char) != 1:
+            raise ValueError("Only single characters are supported")
+        ascii_value = ord(char)
+        if ascii_value > 128:
+            raise ValueError("Only ascii characters are supported")
+        char_constant = arith.Constant.from_int_and_width(ascii_value, i8)
+        return PrintCharOp(char_constant)
+
+
+@irdl_op_definition
+class PrintIntOp(IRDLOperation):
+    """
+    Print a single Integer
+    """
+
+    name = "printf.print_int"
+    int: Operand = operand_def(builtin.IntegerType)
+
+    def __init__(self, integer: SSAValue | Operation):
+        super().__init__(
+            operands=[integer],
+        )
+
+
 Printf = Dialect(
-    [
-        PrintFormatOp,
-    ],
+    [PrintFormatOp, PrintCharOp, PrintIntOp],
     [],
 )

xdsl/tools/command_line_tool.py

@@ -45,6 +45,7 @@
     lower_snitch_runtime,
     mlir_opt,
     printf_to_llvm,
+    printf_to_putchar,
     reconcile_unrealized_casts,
     riscv_register_allocation,
 )
@@ -105,6 +106,7 @@ def get_all_passes() -> list[type[ModulePass]]:
         lower_snitch_runtime.LowerSnitchRuntimePass,
         mlir_opt.MLIROptPass,
         printf_to_llvm.PrintfToLLVM,
+        printf_to_putchar.PrintfToPutcharPass,
         riscv_register_allocation.RISCVRegisterAllocation,
         RISCVLowerArith,
         LowerFuncToRiscvFunc,