dialects: (riscv) add riscv32 and riscv64 load immediate instruction

docs/Toy/toy/__main__.py

@@ -13,6 +13,7 @@
 from xdsl.interpreters.riscv_func import RiscvFuncFunctions
 from xdsl.interpreters.riscv_libc import RiscvLibcFunctions
 from xdsl.interpreters.riscv_scf import RiscvScfFunctions
+from xdsl.interpreters.rv32 import Rv32Functions
 from xdsl.interpreters.scf import ScfFunctions
 from xdsl.parser import Parser as IRParser
 from xdsl.printer import Printer
@@ -119,6 +120,7 @@ def main(path: Path, emit: str, ir: bool, print_generic: bool):
     ):
         interpreter.register_implementations(ToyAcceleratorInstructionFunctions())
         interpreter.register_implementations(RiscvFuncFunctions())
+        interpreter.register_implementations(Rv32Functions())
         interpreter.register_implementations(RiscvDebugFunctions())
         interpreter.register_implementations(RiscvLibcFunctions())
     if emit in ("riscv", "riscv-opt", "riscv-regalloc", "riscv-regalloc-opt"):

docs/marimo/riscv_dialects.py

@@ -438,23 +438,23 @@ def _(mo):
       %zero = riscv.get_register : !riscv.reg<zero>
       riscv_cf.bge %zero: !riscv.reg<zero>, %num :!riscv.reg<a0>, ^bb4(), ^bb1()
     ^bb1():
-      %a_init = riscv.li 1 : !riscv.reg<a2>
-      %b_init = riscv.li 1 : !riscv.reg<a3>
+      %a_init = rv32.li 1 : !riscv.reg<a2>
+      %b_init = rv32.li 1 : !riscv.reg<a3>
       riscv_cf.branch ^bb2 (%num : !riscv.reg<a0>, %a_init : !riscv.reg<a2>, %b_init : !riscv.reg<a3>)
     ^bb2(%i : !riscv.reg<a0>, %a_in : !riscv.reg<a2>, %b_in : !riscv.reg<a3>):
       riscv.label ".LBB1_2"
-      %sum = riscv.li 2 : !riscv.reg<a4>
-      %i_next = riscv.li 3 : !riscv.reg<a0>
-      %temp = riscv.li 4 : !riscv.reg<a1>
-      %a_next = riscv.li 5 : !riscv.reg<a2>
-      %b_next = riscv.li 6 : !riscv.reg<a3>
+      %sum = rv32.li 2 : !riscv.reg<a4>
+      %i_next = rv32.li 3 : !riscv.reg<a0>
+      %temp = rv32.li 4 : !riscv.reg<a1>
+      %a_next = rv32.li 5 : !riscv.reg<a2>
+      %b_next = rv32.li 6 : !riscv.reg<a3>
       riscv_cf.bne %zero: !riscv.reg<zero>, %i_next : !riscv.reg<a0>, ^bb2(%i_next : !riscv.reg<a0>, %a_next : !riscv.reg<a2>, %b_next : !riscv.reg<a3>), ^bb3()
     ^bb3():
       %res = riscv.mv %temp : (!riscv.reg<a1>) -> !riscv.reg<a0>
       riscv_func.return %num : !riscv.reg<a0>
     ^bb4():
       riscv.label ".LBB1_4"
-      %res_early = riscv.li 1 : !riscv.reg<a0>
+      %res_early = rv32.li 1 : !riscv.reg<a0>
       riscv_func.return %res_early : !riscv.reg<a0>
     }""", language="javascript")
     return (fib_editor,)
@@ -504,8 +504,8 @@ def _():
       %zero = riscv.get_register : !riscv.reg<zero>
       riscv_cf.bge %zero: !riscv.reg<zero>, %num :!riscv.reg<a0>, ^bb4(), ^bb1()
     ^bb1():
-      %a_init = riscv.li 1 : !riscv.reg<a2>
-      %b_init = riscv.li 1 : !riscv.reg<a3>
+      %a_init = rv32.li 1 : !riscv.reg<a2>
+      %b_init = rv32.li 1 : !riscv.reg<a3>
       riscv_cf.branch ^bb2 (%num : !riscv.reg<a0>, %a_init : !riscv.reg<a2>, %b_init : !riscv.reg<a3>)
     ^bb2(%i : !riscv.reg<a0>, %a_in : !riscv.reg<a2>, %b_in : !riscv.reg<a3>):
       riscv.label ".LBB1_2"
@@ -520,7 +520,7 @@ def _():
       riscv_func.return %num : !riscv.reg<a0>
     ^bb4():
       riscv.label ".LBB1_4"
-      %res_early = riscv.li 1 : !riscv.reg<a0>
+      %res_early = rv32.li 1 : !riscv.reg<a0>
       riscv_func.return %res_early : !riscv.reg<a0>
     }
     """

tests/dialects/test_riscv.py

@@ -1,7 +1,7 @@
 import pytest
 
 from xdsl.context import Context
-from xdsl.dialects import riscv
+from xdsl.dialects import riscv, rv32
 from xdsl.dialects.builtin import (
     IntAttr,
     IntegerAttr,
@@ -217,13 +217,13 @@ def test_immediate_pseudo_inst():
 
     # Pseudo-Instruction with custom handling
     with pytest.raises(VerifyException):
-        riscv.LiOp(ub, rd=riscv.Registers.A0)
+        rv32.LiOp(ub, rd=riscv.Registers.A0)
 
     with pytest.raises(VerifyException):
-        riscv.LiOp(lb - 1, rd=riscv.Registers.A0)
+        rv32.LiOp(lb - 1, rd=riscv.Registers.A0)
 
-    riscv.LiOp(ub - 1, rd=riscv.Registers.A0)
-    riscv.LiOp(lb, rd=riscv.Registers.A0)
+    rv32.LiOp(ub - 1, rd=riscv.Registers.A0)
+    rv32.LiOp(lb, rd=riscv.Registers.A0)
 
 
 def test_immediate_shift_inst():
@@ -275,7 +275,7 @@ def test_asm_section():
 
 
 def test_get_constant_value():
-    li_op = riscv.LiOp(1)
+    li_op = rv32.LiOp(1)
     li_val = get_constant_value(li_op.rd)
     assert li_val == IntegerAttr.from_int_and_width(1, 32)
     # LiOp implements ConstantLikeInterface so it also has a get_constant_value method:

tests/filecheck/backend/convert_riscv_scf_to_riscv_cf.mlir

@@ -3,9 +3,9 @@
 
 builtin.module {
     riscv_func.func @copy10(%src : !riscv.reg<a0>, %dst : !riscv.reg<a1>) {
-        %zero = riscv.li 0 : !riscv.reg<a2>
-        %step = riscv.li 4 : !riscv.reg<a3>
-        %forty = riscv.li 40 : !riscv.reg<a4>
+        %zero = rv32.li 0 : !riscv.reg<a2>
+        %step = rv32.li 4 : !riscv.reg<a3>
+        %forty = rv32.li 40 : !riscv.reg<a4>
         riscv_scf.for %offset : !riscv.reg<a5> = %zero to %forty step %step {
             %srcptr = riscv.add %src, %offset : (!riscv.reg<a0>, !riscv.reg<a5>) -> !riscv.reg<a6>
             %dstptr = riscv.add %dst, %offset : (!riscv.reg<a1>, !riscv.reg<a5>) -> !riscv.reg<a7>
@@ -19,9 +19,9 @@ builtin.module {
 
 // CHECK:       builtin.module {
 // CHECK-NEXT:    riscv_func.func @copy10(%src : !riscv.reg<a0>, %dst : !riscv.reg<a1>) {
-// CHECK-NEXT:      %zero = riscv.li 0 : !riscv.reg<a2>
-// CHECK-NEXT:      %step = riscv.li 4 : !riscv.reg<a3>
-// CHECK-NEXT:      %forty = riscv.li 40 : !riscv.reg<a4>
+// CHECK-NEXT:      %zero = rv32.li 0 : !riscv.reg<a2>
+// CHECK-NEXT:      %step = rv32.li 4 : !riscv.reg<a3>
+// CHECK-NEXT:      %forty = rv32.li 40 : !riscv.reg<a4>
 // CHECK-NEXT:      %0 = riscv.mv %zero : (!riscv.reg<a2>) -> !riscv.reg<a5>
 // CHECK-NEXT:      riscv_cf.bge %0 : !riscv.reg<a5>, %forty : !riscv.reg<a4>, ^bb0(%0 : !riscv.reg<a5>), ^bb1(%0 : !riscv.reg<a5>)
 // CHECK-NEXT:    ^bb1(%offset : !riscv.reg<a5>):
@@ -45,8 +45,8 @@ builtin.module {
 
 builtin.module {
     riscv_func.func @sum_range(%0 : !riscv.reg<a0>, %1 : !riscv.reg<a1>) {
-        %2 = riscv.li 1 : !riscv.reg<a2>
-        %3 = riscv.li 0 : !riscv.reg<a3>
+        %2 = rv32.li 1 : !riscv.reg<a2>
+        %3 = rv32.li 0 : !riscv.reg<a3>
         %4 = riscv_scf.for %5 : !riscv.reg<a4> = %0 to %1 step %2 iter_args(%6 = %3) -> (!riscv.reg<a3>) {
             %7 = riscv.add %5, %6 : (!riscv.reg<a4>, !riscv.reg<a3>) -> !riscv.reg<a3>
             riscv_scf.yield %7 : !riscv.reg<a3>
@@ -58,8 +58,8 @@ builtin.module {
 
 // CHECK:       builtin.module {
 // CHECK-NEXT:    riscv_func.func @sum_range(%0 : !riscv.reg<a0>, %1 : !riscv.reg<a1>) {
-// CHECK-NEXT:      %2 = riscv.li 1 : !riscv.reg<a2>
-// CHECK-NEXT:      %3 = riscv.li 0 : !riscv.reg<a3>
+// CHECK-NEXT:      %2 = rv32.li 1 : !riscv.reg<a2>
+// CHECK-NEXT:      %3 = rv32.li 0 : !riscv.reg<a3>
 // CHECK-NEXT:      %4 = riscv.mv %0 : (!riscv.reg<a0>) -> !riscv.reg<a4>
 // CHECK-NEXT:      riscv_cf.bge %4 : !riscv.reg<a4>, %1 : !riscv.reg<a1>, ^bb0(%4 : !riscv.reg<a4>, %3 : !riscv.reg<a3>), ^bb1(%4 : !riscv.reg<a4>, %3 : !riscv.reg<a3>)
 // CHECK-NEXT:    ^bb1(%5 : !riscv.reg<a4>, %6 : !riscv.reg<a3>):
@@ -78,12 +78,12 @@ builtin.module {
 
 builtin.module {
     riscv_func.func @nested(%arg0 : !riscv.reg<a0>) {
-        %0 = riscv.li 0 : !riscv.reg<a1>
-        %1 = riscv.li 0 : !riscv.reg<a2>
-        %2 = riscv.li 1 : !riscv.reg<a3>
+        %0 = rv32.li 0 : !riscv.reg<a1>
+        %1 = rv32.li 0 : !riscv.reg<a2>
+        %2 = rv32.li 1 : !riscv.reg<a3>
         %3 = riscv_scf.for %arg1 : !riscv.reg<a2> = %1 to %arg0 step %2 iter_args(%arg2 = %0) -> (!riscv.reg<a1>) {
-            %4 = riscv.li 0 : !riscv.reg<a4>
-            %5 = riscv.li 1 : !riscv.reg<a5>
+            %4 = rv32.li 0 : !riscv.reg<a4>
+            %5 = rv32.li 1 : !riscv.reg<a5>
             %6 = riscv_scf.for %arg3 : !riscv.reg<a4> = %4 to %arg0 step %5 iter_args(%arg4 = %arg2) -> (!riscv.reg<a1>) {
                 %7 = riscv.add %arg1, %arg3 : (!riscv.reg<a2>, !riscv.reg<a4>) -> !riscv.reg<a0>
                 %8 = riscv.add %arg4, %7 : (!riscv.reg<a1>, !riscv.reg<a0>) -> !riscv.reg<a1>
@@ -97,15 +97,15 @@ builtin.module {
 
 // CHECK:       builtin.module {
 // CHECK-NEXT:    riscv_func.func @nested(%arg0 : !riscv.reg<a0>) {
-// CHECK-NEXT:      %0 = riscv.li 0 : !riscv.reg<a1>
-// CHECK-NEXT:      %1 = riscv.li 0 : !riscv.reg<a2>
-// CHECK-NEXT:      %2 = riscv.li 1 : !riscv.reg<a3>
+// CHECK-NEXT:      %0 = rv32.li 0 : !riscv.reg<a1>
+// CHECK-NEXT:      %1 = rv32.li 0 : !riscv.reg<a2>
+// CHECK-NEXT:      %2 = rv32.li 1 : !riscv.reg<a3>
 // CHECK-NEXT:      %3 = riscv.mv %1 : (!riscv.reg<a2>) -> !riscv.reg<a2>
 // CHECK-NEXT:      riscv_cf.bge %3 : !riscv.reg<a2>, %arg0 : !riscv.reg<a0>, ^bb0(%3 : !riscv.reg<a2>, %0 : !riscv.reg<a1>), ^bb1(%3 : !riscv.reg<a2>, %0 : !riscv.reg<a1>)
 // CHECK-NEXT:    ^bb1(%arg1 : !riscv.reg<a2>, %arg2 : !riscv.reg<a1>):
 // CHECK-NEXT:      riscv.label "scf_body_1_for"
-// CHECK-NEXT:      %4 = riscv.li 0 : !riscv.reg<a4>
-// CHECK-NEXT:      %5 = riscv.li 1 : !riscv.reg<a5>
+// CHECK-NEXT:      %4 = rv32.li 0 : !riscv.reg<a4>
+// CHECK-NEXT:      %5 = rv32.li 1 : !riscv.reg<a5>
 // CHECK-NEXT:      %6 = riscv.mv %4 : (!riscv.reg<a4>) -> !riscv.reg<a4>
 // CHECK-NEXT:      riscv_cf.bge %6 : !riscv.reg<a4>, %arg0 : !riscv.reg<a0>, ^bb2(%6 : !riscv.reg<a4>, %arg2 : !riscv.reg<a1>), ^bb3(%6 : !riscv.reg<a4>, %arg2 : !riscv.reg<a1>)
 // CHECK-NEXT:    ^bb3(%arg3 : !riscv.reg<a4>, %arg4 : !riscv.reg<a1>):

tests/filecheck/backend/convert_riscv_scf_to_riscv_cf_with_regalloc.mlir

@@ -2,8 +2,8 @@
 
 builtin.module {
     riscv_func.func @sum_range(%0 : !riscv.reg<a0>, %1 : !riscv.reg<a1>) {
-        %2 = riscv.li 1 : !riscv.reg
-        %3 = riscv.li 0 : !riscv.reg
+        %2 = rv32.li 1 : !riscv.reg
+        %3 = rv32.li 0 : !riscv.reg
         %arg = riscv.mv %3 : (!riscv.reg) -> !riscv.reg
         %4 = riscv_scf.for %5 : !riscv.reg = %0 to %1 step %2 iter_args(%6 = %arg) -> (!riscv.reg) {
             %7 = riscv.add %5, %6 : (!riscv.reg, !riscv.reg) -> !riscv.reg
@@ -16,8 +16,8 @@ builtin.module {
 
 // CHECK:        builtin.module {
 // CHECK-NEXT:    riscv_func.func @sum_range(%0 : !riscv.reg<a0>, %1 : !riscv.reg<a1>) {
-// CHECK-NEXT:      %2 = riscv.li 1 : !riscv.reg<t2>
-// CHECK-NEXT:      %3 = riscv.li 0 : !riscv.reg<zero>
+// CHECK-NEXT:      %2 = rv32.li 1 : !riscv.reg<t2>
+// CHECK-NEXT:      %3 = rv32.li 0 : !riscv.reg<zero>
 // CHECK-NEXT:      %arg = riscv.mv %3 : (!riscv.reg<zero>) -> !riscv.reg<t0>
 // CHECK-NEXT:      %4 = riscv.mv %0 : (!riscv.reg<a0>) -> !riscv.reg<t1>
 // CHECK-NEXT:      riscv_cf.bge %4 : !riscv.reg<t1>, %1 : !riscv.reg<a1>, ^bb0(%4 : !riscv.reg<t1>, %arg : !riscv.reg<t0>), ^bb1(%4 : !riscv.reg<t1>, %arg : !riscv.reg<t0>)

tests/filecheck/backend/riscv/canonicalize.mlir

@@ -7,7 +7,7 @@ builtin.module {
   %o2 = riscv.mv %i2 : (!riscv.reg) -> !riscv.reg
   "test.op"(%o0, %o1, %o2) : (!riscv.reg<a0>, !riscv.reg<a2>, !riscv.reg) -> ()
 
-  %i3 = riscv.li 100 : !riscv.reg
+  %i3 = rv32.li 100 : !riscv.reg
   %i4 = riscv.mv %i3 : (!riscv.reg) -> !riscv.reg
   %i5 = riscv.mv %i3 : (!riscv.reg) -> !riscv.reg<j_0>
   "test.op"(%i3, %i4, %i5) : (!riscv.reg, !riscv.reg, !riscv.reg<j_0>) -> ()
@@ -22,15 +22,15 @@ builtin.module {
   "test.op"(%fo0, %fo1, %fo2, %fo3, %fo4, %fo5) : (!riscv.freg<fa0>, !riscv.freg<fa2>, !riscv.freg, !riscv.freg<fa0>, !riscv.freg<fa2>, !riscv.freg) -> ()
 
   %zero = riscv.get_register : !riscv.reg<zero>
-  %c0 = riscv.li 0 : !riscv.reg
-  %c1 = riscv.li 1 : !riscv.reg
-  %c2 = riscv.li 2 : !riscv.reg
-  %c3 = riscv.li 3 : !riscv.reg
+  %c0 = rv32.li 0 : !riscv.reg
+  %c1 = rv32.li 1 : !riscv.reg
+  %c2 = rv32.li 2 : !riscv.reg
+  %c3 = rv32.li 3 : !riscv.reg
 
   // Don't optimise out unused immediates
   "test.op"(%zero, %c0, %c1, %c2, %c3) : (!riscv.reg<zero>, !riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg) -> ()
 
-  %load_zero_zero = riscv.li 0 : !riscv.reg<zero>
+  %load_zero_zero = rv32.li 0 : !riscv.reg<zero>
   "test.op"(%load_zero_zero) : (!riscv.reg<zero>) -> ()
 
   %add_immediate_zero_reg = riscv.addi %zero, 1 : (!riscv.reg<zero>) -> !riscv.reg<a0>
@@ -170,7 +170,7 @@ builtin.module {
 // CHECK-NEXT:   %{{.*}} = riscv.mv %{{.*}} : (!riscv.reg) -> !riscv.reg
 // CHECK-NEXT:   "test.op"(%i0, %o1, %o2) : (!riscv.reg<a0>, !riscv.reg<a2>, !riscv.reg) -> ()
 
-// CHECK-NEXT:   %i3 = riscv.li 100 : !riscv.reg
+// CHECK-NEXT:   %i3 = rv32.li 100 : !riscv.reg
 // CHECK-NEXT:   %i4 = riscv.mv %i3 : (!riscv.reg) -> !riscv.reg
 // CHECK-NEXT:   %i5 = riscv.mv %i3 : (!riscv.reg) -> !riscv.reg<j_0>
 // CHECK-NEXT:   "test.op"(%i3, %i4, %i5) : (!riscv.reg, !riscv.reg, !riscv.reg<j_0>) -> ()
@@ -185,18 +185,18 @@ builtin.module {
 // CHECK-NEXT:   %zero = riscv.get_register : !riscv.reg<zero>
 // CHECK-NEXT:   %c0 = riscv.get_register : !riscv.reg<zero>
 // CHECK-NEXT:   %c0_1 = riscv.mv %c0 : (!riscv.reg<zero>) -> !riscv.reg
-// CHECK-NEXT:   %c1 = riscv.li 1 : !riscv.reg
-// CHECK-NEXT:   %c2 = riscv.li 2 : !riscv.reg
-// CHECK-NEXT:   %c3 = riscv.li 3 : !riscv.reg
+// CHECK-NEXT:   %c1 = rv32.li 1 : !riscv.reg
+// CHECK-NEXT:   %c2 = rv32.li 2 : !riscv.reg
+// CHECK-NEXT:   %c3 = rv32.li 3 : !riscv.reg
 // CHECK-NEXT:   "test.op"(%zero, %c0_1, %c1, %c2, %c3) : (!riscv.reg<zero>, !riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg) -> ()
 
 // CHECK-NEXT:   %load_zero_zero = riscv.get_register : !riscv.reg<zero>
 // CHECK-NEXT:   "test.op"(%load_zero_zero) : (!riscv.reg<zero>) -> ()
 
-// CHECK-NEXT:   %add_immediate_zero_reg = riscv.li 1 : !riscv.reg<a0>
+// CHECK-NEXT:   %add_immediate_zero_reg = rv32.li 1 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%add_immediate_zero_reg) : (!riscv.reg<a0>) -> ()
 
-// CHECK-NEXT:   %multiply_immediates = riscv.li 6 : !riscv.reg<a0>
+// CHECK-NEXT:   %multiply_immediates = rv32.li 6 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%multiply_immediates) : (!riscv.reg<a0>) -> ()
 
 // CHECK-NEXT:   %multiply_immediate_r0 = riscv.mv %c0_1 : (!riscv.reg) -> !riscv.reg<a0>
@@ -220,7 +220,7 @@ builtin.module {
 // CHECK-NEXT:   %add_rhs_immediate = riscv.addi %i2, 2 : (!riscv.reg) -> !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%add_rhs_immediate) : (!riscv.reg<a0>) -> ()
 
-// CHECK-NEXT:   %add_immediates = riscv.li 5 : !riscv.reg<a0>
+// CHECK-NEXT:   %add_immediates = rv32.li 5 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%add_immediates) : (!riscv.reg<a0>) -> ()
 
 // CHECK-NEXT:   %add_vars = riscv.add %i0, %i1 : (!riscv.reg<a0>, !riscv.reg<a1>) -> !riscv.reg<a0>
@@ -229,7 +229,7 @@ builtin.module {
 // CHECK-NEXT:   %add_immediate_zero = riscv.mv %i2 : (!riscv.reg) -> !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%add_immediate_zero) : (!riscv.reg<a0>) -> ()
 
-// CHECK-NEXT:   %add_immediate_constant = riscv.li 3 : !riscv.reg<a0>
+// CHECK-NEXT:   %add_immediate_constant = rv32.li 3 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%add_immediate_constant) : (!riscv.reg<a0>) -> ()
 
   // Unchanged
@@ -240,7 +240,7 @@ builtin.module {
 // CHECK-NEXT:   %sub_rhs_immediate = riscv.addi %i2, -2 : (!riscv.reg) -> !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%sub_rhs_immediate) : (!riscv.reg<a0>) -> ()
 
-// CHECK-NEXT:   %sub_immediates = riscv.li -1 : !riscv.reg<a0>
+// CHECK-NEXT:   %sub_immediates = rv32.li -1 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%sub_immediates) : (!riscv.reg<a0>) -> ()
 
 // CHECK-NEXT:   %sub_lhs_rhs = riscv.get_register : !riscv.reg<zero>
@@ -252,16 +252,16 @@ builtin.module {
 // CHECK-NEXT:   "test.op"(%add_vars) : (!riscv.reg<a0>) -> ()
 
 // Optimise out an arithmetic operation
-// CHECK-NEXT:   %sub_add_immediate = riscv.li 2 : !riscv.reg<a0>
+// CHECK-NEXT:   %sub_add_immediate = rv32.li 2 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%sub_add_immediate) : (!riscv.reg<a0>) -> ()
 
-// CHECK-NEXT:   %andi_immediate = riscv.li 4 : !riscv.reg<a0>
+// CHECK-NEXT:   %andi_immediate = rv32.li 4 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%andi_immediate) : (!riscv.reg<a0>) -> ()
 
-// CHECK-NEXT:   %shift_left_immediate = riscv.li 32 : !riscv.reg<a0>
+// CHECK-NEXT:   %shift_left_immediate = rv32.li 32 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%shift_left_immediate) : (!riscv.reg<a0>) -> ()
 
-// CHECK-NEXT:   %shift_right_immediate = riscv.li 4 : !riscv.reg<a0>
+// CHECK-NEXT:   %shift_right_immediate = rv32.li 4 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%shift_right_immediate) : (!riscv.reg<a0>) -> ()
 
 // CHECK-NEXT:   %load_float_known_offset = riscv.flw %i2, 12 : (!riscv.reg) -> !riscv.freg<fa0>
@@ -274,7 +274,7 @@ builtin.module {
 
 // CHECK-NEXT:   riscv.fsd %i2, %f2, 12 : (!riscv.reg, !riscv.freg) -> ()
 
-// CHECK-NEXT:   %add_lhs_rhs = riscv.li 2 : !riscv.reg
+// CHECK-NEXT:   %add_lhs_rhs = rv32.li 2 : !riscv.reg
 // CHECK-NEXT:   %add_lhs_rhs_1 = riscv.mul %i1, %add_lhs_rhs : (!riscv.reg<a1>, !riscv.reg) -> !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%add_lhs_rhs_1) : (!riscv.reg<a0>) -> ()
 
@@ -306,10 +306,10 @@ builtin.module {
 // CHECK-NEXT:   %xor_bitwise_zero_r0 = riscv.mv %c1 : (!riscv.reg) -> !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%xor_bitwise_zero_r0) : (!riscv.reg<a0>) -> ()
 
-// CHECK-NEXT:   %ori_immediate = riscv.li 103 : !riscv.reg<a0>
+// CHECK-NEXT:   %ori_immediate = rv32.li 103 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%ori_immediate) : (!riscv.reg<a0>) -> ()
 
-// CHECK-NEXT:   %xori_immediate = riscv.li 99 : !riscv.reg<a0>
+// CHECK-NEXT:   %xori_immediate = rv32.li 99 : !riscv.reg<a0>
 // CHECK-NEXT:   "test.op"(%xori_immediate) : (!riscv.reg<a0>) -> ()
 
 // CHECK-NEXT:   %shift_left_zero_r0 = riscv.mv %i2 : (!riscv.reg) -> !riscv.reg<a0>