Skip to content

Asm

asm

The asm dialect provides utilities for embedding assembly-level abstractions in higher-level functions.

ASM = ir.Dialect('asm', [FromRegOp, ToRegOp], [], []) module-attribute

FromRegOp

Bases: IRDLOperation, HasFolderInterface

Get the value stored in a given register.

Source code in xdsl/dialects/asm.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
@irdl.irdl_op_definition
class FromRegOp(irdl.IRDLOperation, HasFolderInterface):
    """
    Get the value stored in a given register.
    """

    name = "asm.from_reg"

    register = irdl.operand_def(RegisterType)
    value = irdl.result_def()

    traits = irdl.traits_def(Pure())

    assembly_format = "$register attr-dict `:` type($register) `->` type($value)"

    def __init__(self, register: ir.SSAValue | ir.Operation, result_type: ir.Attribute):
        super().__init__(operands=(register,), result_types=(result_type,))

    def verify_(self) -> None:
        if (
            isinstance(to_reg_op := self.register.owner, ToRegOp)
            and to_reg_op.value.type != self.value.type
        ):
            raise VerifyException(
                f"Expected original value type {to_reg_op.value.type} to be "
                f"equal to own value type {self.value.type}."
            )

    def fold(self) -> Sequence[ir.SSAValue | ir.Attribute] | None:
        if isinstance(to_reg_op := self.register.owner, ToRegOp):
            return (to_reg_op.value,)

name = 'asm.from_reg' class-attribute instance-attribute

register = irdl.operand_def(RegisterType) class-attribute instance-attribute

value = irdl.result_def() class-attribute instance-attribute

traits = irdl.traits_def(Pure()) class-attribute instance-attribute

assembly_format = '$register attr-dict `:` type($register) `->` type($value)' class-attribute instance-attribute

__init__(register: ir.SSAValue | ir.Operation, result_type: ir.Attribute)

Source code in xdsl/dialects/asm.py 
29
30
def __init__(self, register: ir.SSAValue | ir.Operation, result_type: ir.Attribute):
    super().__init__(operands=(register,), result_types=(result_type,))

verify_() -> None

Source code in xdsl/dialects/asm.py 
32
33
34
35
36
37
38
39
40
def verify_(self) -> None:
    if (
        isinstance(to_reg_op := self.register.owner, ToRegOp)
        and to_reg_op.value.type != self.value.type
    ):
        raise VerifyException(
            f"Expected original value type {to_reg_op.value.type} to be "
            f"equal to own value type {self.value.type}."
        )

fold() -> Sequence[ir.SSAValue | ir.Attribute] | None

Source code in xdsl/dialects/asm.py 
42
43
44
def fold(self) -> Sequence[ir.SSAValue | ir.Attribute] | None:
    if isinstance(to_reg_op := self.register.owner, ToRegOp):
        return (to_reg_op.value,)

ToRegOp

Bases: IRDLOperation, HasFolderInterface

Get the register holding a given value.

Source code in xdsl/dialects/asm.py 
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
@irdl.irdl_op_definition
class ToRegOp(irdl.IRDLOperation, HasFolderInterface):
    """
    Get the register holding a given value.
    """

    name = "asm.to_reg"

    value = irdl.operand_def()
    register = irdl.result_def(RegisterType)

    traits = irdl.traits_def(Pure())

    assembly_format = "$value attr-dict `:` type($value) `->` type($register)"

    def __init__(self, value: ir.SSAValue | ir.Operation, result_type: RegisterType):
        super().__init__(operands=(value,), result_types=(result_type,))

    def verify_(self) -> None:
        if (
            isinstance(from_reg_op := self.value.owner, FromRegOp)
            and from_reg_op.register.type != self.register.type
        ):
            raise VerifyException(
                f"Expected original register type {from_reg_op.register.type} to be "
                f"equal to own register type {self.register.type}."
            )

    def fold(self) -> Sequence[ir.SSAValue | ir.Attribute] | None:
        if isinstance(from_reg_op := self.value.owner, FromRegOp):
            return (from_reg_op.register,)

name = 'asm.to_reg' class-attribute instance-attribute

value = irdl.operand_def() class-attribute instance-attribute

register = irdl.result_def(RegisterType) class-attribute instance-attribute

traits = irdl.traits_def(Pure()) class-attribute instance-attribute

assembly_format = '$value attr-dict `:` type($value) `->` type($register)' class-attribute instance-attribute

__init__(value: ir.SSAValue | ir.Operation, result_type: RegisterType)

Source code in xdsl/dialects/asm.py 
62
63
def __init__(self, value: ir.SSAValue | ir.Operation, result_type: RegisterType):
    super().__init__(operands=(value,), result_types=(result_type,))

verify_() -> None

Source code in xdsl/dialects/asm.py 
65
66
67
68
69
70
71
72
73
def verify_(self) -> None:
    if (
        isinstance(from_reg_op := self.value.owner, FromRegOp)
        and from_reg_op.register.type != self.register.type
    ):
        raise VerifyException(
            f"Expected original register type {from_reg_op.register.type} to be "
            f"equal to own register type {self.register.type}."
        )

fold() -> Sequence[ir.SSAValue | ir.Attribute] | None

Source code in xdsl/dialects/asm.py 
75
76
77
def fold(self) -> Sequence[ir.SSAValue | ir.Attribute] | None:
    if isinstance(from_reg_op := self.value.owner, FromRegOp):
        return (from_reg_op.register,)