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
45
46
47
48
49
50
51
52
53
54
@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,))

    @classmethod
    def get(cls, register: ir.SSAValue | ir.Operation, result_type: ir.Attribute):
        """
        Create the operation, and set the result's name hint to `register`'s name hint.
        """
        register = ir.SSAValue.get(register)
        op = cls(register, result_type)
        op.value.name_hint = register.name_hint
        return op

    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,))

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

Create the operation, and set the result's name hint to register's name hint.

Source code in xdsl/dialects/asm.py 
32
33
34
35
36
37
38
39
40
@classmethod
def get(cls, register: ir.SSAValue | ir.Operation, result_type: ir.Attribute):
    """
    Create the operation, and set the result's name hint to `register`'s name hint.
    """
    register = ir.SSAValue.get(register)
    op = cls(register, result_type)
    op.value.name_hint = register.name_hint
    return op

verify_() -> None

Source code in xdsl/dialects/asm.py 
42
43
44
45
46
47
48
49
50
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 
52
53
54
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 
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
@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,))

    @classmethod
    def get(cls, value: ir.SSAValue | ir.Operation, result_type: RegisterType):
        """
        Create the operation, and set the result's name hint to `value`'s name hint.
        """
        value = ir.SSAValue.get(value)
        op = cls(value, result_type)
        op.register.name_hint = value.name_hint
        return op

    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 
72
73
def __init__(self, value: ir.SSAValue | ir.Operation, result_type: RegisterType):
    super().__init__(operands=(value,), result_types=(result_type,))

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

Create the operation, and set the result's name hint to value's name hint.

Source code in xdsl/dialects/asm.py 
75
76
77
78
79
80
81
82
83
@classmethod
def get(cls, value: ir.SSAValue | ir.Operation, result_type: RegisterType):
    """
    Create the operation, and set the result's name hint to `value`'s name hint.
    """
    value = ir.SSAValue.get(value)
    op = cls(value, result_type)
    op.register.name_hint = value.name_hint
    return op

verify_() -> None

Source code in xdsl/dialects/asm.py 
85
86
87
88
89
90
91
92
93
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 
95
96
97
def fold(self) -> Sequence[ir.SSAValue | ir.Attribute] | None:
    if isinstance(from_reg_op := self.value.owner, FromRegOp):
        return (from_reg_op.register,)