From d20c8d857bd8b6761b8bc071bce3eb39070e1060 Mon Sep 17 00:00:00 2001 From: osmanyasar05 Date: Thu, 12 Feb 2026 14:10:34 +0000 Subject: [PATCH 1/9] add folding patterns --- xdsl/dialects/riscv/abstract_ops.py | 14 ++++++++++++++ xdsl/dialects/riscv/ops.py | 12 ++++++++++++ 2 files changed, 26 insertions(+) diff --git a/xdsl/dialects/riscv/abstract_ops.py b/xdsl/dialects/riscv/abstract_ops.py index c63ff7f45c..41ae23d11a 100644 --- a/xdsl/dialects/riscv/abstract_ops.py +++ b/xdsl/dialects/riscv/abstract_ops.py @@ -15,6 +15,7 @@ ) from xdsl.backend.register_type import RegisterAllocatedMemoryEffect, RegisterType from xdsl.dialects.builtin import ( + I32, IntegerAttr, IntegerType, ModuleOp, @@ -788,6 +789,19 @@ def custom_print_attributes(self, printer: Printer) -> AbstractSet[str]: print_immediate_value(printer, self.immediate) return {"immediate"} + @staticmethod + def py_operation( + arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] + ) -> IntegerAttr[I32] | None: + """ + Performs a python function corresponding to this operation. + + If `i := py_operation(arg0, arg1)` is an IntegerAttr[I32], then this operation can be + canonicalized to a constant with value `i` when the inputs are constants + with values `arg0` and `arg1`. + """ + return None + class RdRsImmBitManipOperation(RISCVCustomFormatOperation, RISCVInstruction, ABC): """ diff --git a/xdsl/dialects/riscv/ops.py b/xdsl/dialects/riscv/ops.py index 392f5cccdc..c86c1a7db9 100644 --- a/xdsl/dialects/riscv/ops.py +++ b/xdsl/dialects/riscv/ops.py @@ -260,6 +260,12 @@ class SlliOp(RdRsImmShiftOperation): traits = traits_def(SlliOpHasCanonicalizationPatternsTrait()) + @staticmethod + def py_operation( + arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] + ) -> IntegerAttr[I32] | None: + return IntegerAttr(arg0.value.data << arg1.value.data, i32) + class SrliOpHasCanonicalizationPatternsTrait(HasCanonicalizationPatternsTrait): @classmethod @@ -286,6 +292,12 @@ class SrliOp(RdRsImmShiftOperation): traits = traits_def(SrliOpHasCanonicalizationPatternsTrait()) + @staticmethod + def py_operation( + arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] + ) -> IntegerAttr[I32] | None: + return IntegerAttr(arg0.value.data >> arg1.value.data, i32) + @irdl_op_definition class SraiOp(RdRsImmShiftOperation): From c68cf7a21836cc47a7a2cb8b318356cc0fc02e54 Mon Sep 17 00:00:00 2001 From: osmanyasar05 Date: Thu, 12 Feb 2026 15:41:45 +0000 Subject: [PATCH 2/9] add constant folding pattern --- xdsl/dialects/riscv/abstract_ops.py | 14 +++-- xdsl/dialects/riscv/ops.py | 34 ++---------- .../canonicalization_patterns/riscv.py | 53 ++++++++++--------- 3 files changed, 40 insertions(+), 61 deletions(-) diff --git a/xdsl/dialects/riscv/abstract_ops.py b/xdsl/dialects/riscv/abstract_ops.py index 41ae23d11a..9a67b862e9 100644 --- a/xdsl/dialects/riscv/abstract_ops.py +++ b/xdsl/dialects/riscv/abstract_ops.py @@ -727,9 +727,10 @@ class ImmShiftOpHasCanonicalizationPatternsTrait(HasCanonicalizationPatternsTrai def get_canonicalization_patterns(cls) -> tuple[RewritePattern, ...]: from xdsl.transforms.canonicalization_patterns.riscv import ( ShiftbyZero, + ShiftConstantFolding, ) - return (ShiftbyZero(),) + return (ShiftbyZero(), ShiftConstantFolding()) class RdRsImmShiftOperation(RISCVCustomFormatOperation, RISCVInstruction, ABC): @@ -789,10 +790,10 @@ def custom_print_attributes(self, printer: Printer) -> AbstractSet[str]: print_immediate_value(printer, self.immediate) return {"immediate"} - @staticmethod + @abstractmethod def py_operation( - arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] - ) -> IntegerAttr[I32] | None: + self, arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] + ) -> IntegerAttr[I32]: """ Performs a python function corresponding to this operation. @@ -800,7 +801,10 @@ def py_operation( canonicalized to a constant with value `i` when the inputs are constants with values `arg0` and `arg1`. """ - return None + + raise NotImplementedError( + "RdRsImmShiftOperation py_operation is not yet implemented" + ) class RdRsImmBitManipOperation(RISCVCustomFormatOperation, RISCVInstruction, ABC): diff --git a/xdsl/dialects/riscv/ops.py b/xdsl/dialects/riscv/ops.py index c86c1a7db9..e76ebd5dc5 100644 --- a/xdsl/dialects/riscv/ops.py +++ b/xdsl/dialects/riscv/ops.py @@ -235,16 +235,6 @@ class XoriOp(RdRsImmIntegerOperation): traits = traits_def(XoriOpHasCanonicalizationPatternsTrait()) -class SlliOpHasCanonicalizationPatternsTrait(HasCanonicalizationPatternsTrait): - @classmethod - def get_canonicalization_patterns(cls) -> tuple[RewritePattern, ...]: - from xdsl.transforms.canonicalization_patterns.riscv import ( - ShiftLeftImmediate, - ) - - return (ShiftLeftImmediate(),) - - @irdl_op_definition class SlliOp(RdRsImmShiftOperation): """ @@ -258,25 +248,12 @@ class SlliOp(RdRsImmShiftOperation): name = "riscv.slli" - traits = traits_def(SlliOpHasCanonicalizationPatternsTrait()) - - @staticmethod def py_operation( - arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] - ) -> IntegerAttr[I32] | None: + self, arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] + ) -> IntegerAttr[I32]: return IntegerAttr(arg0.value.data << arg1.value.data, i32) -class SrliOpHasCanonicalizationPatternsTrait(HasCanonicalizationPatternsTrait): - @classmethod - def get_canonicalization_patterns(cls) -> tuple[RewritePattern, ...]: - from xdsl.transforms.canonicalization_patterns.riscv import ( - ShiftRightImmediate, - ) - - return (ShiftRightImmediate(),) - - @irdl_op_definition class SrliOp(RdRsImmShiftOperation): """ @@ -290,12 +267,9 @@ class SrliOp(RdRsImmShiftOperation): name = "riscv.srli" - traits = traits_def(SrliOpHasCanonicalizationPatternsTrait()) - - @staticmethod def py_operation( - arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] - ) -> IntegerAttr[I32] | None: + self, arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] + ) -> IntegerAttr[I32]: return IntegerAttr(arg0.value.data >> arg1.value.data, i32) diff --git a/xdsl/transforms/canonicalization_patterns/riscv.py b/xdsl/transforms/canonicalization_patterns/riscv.py index 0ddd9f47a2..4dfa6dd1d4 100644 --- a/xdsl/transforms/canonicalization_patterns/riscv.py +++ b/xdsl/transforms/canonicalization_patterns/riscv.py @@ -287,32 +287,6 @@ def match_and_rewrite(self, op: riscv.XoriOp, rewriter: PatternRewriter) -> None ) -class ShiftLeftImmediate(RewritePattern): - @op_type_rewrite_pattern - def match_and_rewrite(self, op: riscv.SlliOp, rewriter: PatternRewriter) -> None: - if (rs1 := get_constant_value(op.rs1)) is not None and isinstance( - op.immediate, IntegerAttr - ): - rd = op.rd.type - rewriter.replace_op( - op, - rv32.LiOp(rs1.value.data << op.immediate.value.data, rd=rd), - ) - - -class ShiftRightImmediate(RewritePattern): - @op_type_rewrite_pattern - def match_and_rewrite(self, op: riscv.SrliOp, rewriter: PatternRewriter) -> None: - if (rs1 := get_constant_value(op.rs1)) is not None and isinstance( - op.immediate, IntegerAttr - ): - rd = op.rd.type - rewriter.replace_op( - op, - rv32.LiOp(rs1.value.data >> op.immediate.value.data, rd=rd), - ) - - class ShiftbyZero(RewritePattern): """ shift(x, 0) -> x @@ -327,6 +301,33 @@ def match_and_rewrite( rewriter.replace_op(op, riscv.MVOp(op.rs1, rd=op.rd.type)) +class ShiftConstantFolding(RewritePattern): + """ + shift(c1, c2) -> c3 + """ + + @op_type_rewrite_pattern + def match_and_rewrite( + self, op: riscv.SlliOp | riscv.SrliOp | riscv.SraiOp, rewriter: PatternRewriter + ) -> None: + if (rs1 := get_constant_value(op.rs1)) is not None and isinstance( + op.immediate, IntegerAttr + ): + val = rs1.value.data + shamt = op.immediate.value.data + rd = op.rd.type + + if isinstance(op, riscv.SlliOp): + result = val << shamt + elif isinstance(op, riscv.SrliOp): + result = (val % 0x100000000) >> shamt + else: + # if SraiOp + result = val >> shamt + + rewriter.replace_op(op, rv32.LiOp(result, rd=rd)) + + class LoadWordWithKnownOffset(RewritePattern): @op_type_rewrite_pattern def match_and_rewrite(self, op: riscv.LwOp, rewriter: PatternRewriter) -> None: From b061645e511621d18d850db0a82d091ded50f01c Mon Sep 17 00:00:00 2001 From: osmanyasar05 Date: Thu, 12 Feb 2026 16:02:40 +0000 Subject: [PATCH 3/9] add signed tests --- .../filecheck/backend/riscv/canonicalize.mlir | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/tests/filecheck/backend/riscv/canonicalize.mlir b/tests/filecheck/backend/riscv/canonicalize.mlir index 3fb51213e2..292563aa0f 100644 --- a/tests/filecheck/backend/riscv/canonicalize.mlir +++ b/tests/filecheck/backend/riscv/canonicalize.mlir @@ -26,9 +26,10 @@ builtin.module { %c1 = rv32.li 1 : !riscv.reg %c2 = rv32.li 2 : !riscv.reg %c3 = rv32.li 3 : !riscv.reg + %c_neg1 = rv32.li -1 : !riscv.reg // Don't optimise out unused immediates - "test.op"(%zero, %c0, %c1, %c2, %c3) : (!riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg) -> () + "test.op"(%zero, %c0, %c1, %c2, %c3, %c_neg1) : (!riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg) -> () %load_zero_zero = rv32.li 0 : !riscv.reg "test.op"(%load_zero_zero) : (!riscv.reg) -> () @@ -103,6 +104,13 @@ builtin.module { %shift_right_immediate = riscv.srli %shift_left_immediate, 3 : (!riscv.reg) -> !riscv.reg "test.op"(%shift_right_immediate) : (!riscv.reg) -> () + // Check shifts with signed numbers + %srli_neg = riscv.srli %c_neg1, 1 : (!riscv.reg) -> !riscv.reg + "test.op"(%srli_neg) : (!riscv.reg) -> () + + %srai_neg = riscv.srai %c_neg1, 1 : (!riscv.reg) -> !riscv.reg + "test.op"(%srai_neg) : (!riscv.reg) -> () + %load_float_ptr = riscv.addi %i2, 8 : (!riscv.reg) -> !riscv.reg %load_float_known_offset = riscv.flw %load_float_ptr, 4 : (!riscv.reg) -> !riscv.freg "test.op"(%load_float_known_offset) : (!riscv.freg) -> () @@ -201,7 +209,8 @@ builtin.module { // 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, !riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg) -> () +// CHECK-NEXT: %c_neg1 = rv32.li -1 : !riscv.reg +// CHECK-NEXT: "test.op"(%zero, %c0_1, %c1, %c2, %c3, %c_neg1) : (!riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg, !riscv.reg) -> () // CHECK-NEXT: %load_zero_zero = riscv.get_register : !riscv.reg // CHECK-NEXT: "test.op"(%load_zero_zero) : (!riscv.reg) -> () @@ -277,6 +286,12 @@ builtin.module { // CHECK-NEXT: %shift_right_immediate = rv32.li 4 : !riscv.reg // CHECK-NEXT: "test.op"(%shift_right_immediate) : (!riscv.reg) -> () +// CHECK-NEXT: %srli_neg = rv32.li 2147483647 : !riscv.reg +// CHECK-NEXT: "test.op"(%srli_neg) : (!riscv.reg) -> () + +// CHECK-NEXT: %srai_neg = rv32.li -1 : !riscv.reg +// CHECK-NEXT: "test.op"(%srai_neg) : (!riscv.reg) -> () + // CHECK-NEXT: %load_float_known_offset = riscv.flw %i2, 12 : (!riscv.reg) -> !riscv.freg // CHECK-NEXT: "test.op"(%load_float_known_offset) : (!riscv.freg) -> () From e0e78abef2bcdbf4af70fc7aa92cab09d420d7c0 Mon Sep 17 00:00:00 2001 From: osmanyasar05 Date: Thu, 12 Feb 2026 16:31:15 +0000 Subject: [PATCH 4/9] add folder for srai --- xdsl/dialects/riscv/ops.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/xdsl/dialects/riscv/ops.py b/xdsl/dialects/riscv/ops.py index e76ebd5dc5..d72a316e37 100644 --- a/xdsl/dialects/riscv/ops.py +++ b/xdsl/dialects/riscv/ops.py @@ -270,7 +270,7 @@ class SrliOp(RdRsImmShiftOperation): def py_operation( self, arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] ) -> IntegerAttr[I32]: - return IntegerAttr(arg0.value.data >> arg1.value.data, i32) + return IntegerAttr((arg0.value.data % 0x100000000) >> arg1.value.data, i32) @irdl_op_definition @@ -286,6 +286,11 @@ class SraiOp(RdRsImmShiftOperation): name = "riscv.srai" + def py_operation( + self, arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] + ) -> IntegerAttr[I32]: + return IntegerAttr(arg0.value.data >> arg1.value.data, i32) + @irdl_op_definition class AddiwOp(RdRsImmIntegerOperation): From 47bdcf735d67aecaf51b6b5e9f8e128cee186aed Mon Sep 17 00:00:00 2001 From: osmanyasar05 Date: Fri, 13 Feb 2026 16:27:01 +0000 Subject: [PATCH 5/9] use py_op --- xdsl/dialects/riscv/__init__.py | 3 +++ .../canonicalization_patterns/riscv.py | 18 +++++------------- 2 files changed, 8 insertions(+), 13 deletions(-) diff --git a/xdsl/dialects/riscv/__init__.py b/xdsl/dialects/riscv/__init__.py index 69b08a7948..d7af0618da 100644 --- a/xdsl/dialects/riscv/__init__.py +++ b/xdsl/dialects/riscv/__init__.py @@ -12,6 +12,9 @@ from .abstract_ops import ( AssemblyInstructionArg as AssemblyInstructionArg, ) +from .abstract_ops import ( + RdRsImmShiftOperation as RdRsImmShiftOperation, +) from .abstract_ops import ( RdRsRsFloatOperationWithFastMath as RdRsRsFloatOperationWithFastMath, ) diff --git a/xdsl/transforms/canonicalization_patterns/riscv.py b/xdsl/transforms/canonicalization_patterns/riscv.py index 4dfa6dd1d4..dea7fdd560 100644 --- a/xdsl/transforms/canonicalization_patterns/riscv.py +++ b/xdsl/transforms/canonicalization_patterns/riscv.py @@ -294,7 +294,7 @@ class ShiftbyZero(RewritePattern): @op_type_rewrite_pattern def match_and_rewrite( - self, op: riscv.SlliOp | riscv.SrliOp | riscv.SraiOp, rewriter: PatternRewriter + self, op: riscv.RdRsImmShiftOperation, rewriter: PatternRewriter ) -> None: # check if the shift amount is zero if isinstance(op.immediate, IntegerAttr) and op.immediate.value.data == 0: @@ -308,23 +308,15 @@ class ShiftConstantFolding(RewritePattern): @op_type_rewrite_pattern def match_and_rewrite( - self, op: riscv.SlliOp | riscv.SrliOp | riscv.SraiOp, rewriter: PatternRewriter + self, op: riscv.RdRsImmShiftOperation, rewriter: PatternRewriter ) -> None: if (rs1 := get_constant_value(op.rs1)) is not None and isinstance( op.immediate, IntegerAttr ): - val = rs1.value.data - shamt = op.immediate.value.data rd = op.rd.type - - if isinstance(op, riscv.SlliOp): - result = val << shamt - elif isinstance(op, riscv.SrliOp): - result = (val % 0x100000000) >> shamt - else: - # if SraiOp - result = val >> shamt - + val = cast(IntegerAttr[I32], rs1) + shamt = cast(IntegerAttr[I32], op.immediate) + result = op.py_operation(val, shamt) rewriter.replace_op(op, rv32.LiOp(result, rd=rd)) From 3075de60c89543d78c4ce82e7213c8adbadf4fa2 Mon Sep 17 00:00:00 2001 From: osmanyasar05 Date: Sun, 15 Feb 2026 00:15:15 +0000 Subject: [PATCH 6/9] add slli test, modify py_op --- .../filecheck/backend/riscv/canonicalize.mlir | 6 +++++ xdsl/dialects/riscv/abstract_ops.py | 8 +++---- xdsl/dialects/riscv/ops.py | 23 +++++++++---------- .../canonicalization_patterns/riscv.py | 6 ++--- 4 files changed, 23 insertions(+), 20 deletions(-) diff --git a/tests/filecheck/backend/riscv/canonicalize.mlir b/tests/filecheck/backend/riscv/canonicalize.mlir index 292563aa0f..ba7de53232 100644 --- a/tests/filecheck/backend/riscv/canonicalize.mlir +++ b/tests/filecheck/backend/riscv/canonicalize.mlir @@ -111,6 +111,9 @@ builtin.module { %srai_neg = riscv.srai %c_neg1, 1 : (!riscv.reg) -> !riscv.reg "test.op"(%srai_neg) : (!riscv.reg) -> () + %slli_neg = riscv.slli %c_neg1, 1 : (!riscv.reg) -> !riscv.reg + "test.op"(%slli_neg) : (!riscv.reg) -> () + %load_float_ptr = riscv.addi %i2, 8 : (!riscv.reg) -> !riscv.reg %load_float_known_offset = riscv.flw %load_float_ptr, 4 : (!riscv.reg) -> !riscv.freg "test.op"(%load_float_known_offset) : (!riscv.freg) -> () @@ -292,6 +295,9 @@ builtin.module { // CHECK-NEXT: %srai_neg = rv32.li -1 : !riscv.reg // CHECK-NEXT: "test.op"(%srai_neg) : (!riscv.reg) -> () +// CHECK-NEXT: %slli_neg = rv32.li -2 : !riscv.reg +// CHECK-NEXT: "test.op"(%slli_neg) : (!riscv.reg) -> () + // CHECK-NEXT: %load_float_known_offset = riscv.flw %i2, 12 : (!riscv.reg) -> !riscv.freg // CHECK-NEXT: "test.op"(%load_float_known_offset) : (!riscv.freg) -> () diff --git a/xdsl/dialects/riscv/abstract_ops.py b/xdsl/dialects/riscv/abstract_ops.py index 9a67b862e9..d295f3df78 100644 --- a/xdsl/dialects/riscv/abstract_ops.py +++ b/xdsl/dialects/riscv/abstract_ops.py @@ -791,15 +791,13 @@ def custom_print_attributes(self, printer: Printer) -> AbstractSet[str]: return {"immediate"} @abstractmethod - def py_operation( - self, arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] - ) -> IntegerAttr[I32]: + def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: """ Performs a python function corresponding to this operation. - If `i := py_operation(arg0, arg1)` is an IntegerAttr[I32], then this operation can be + If `i := py_operation(rs1)` is an IntegerAttr[I32], then this operation can be canonicalized to a constant with value `i` when the inputs are constants - with values `arg0` and `arg1`. + with values `rs1`. The immediate value is retrieved from the `immediate` attribute of the operation. """ raise NotImplementedError( diff --git a/xdsl/dialects/riscv/ops.py b/xdsl/dialects/riscv/ops.py index d72a316e37..ad524e1d5b 100644 --- a/xdsl/dialects/riscv/ops.py +++ b/xdsl/dialects/riscv/ops.py @@ -248,10 +248,9 @@ class SlliOp(RdRsImmShiftOperation): name = "riscv.slli" - def py_operation( - self, arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] - ) -> IntegerAttr[I32]: - return IntegerAttr(arg0.value.data << arg1.value.data, i32) + def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: + if isinstance(self.immediate, IntegerAttr): + return IntegerAttr(rs1.value.data << self.immediate.value.data, i32) @irdl_op_definition @@ -267,10 +266,11 @@ class SrliOp(RdRsImmShiftOperation): name = "riscv.srli" - def py_operation( - self, arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] - ) -> IntegerAttr[I32]: - return IntegerAttr((arg0.value.data % 0x100000000) >> arg1.value.data, i32) + def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: + if isinstance(self.immediate, IntegerAttr): + return IntegerAttr( + (rs1.value.data % 0x100000000) >> self.immediate.value.data, i32 + ) @irdl_op_definition @@ -286,10 +286,9 @@ class SraiOp(RdRsImmShiftOperation): name = "riscv.srai" - def py_operation( - self, arg0: IntegerAttr[I32], arg1: IntegerAttr[I32] - ) -> IntegerAttr[I32]: - return IntegerAttr(arg0.value.data >> arg1.value.data, i32) + def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: + if isinstance(self.immediate, IntegerAttr): + return IntegerAttr(rs1.value.data >> self.immediate.value.data, i32) @irdl_op_definition diff --git a/xdsl/transforms/canonicalization_patterns/riscv.py b/xdsl/transforms/canonicalization_patterns/riscv.py index dea7fdd560..310a3d9c8b 100644 --- a/xdsl/transforms/canonicalization_patterns/riscv.py +++ b/xdsl/transforms/canonicalization_patterns/riscv.py @@ -315,9 +315,9 @@ def match_and_rewrite( ): rd = op.rd.type val = cast(IntegerAttr[I32], rs1) - shamt = cast(IntegerAttr[I32], op.immediate) - result = op.py_operation(val, shamt) - rewriter.replace_op(op, rv32.LiOp(result, rd=rd)) + result = op.py_operation(val) + if result is not None: + rewriter.replace_op(op, rv32.LiOp(result, rd=rd)) class LoadWordWithKnownOffset(RewritePattern): From 1c25f6902b5942d387403301037120308d6f0021 Mon Sep 17 00:00:00 2001 From: osmanyasar05 Date: Tue, 17 Feb 2026 16:49:55 +0000 Subject: [PATCH 7/9] remove labelattr --- xdsl/dialects/riscv/ops.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/xdsl/dialects/riscv/ops.py b/xdsl/dialects/riscv/ops.py index 84bf7cbaae..a07258fdeb 100644 --- a/xdsl/dialects/riscv/ops.py +++ b/xdsl/dialects/riscv/ops.py @@ -249,8 +249,7 @@ class SlliOp(RdRsImmShiftOperation): name = "riscv.slli" def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: - if isinstance(self.immediate, IntegerAttr): - return IntegerAttr(rs1.value.data << self.immediate.value.data, i32) + return IntegerAttr(rs1.value.data << self.immediate.value.data, i32) @irdl_op_definition @@ -267,10 +266,9 @@ class SrliOp(RdRsImmShiftOperation): name = "riscv.srli" def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: - if isinstance(self.immediate, IntegerAttr): - return IntegerAttr( - (rs1.value.data % 0x100000000) >> self.immediate.value.data, i32 - ) + return IntegerAttr( + (rs1.value.data % 0x100000000) >> self.immediate.value.data, i32 + ) @irdl_op_definition @@ -287,8 +285,7 @@ class SraiOp(RdRsImmShiftOperation): name = "riscv.srai" def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: - if isinstance(self.immediate, IntegerAttr): - return IntegerAttr(rs1.value.data >> self.immediate.value.data, i32) + return IntegerAttr(rs1.value.data >> self.immediate.value.data, i32) @irdl_op_definition From b216caee7e6d0e6f0188a7be1e2703c1eef3e8da Mon Sep 17 00:00:00 2001 From: osmanyasar05 Date: Tue, 17 Feb 2026 17:04:38 +0000 Subject: [PATCH 8/9] label --- xdsl/transforms/canonicalization_patterns/riscv.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/xdsl/transforms/canonicalization_patterns/riscv.py b/xdsl/transforms/canonicalization_patterns/riscv.py index f2ea516b94..b94afd24c1 100644 --- a/xdsl/transforms/canonicalization_patterns/riscv.py +++ b/xdsl/transforms/canonicalization_patterns/riscv.py @@ -319,9 +319,7 @@ class ShiftConstantFolding(RewritePattern): def match_and_rewrite( self, op: riscv.RdRsImmShiftOperation, rewriter: PatternRewriter ) -> None: - if (rs1 := get_constant_value(op.rs1)) is not None and isinstance( - op.immediate, IntegerAttr - ): + if (rs1 := get_constant_value(op.rs1)) is not None: rd = op.rd.type val = cast(IntegerAttr[I32], rs1) result = op.py_operation(val) From ee82909d7335781f81d7201fcee7011f2a95122c Mon Sep 17 00:00:00 2001 From: osmanyasar05 Date: Tue, 17 Feb 2026 17:19:29 +0000 Subject: [PATCH 9/9] remove none --- xdsl/dialects/riscv/abstract_ops.py | 2 +- xdsl/dialects/riscv/ops.py | 6 +++--- xdsl/transforms/canonicalization_patterns/riscv.py | 3 +-- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/xdsl/dialects/riscv/abstract_ops.py b/xdsl/dialects/riscv/abstract_ops.py index 778d80aef1..ecfabd3ec5 100644 --- a/xdsl/dialects/riscv/abstract_ops.py +++ b/xdsl/dialects/riscv/abstract_ops.py @@ -782,7 +782,7 @@ def assembly_line_args(self) -> tuple[AssemblyInstructionArg, ...]: return self.rd, self.rs1, self.immediate @abstractmethod - def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: + def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32]: """ Performs a python function corresponding to this operation. diff --git a/xdsl/dialects/riscv/ops.py b/xdsl/dialects/riscv/ops.py index a07258fdeb..917b67145b 100644 --- a/xdsl/dialects/riscv/ops.py +++ b/xdsl/dialects/riscv/ops.py @@ -248,7 +248,7 @@ class SlliOp(RdRsImmShiftOperation): name = "riscv.slli" - def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: + def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32]: return IntegerAttr(rs1.value.data << self.immediate.value.data, i32) @@ -265,7 +265,7 @@ class SrliOp(RdRsImmShiftOperation): name = "riscv.srli" - def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: + def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32]: return IntegerAttr( (rs1.value.data % 0x100000000) >> self.immediate.value.data, i32 ) @@ -284,7 +284,7 @@ class SraiOp(RdRsImmShiftOperation): name = "riscv.srai" - def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32] | None: + def py_operation(self, rs1: IntegerAttr[I32]) -> IntegerAttr[I32]: return IntegerAttr(rs1.value.data >> self.immediate.value.data, i32) diff --git a/xdsl/transforms/canonicalization_patterns/riscv.py b/xdsl/transforms/canonicalization_patterns/riscv.py index b94afd24c1..ec023ab41c 100644 --- a/xdsl/transforms/canonicalization_patterns/riscv.py +++ b/xdsl/transforms/canonicalization_patterns/riscv.py @@ -323,8 +323,7 @@ def match_and_rewrite( rd = op.rd.type val = cast(IntegerAttr[I32], rs1) result = op.py_operation(val) - if result is not None: - rewriter.replace_op(op, rv32.LiOp(result, rd=rd)) + rewriter.replace_op(op, rv32.LiOp(result, rd=rd)) class LoadWordWithKnownOffset(RewritePattern):