Llvm

llvm

GEP_USE_SSA_VAL = -2147483648 module-attribute

This is used in the getelementptr index list to signify that an ssa value should be used for this index.

ALL_ICMP_FLAGS = tuple(ICmpPredicateFlag) module-attribute

ICMP_INDEX_BY_FLAG = {f: i for i, f in (enumerate(ALL_ICMP_FLAGS))} module-attribute

LLVM_CALLING_CONVS: set[str] = {'ccc', 'fastcc', 'coldcc', 'cc 10', 'cc 11', 'webkit_jscc', 'anyregcc', 'preserve_mostcc', 'preserve_allcc', 'cxx_fast_tlscc', 'tailcc', 'swiftcc', 'swifttailcc', 'cfguard_checkcc'} module-attribute

A list of all valid calling conventions understood by LLVM, see external documentation here for more info.

LLVMType = LLVMStructType | LLVMPointerType | LLVMArrayType | LLVMVoidType | LLVMFunctionType module-attribute

LLVMTypeConstr = base(LLVMStructType) | base(LLVMPointerType) | base(LLVMArrayType) | base(LLVMVoidType) | base(LLVMFunctionType) module-attribute

LLVM = Dialect('llvm', [AShrOp, AddOp, AddressOfOp, AllocaOp, AndOp, BitcastOp, CallIntrinsicOp, CallOp, ConstantOp, ExtractValueOp, FAddOp, FDivOp, FMulOp, FPExtOp, FRemOp, FSubOp, FuncOp, GEPOp, GlobalOp, ICmpOp, InlineAsmOp, InsertValueOp, IntToPtrOp, LShrOp, LoadOp, MulOp, NullOp, OrOp, PtrToIntOp, ReturnOp, SDivOp, SExtOp, SIToFPOp, SRemOp, ShlOp, StoreOp, SubOp, TruncOp, UDivOp, URemOp, UndefOp, UnreachableOp, XOrOp, ZExtOp, ZeroOp], [CallingConventionAttr, FastMathAttr, FramePointerKindAttr, LLVMArrayType, LLVMFunctionType, LLVMPointerType, LLVMStructType, LLVMVoidType, LinkageAttr, OverflowAttr, TailCallKindAttr, TargetFeaturesAttr]) module-attribute

LLVMStructType dataclass

Bases: ParametrizedAttribute, TypeAttribute

See external documentation.

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition
class LLVMStructType(ParametrizedAttribute, TypeAttribute):
    """
    See external [documentation](https://mlir.llvm.org/docs/Dialects/LLVM/#structure-types).
    """

    name = "llvm.struct"

    # An empty string refers to a struct without a name.
    struct_name: StringAttr
    types: ArrayAttr[Attribute]

    # TODO: Add this parameter once xDSL supports the necessary capabilities.
    #  bitmask: StringAttr

    @staticmethod
    def from_type_list(types: Sequence[Attribute]) -> LLVMStructType:
        return LLVMStructType(StringAttr(""), ArrayAttr(types))

    def print_parameters(self, printer: Printer) -> None:
        with printer.in_angle_brackets():
            if self.struct_name.data:
                printer.print_string_literal(self.struct_name.data)
                printer.print_string(", ")
            with printer.in_parens():
                printer.print_list(self.types.data, printer.print_attribute)

    @classmethod
    def parse_parameters(cls, parser: AttrParser) -> tuple[StringAttr, ArrayAttr]:
        parser.parse_characters("<", " in LLVM struct")
        struct_name = parser.parse_optional_str_literal()
        if struct_name is None:
            struct_name = ""
        else:
            parser.parse_characters(",", " after type")

        params = parser.parse_comma_separated_list(
            parser.Delimiter.PAREN, lambda: parse_llvm_type(parser)
        )
        parser.parse_characters(">", " to close LLVM struct parameters")
        return (StringAttr(struct_name), ArrayAttr(params))

name = 'llvm.struct' class-attribute instance-attribute

struct_name: StringAttr instance-attribute

types: ArrayAttr[Attribute] instance-attribute

from_type_list(types: Sequence[Attribute]) -> LLVMStructType staticmethod

Source code in xdsl/dialects/llvm.py

@staticmethod
def from_type_list(types: Sequence[Attribute]) -> LLVMStructType:
    return LLVMStructType(StringAttr(""), ArrayAttr(types))

print_parameters(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print_parameters(self, printer: Printer) -> None:
    with printer.in_angle_brackets():
        if self.struct_name.data:
            printer.print_string_literal(self.struct_name.data)
            printer.print_string(", ")
        with printer.in_parens():
            printer.print_list(self.types.data, printer.print_attribute)

parse_parameters(parser: AttrParser) -> tuple[StringAttr, ArrayAttr] classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse_parameters(cls, parser: AttrParser) -> tuple[StringAttr, ArrayAttr]:
    parser.parse_characters("<", " in LLVM struct")
    struct_name = parser.parse_optional_str_literal()
    if struct_name is None:
        struct_name = ""
    else:
        parser.parse_characters(",", " after type")

    params = parser.parse_comma_separated_list(
        parser.Delimiter.PAREN, lambda: parse_llvm_type(parser)
    )
    parser.parse_characters(">", " to close LLVM struct parameters")
    return (StringAttr(struct_name), ArrayAttr(params))

LLVMPointerType

Bases: ParametrizedAttribute, TypeAttribute

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition
class LLVMPointerType(ParametrizedAttribute, TypeAttribute):
    name = "llvm.ptr"

    addr_space: IntAttr | NoneAttr

    def print_parameters(self, printer: Printer) -> None:
        if isinstance(self.addr_space, IntAttr):
            with printer.in_angle_brackets():
                printer.print_int(self.addr_space.data)

    @classmethod
    def parse_parameters(cls, parser: AttrParser) -> tuple[IntAttr | NoneAttr]:
        if parser.parse_optional_characters("<") is None:
            return (NoneAttr(),)
        addr_space = parser.parse_integer()
        parser.parse_characters(">", " to end llvm.ptr parameters")
        return (IntAttr(addr_space),)

    def __init__(self, addr_space: IntAttr | NoneAttr = NoneAttr()):
        super().__init__(addr_space)

name = 'llvm.ptr' class-attribute instance-attribute

addr_space: IntAttr | NoneAttr instance-attribute

print_parameters(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print_parameters(self, printer: Printer) -> None:
    if isinstance(self.addr_space, IntAttr):
        with printer.in_angle_brackets():
            printer.print_int(self.addr_space.data)

parse_parameters(parser: AttrParser) -> tuple[IntAttr | NoneAttr] classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse_parameters(cls, parser: AttrParser) -> tuple[IntAttr | NoneAttr]:
    if parser.parse_optional_characters("<") is None:
        return (NoneAttr(),)
    addr_space = parser.parse_integer()
    parser.parse_characters(">", " to end llvm.ptr parameters")
    return (IntAttr(addr_space),)

__init__(addr_space: IntAttr | NoneAttr = NoneAttr())

Source code in xdsl/dialects/llvm.py

def __init__(self, addr_space: IntAttr | NoneAttr = NoneAttr()):
    super().__init__(addr_space)

LLVMArrayType dataclass

Bases: ParametrizedAttribute, TypeAttribute

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition
class LLVMArrayType(ParametrizedAttribute, TypeAttribute):
    name = "llvm.array"

    size: IntAttr
    type: Attribute

    def print_parameters(self, printer: Printer) -> None:
        with printer.in_angle_brackets():
            printer.print_int(self.size.data)
            printer.print_string(" x ")
            printer.print_attribute(self.type)

    @classmethod
    def parse_parameters(cls, parser: AttrParser) -> tuple[IntAttr, Attribute]:
        with parser.in_angle_brackets():
            size = IntAttr(parser.parse_integer())
            parser.parse_shape_delimiter()
            type = parse_llvm_type(parser)
        return (size, type)

    @staticmethod
    def from_size_and_type(size: int | IntAttr, type: Attribute):
        if isinstance(size, int):
            size = IntAttr(size)
        return LLVMArrayType(size, type)

name = 'llvm.array' class-attribute instance-attribute

size: IntAttr instance-attribute

type: Attribute instance-attribute

print_parameters(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print_parameters(self, printer: Printer) -> None:
    with printer.in_angle_brackets():
        printer.print_int(self.size.data)
        printer.print_string(" x ")
        printer.print_attribute(self.type)

parse_parameters(parser: AttrParser) -> tuple[IntAttr, Attribute] classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse_parameters(cls, parser: AttrParser) -> tuple[IntAttr, Attribute]:
    with parser.in_angle_brackets():
        size = IntAttr(parser.parse_integer())
        parser.parse_shape_delimiter()
        type = parse_llvm_type(parser)
    return (size, type)

from_size_and_type(size: int | IntAttr, type: Attribute) staticmethod

Source code in xdsl/dialects/llvm.py

@staticmethod
def from_size_and_type(size: int | IntAttr, type: Attribute):
    if isinstance(size, int):
        size = IntAttr(size)
    return LLVMArrayType(size, type)

LLVMVoidType dataclass

Bases: ParametrizedAttribute, TypeAttribute

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition
class LLVMVoidType(ParametrizedAttribute, TypeAttribute):
    name = "llvm.void"

name = 'llvm.void' class-attribute instance-attribute

LLVMFunctionType

Bases: ParametrizedAttribute, TypeAttribute

Currently does not support variadics.

See external documentation.

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition
class LLVMFunctionType(ParametrizedAttribute, TypeAttribute):
    """
    Currently does not support variadics.

    See external [documentation](https://mlir.llvm.org/docs/Dialects/LLVM/#function-types).
    """

    name = "llvm.func"

    inputs: ArrayAttr[Attribute]
    output: Attribute
    variadic: UnitAttr | NoneAttr

    def __init__(
        self,
        inputs: Sequence[Attribute] | ArrayAttr[Attribute],
        output: Attribute | None = None,
        is_variadic: bool = False,
    ) -> None:
        if not isinstance(inputs, ArrayAttr):
            inputs = ArrayAttr(inputs)
        if output is None:
            output = LLVMVoidType()
        variad_attr = UnitAttr() if is_variadic else NoneAttr()
        super().__init__(inputs, output, variad_attr)

    @property
    def is_variadic(self) -> bool:
        return isinstance(self.variadic, UnitAttr)

    def print_parameters(self, printer: Printer) -> None:
        with printer.in_angle_brackets():
            if isinstance(self.output, LLVMVoidType):
                printer.print_string("void")
            else:
                printer.print_attribute(self.output)

            printer.print_string(" ")
            with printer.in_parens():
                printer.print_list(self.inputs, printer.print_attribute)
                if self.is_variadic:
                    if self.inputs:
                        printer.print_string(", ")
                    printer.print_string("...")

    @classmethod
    def parse_parameters(cls, parser: AttrParser) -> list[Attribute]:
        parser.parse_characters("<", " in llvm.func parameters")
        output = parse_llvm_type(parser)

        # save pos before args for error message printing
        pos = parser.pos

        def _parse_attr_or_variadic() -> Attribute | EllipsisType:
            """
            This returns either an attribute, or Ellipsis if a
            varargs specifier (`...`) was parsed.
            """
            if parser.parse_optional_characters("...") is not None:
                return ...
            return parse_llvm_type(parser)

        inputs = parser.parse_comma_separated_list(
            Parser.Delimiter.PAREN, _parse_attr_or_variadic
        )
        is_varargs: NoneAttr | UnitAttr = NoneAttr()
        if inputs and inputs[-1] is Ellipsis:
            is_varargs = UnitAttr()
            inputs = inputs[:-1]

        if not isa(inputs, list[Attribute]):
            parser.raise_error(
                "Varargs specifier `...` must be at the end of the argument definition",
                pos,
                parser.pos,
            )

        parser.parse_characters(">", " in llvm.func parameters")

        return [ArrayAttr(inputs), output, is_varargs]

name = 'llvm.func' class-attribute instance-attribute

inputs: ArrayAttr[Attribute] instance-attribute

output: Attribute instance-attribute

variadic: UnitAttr | NoneAttr instance-attribute

is_variadic: bool property

__init__(inputs: Sequence[Attribute] | ArrayAttr[Attribute], output: Attribute | None = None, is_variadic: bool = False) -> None

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    inputs: Sequence[Attribute] | ArrayAttr[Attribute],
    output: Attribute | None = None,
    is_variadic: bool = False,
) -> None:
    if not isinstance(inputs, ArrayAttr):
        inputs = ArrayAttr(inputs)
    if output is None:
        output = LLVMVoidType()
    variad_attr = UnitAttr() if is_variadic else NoneAttr()
    super().__init__(inputs, output, variad_attr)

print_parameters(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print_parameters(self, printer: Printer) -> None:
    with printer.in_angle_brackets():
        if isinstance(self.output, LLVMVoidType):
            printer.print_string("void")
        else:
            printer.print_attribute(self.output)

        printer.print_string(" ")
        with printer.in_parens():
            printer.print_list(self.inputs, printer.print_attribute)
            if self.is_variadic:
                if self.inputs:
                    printer.print_string(", ")
                printer.print_string("...")

parse_parameters(parser: AttrParser) -> list[Attribute] classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse_parameters(cls, parser: AttrParser) -> list[Attribute]:
    parser.parse_characters("<", " in llvm.func parameters")
    output = parse_llvm_type(parser)

    # save pos before args for error message printing
    pos = parser.pos

    def _parse_attr_or_variadic() -> Attribute | EllipsisType:
        """
        This returns either an attribute, or Ellipsis if a
        varargs specifier (`...`) was parsed.
        """
        if parser.parse_optional_characters("...") is not None:
            return ...
        return parse_llvm_type(parser)

    inputs = parser.parse_comma_separated_list(
        Parser.Delimiter.PAREN, _parse_attr_or_variadic
    )
    is_varargs: NoneAttr | UnitAttr = NoneAttr()
    if inputs and inputs[-1] is Ellipsis:
        is_varargs = UnitAttr()
        inputs = inputs[:-1]

    if not isa(inputs, list[Attribute]):
        parser.raise_error(
            "Varargs specifier `...` must be at the end of the argument definition",
            pos,
            parser.pos,
        )

    parser.parse_characters(">", " in llvm.func parameters")

    return [ArrayAttr(inputs), output, is_varargs]

LinkageAttr

Bases: ParametrizedAttribute

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition
class LinkageAttr(ParametrizedAttribute):
    name = "llvm.linkage"

    linkage: StringAttr

    def __init__(self, linkage: str | StringAttr) -> None:
        if isinstance(linkage, str):
            linkage = StringAttr(linkage)
        super().__init__(linkage)

    def print_parameters(self, printer: Printer) -> None:
        printer.print_string("<")
        printer.print_attribute(self.linkage)
        printer.print_string(">")

    @classmethod
    def parse_parameters(cls, parser: AttrParser) -> list[Attribute]:
        parser.parse_characters("<", "llvm.linkage parameter expected")
        # The linkage string is output from xDSL as a string (and accepted by MLIR as such)
        # however it is always output from MLIR without quotes. Therefore need to determine
        # whether this is a string or not and slightly change how we parse based upon that
        linkage_str = parser.parse_optional_str_literal()
        if linkage_str is None:
            linkage_str = parser.parse_identifier()
        linkage = StringAttr(linkage_str)
        parser.parse_characters(">", " to end llvm.linkage parameters")
        return [linkage]

    def verify(self):
        allowed_linkage = [
            "private",
            "internal",
            "available_externally",
            "linkonce",
            "weak",
            "common",
            "appending",
            "extern_weak",
            "linkonce_odr",
            "weak_odr",
            "external",
        ]
        if self.linkage.data not in allowed_linkage:
            raise VerifyException(f"Specified linkage '{self.linkage.data}' is unknown")

name = 'llvm.linkage' class-attribute instance-attribute

linkage: StringAttr instance-attribute

__init__(linkage: str | StringAttr) -> None

Source code in xdsl/dialects/llvm.py

def __init__(self, linkage: str | StringAttr) -> None:
    if isinstance(linkage, str):
        linkage = StringAttr(linkage)
    super().__init__(linkage)

print_parameters(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print_parameters(self, printer: Printer) -> None:
    printer.print_string("<")
    printer.print_attribute(self.linkage)
    printer.print_string(">")

parse_parameters(parser: AttrParser) -> list[Attribute] classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse_parameters(cls, parser: AttrParser) -> list[Attribute]:
    parser.parse_characters("<", "llvm.linkage parameter expected")
    # The linkage string is output from xDSL as a string (and accepted by MLIR as such)
    # however it is always output from MLIR without quotes. Therefore need to determine
    # whether this is a string or not and slightly change how we parse based upon that
    linkage_str = parser.parse_optional_str_literal()
    if linkage_str is None:
        linkage_str = parser.parse_identifier()
    linkage = StringAttr(linkage_str)
    parser.parse_characters(">", " to end llvm.linkage parameters")
    return [linkage]

verify()

Source code in xdsl/dialects/llvm.py

def verify(self):
    allowed_linkage = [
        "private",
        "internal",
        "available_externally",
        "linkonce",
        "weak",
        "common",
        "appending",
        "extern_weak",
        "linkonce_odr",
        "weak_odr",
        "external",
    ]
    if self.linkage.data not in allowed_linkage:
        raise VerifyException(f"Specified linkage '{self.linkage.data}' is unknown")

ArithmeticBinOperation

Bases: IRDLOperation, ABC

Class for arithmetic binary operations.

Source code in xdsl/dialects/llvm.py

class ArithmeticBinOperation(IRDLOperation, ABC):
    """Class for arithmetic binary operations."""

    T: ClassVar = VarConstraint(
        "T", SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )

    lhs = operand_def(T)
    rhs = operand_def(T)
    res = result_def(T)

    traits = traits_def(NoMemoryEffect())

    def __init__(
        self,
        lhs: SSAValue,
        rhs: SSAValue,
        attributes: dict[str, Attribute] = {},
    ):
        super().__init__(
            operands=[lhs, rhs],
            attributes=attributes,
            result_types=[lhs.type],
        )

    @classmethod
    def parse(cls, parser: Parser):
        lhs = parser.parse_unresolved_operand()
        parser.parse_characters(",")
        rhs = parser.parse_unresolved_operand()
        attributes = parser.parse_optional_attr_dict()
        parser.parse_characters(":")
        type = parser.parse_type()
        operands = parser.resolve_operands([lhs, rhs], [type, type], parser.pos)
        return cls(operands[0], operands[1], attributes)

    def print(self, printer: Printer) -> None:
        printer.print_string(" ")
        printer.print_ssa_value(self.lhs)
        printer.print_string(", ")
        printer.print_ssa_value(self.rhs)
        printer.print_op_attributes(self.attributes)
        printer.print_string(" : ")
        printer.print_attribute(self.lhs.type)

T: ClassVar = VarConstraint('T', SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

lhs = operand_def(T) class-attribute instance-attribute

rhs = operand_def(T) class-attribute instance-attribute

res = result_def(T) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(lhs: SSAValue, rhs: SSAValue, attributes: dict[str, Attribute] = {})

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    lhs: SSAValue,
    rhs: SSAValue,
    attributes: dict[str, Attribute] = {},
):
    super().__init__(
        operands=[lhs, rhs],
        attributes=attributes,
        result_types=[lhs.type],
    )

parse(parser: Parser) classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse(cls, parser: Parser):
    lhs = parser.parse_unresolved_operand()
    parser.parse_characters(",")
    rhs = parser.parse_unresolved_operand()
    attributes = parser.parse_optional_attr_dict()
    parser.parse_characters(":")
    type = parser.parse_type()
    operands = parser.resolve_operands([lhs, rhs], [type, type], parser.pos)
    return cls(operands[0], operands[1], attributes)

print(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print(self, printer: Printer) -> None:
    printer.print_string(" ")
    printer.print_ssa_value(self.lhs)
    printer.print_string(", ")
    printer.print_ssa_value(self.rhs)
    printer.print_op_attributes(self.attributes)
    printer.print_string(" : ")
    printer.print_attribute(self.lhs.type)

OverflowFlag

Bases: StrEnum

Source code in xdsl/dialects/llvm.py

class OverflowFlag(StrEnum):
    NO_SIGNED_WRAP = "nsw"
    NO_UNSIGNED_WRAP = "nuw"

NO_SIGNED_WRAP = 'nsw' class-attribute instance-attribute

NO_UNSIGNED_WRAP = 'nuw' class-attribute instance-attribute

OverflowAttrBase dataclass

Bases: BitEnumAttribute[OverflowFlag]

Source code in xdsl/dialects/llvm.py

@dataclass(frozen=True, init=False)
class OverflowAttrBase(BitEnumAttribute[OverflowFlag]):
    none_value = "none"

none_value = 'none' class-attribute instance-attribute

__init__(data: DataElement) -> None

OverflowAttr dataclass

Bases: OverflowAttrBase

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition(init=False)
class OverflowAttr(OverflowAttrBase):
    name = "llvm.overflow"

    @classmethod
    def parse(cls, parser: Parser) -> OverflowAttr:
        if parser.parse_optional_keyword("overflow") is not None:
            return OverflowAttr(OverflowAttr.parse_parameter(parser))
        return OverflowAttr("none")

    def print(self, printer: Printer):
        if self.flags:
            printer.print_string(" overflow")
            self.print_parameter(printer)

    def to_int(self) -> int:
        if len(self.data) == 0:
            return 0
        if len(self.data) == 2:
            return 3
        if self.data[0] == OverflowFlag.NO_SIGNED_WRAP:
            return 1
        return 2

    @staticmethod
    def from_int(i: int) -> OverflowAttr:
        match i:
            case 0:
                return OverflowAttr("none")
            case 1:
                return OverflowAttr((OverflowFlag.NO_SIGNED_WRAP,))
            case 2:
                return OverflowAttr((OverflowFlag.NO_UNSIGNED_WRAP,))
            case 3:
                return OverflowAttr(
                    (OverflowFlag.NO_SIGNED_WRAP, OverflowFlag.NO_UNSIGNED_WRAP)
                )
            case _:
                raise ValueError("OverflowAttr given out of bounds integer.")

name = 'llvm.overflow' class-attribute instance-attribute

parse(parser: Parser) -> OverflowAttr classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse(cls, parser: Parser) -> OverflowAttr:
    if parser.parse_optional_keyword("overflow") is not None:
        return OverflowAttr(OverflowAttr.parse_parameter(parser))
    return OverflowAttr("none")

print(printer: Printer)

Source code in xdsl/dialects/llvm.py

def print(self, printer: Printer):
    if self.flags:
        printer.print_string(" overflow")
        self.print_parameter(printer)

to_int() -> int

Source code in xdsl/dialects/llvm.py

def to_int(self) -> int:
    if len(self.data) == 0:
        return 0
    if len(self.data) == 2:
        return 3
    if self.data[0] == OverflowFlag.NO_SIGNED_WRAP:
        return 1
    return 2

from_int(i: int) -> OverflowAttr staticmethod

Source code in xdsl/dialects/llvm.py

@staticmethod
def from_int(i: int) -> OverflowAttr:
    match i:
        case 0:
            return OverflowAttr("none")
        case 1:
            return OverflowAttr((OverflowFlag.NO_SIGNED_WRAP,))
        case 2:
            return OverflowAttr((OverflowFlag.NO_UNSIGNED_WRAP,))
        case 3:
            return OverflowAttr(
                (OverflowFlag.NO_SIGNED_WRAP, OverflowFlag.NO_UNSIGNED_WRAP)
            )
        case _:
            raise ValueError("OverflowAttr given out of bounds integer.")

ArithmeticBinOpOverflow

Bases: IRDLOperation, ABC

Class for arithmetic binary operations that use overflow flags.

Source code in xdsl/dialects/llvm.py

class ArithmeticBinOpOverflow(IRDLOperation, ABC):
    """Class for arithmetic binary operations that use overflow flags."""

    T: ClassVar = VarConstraint(
        "T", SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )

    lhs = operand_def(T)
    rhs = operand_def(T)
    res = result_def(T)
    overflowFlags = opt_prop_def(IntegerAttr[I32])

    traits = traits_def(NoMemoryEffect())

    def __init__(
        self,
        lhs: SSAValue,
        rhs: SSAValue,
        attributes: dict[str, Attribute] = {},
        overflow: OverflowAttr | IntegerAttr = IntegerAttr(0, 32),
    ):
        if isinstance(overflow, OverflowAttr):
            overflow = IntegerAttr(overflow.to_int(), 32)
        super().__init__(
            operands=[lhs, rhs],
            attributes=attributes,
            result_types=[lhs.type],
            properties={
                "overflowFlags": overflow,
            },
        )

    @classmethod
    def parse(cls, parser: Parser):
        lhs = parser.parse_unresolved_operand()
        parser.parse_characters(",")
        rhs = parser.parse_unresolved_operand()
        overflowFlags = OverflowAttr.parse(parser)
        attributes = parser.parse_optional_attr_dict()
        parser.parse_characters(":")
        type = parser.parse_type()
        operands = parser.resolve_operands([lhs, rhs], [type, type], parser.pos)
        return cls(operands[0], operands[1], attributes, overflowFlags)

    def print(self, printer: Printer) -> None:
        printer.print_string(" ")
        printer.print_ssa_value(self.lhs)
        printer.print_string(", ")
        printer.print_ssa_value(self.rhs)
        if self.overflowFlags:
            OverflowAttr.from_int(self.overflowFlags.value.data).print(printer)
        printer.print_op_attributes(self.attributes)
        printer.print_string(" : ")
        printer.print_attribute(self.lhs.type)

T: ClassVar = VarConstraint('T', SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

lhs = operand_def(T) class-attribute instance-attribute

rhs = operand_def(T) class-attribute instance-attribute

res = result_def(T) class-attribute instance-attribute

overflowFlags = opt_prop_def(IntegerAttr[I32]) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(lhs: SSAValue, rhs: SSAValue, attributes: dict[str, Attribute] = {}, overflow: OverflowAttr | IntegerAttr = IntegerAttr(0, 32))

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    lhs: SSAValue,
    rhs: SSAValue,
    attributes: dict[str, Attribute] = {},
    overflow: OverflowAttr | IntegerAttr = IntegerAttr(0, 32),
):
    if isinstance(overflow, OverflowAttr):
        overflow = IntegerAttr(overflow.to_int(), 32)
    super().__init__(
        operands=[lhs, rhs],
        attributes=attributes,
        result_types=[lhs.type],
        properties={
            "overflowFlags": overflow,
        },
    )

parse(parser: Parser) classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse(cls, parser: Parser):
    lhs = parser.parse_unresolved_operand()
    parser.parse_characters(",")
    rhs = parser.parse_unresolved_operand()
    overflowFlags = OverflowAttr.parse(parser)
    attributes = parser.parse_optional_attr_dict()
    parser.parse_characters(":")
    type = parser.parse_type()
    operands = parser.resolve_operands([lhs, rhs], [type, type], parser.pos)
    return cls(operands[0], operands[1], attributes, overflowFlags)

print(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print(self, printer: Printer) -> None:
    printer.print_string(" ")
    printer.print_ssa_value(self.lhs)
    printer.print_string(", ")
    printer.print_ssa_value(self.rhs)
    if self.overflowFlags:
        OverflowAttr.from_int(self.overflowFlags.value.data).print(printer)
    printer.print_op_attributes(self.attributes)
    printer.print_string(" : ")
    printer.print_attribute(self.lhs.type)

ArithmeticBinOpExact

Bases: IRDLOperation, ABC

Class for arithmetic binary operations that use an exact flag.

Source code in xdsl/dialects/llvm.py

class ArithmeticBinOpExact(IRDLOperation, ABC):
    """Class for arithmetic binary operations that use an exact flag."""

    T: ClassVar = VarConstraint(
        "T", SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )

    lhs = operand_def(T)
    rhs = operand_def(T)
    res = result_def(T)
    is_exact = opt_prop_def(UnitAttr, prop_name="isExact")

    traits = traits_def(NoMemoryEffect())

    def __init__(
        self,
        lhs: SSAValue,
        rhs: SSAValue,
        attributes: dict[str, Attribute] = {},
        is_exact: UnitAttr | None = None,
    ):
        super().__init__(
            operands=[lhs, rhs],
            attributes=attributes,
            result_types=[lhs.type],
            properties={
                "isExact": is_exact,
            },
        )

    @classmethod
    def parse_exact(cls, parser: Parser):
        if parser.parse_optional_keyword("exact") is not None:
            return UnitAttr()

    def print_exact(self, printer: Printer) -> None:
        if self.is_exact:
            printer.print_string(" exact")

    @classmethod
    def parse(cls, parser: Parser):
        exact = cls.parse_exact(parser)
        lhs = parser.parse_unresolved_operand()
        parser.parse_characters(",")
        rhs = parser.parse_unresolved_operand()
        attributes = parser.parse_optional_attr_dict()
        parser.parse_characters(":")
        type = parser.parse_type()
        operands = parser.resolve_operands([lhs, rhs], [type, type], parser.pos)
        return cls(operands[0], operands[1], attributes, exact)

    def print(self, printer: Printer) -> None:
        self.print_exact(printer)
        printer.print_string(" ")
        printer.print_ssa_value(self.lhs)
        printer.print_string(", ")
        printer.print_ssa_value(self.rhs)
        printer.print_op_attributes(self.attributes)
        printer.print_string(" : ")
        printer.print_attribute(self.lhs.type)

T: ClassVar = VarConstraint('T', SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

lhs = operand_def(T) class-attribute instance-attribute

rhs = operand_def(T) class-attribute instance-attribute

res = result_def(T) class-attribute instance-attribute

is_exact = opt_prop_def(UnitAttr, prop_name='isExact') class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(lhs: SSAValue, rhs: SSAValue, attributes: dict[str, Attribute] = {}, is_exact: UnitAttr | None = None)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    lhs: SSAValue,
    rhs: SSAValue,
    attributes: dict[str, Attribute] = {},
    is_exact: UnitAttr | None = None,
):
    super().__init__(
        operands=[lhs, rhs],
        attributes=attributes,
        result_types=[lhs.type],
        properties={
            "isExact": is_exact,
        },
    )

parse_exact(parser: Parser) classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse_exact(cls, parser: Parser):
    if parser.parse_optional_keyword("exact") is not None:
        return UnitAttr()

print_exact(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print_exact(self, printer: Printer) -> None:
    if self.is_exact:
        printer.print_string(" exact")

parse(parser: Parser) classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse(cls, parser: Parser):
    exact = cls.parse_exact(parser)
    lhs = parser.parse_unresolved_operand()
    parser.parse_characters(",")
    rhs = parser.parse_unresolved_operand()
    attributes = parser.parse_optional_attr_dict()
    parser.parse_characters(":")
    type = parser.parse_type()
    operands = parser.resolve_operands([lhs, rhs], [type, type], parser.pos)
    return cls(operands[0], operands[1], attributes, exact)

print(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print(self, printer: Printer) -> None:
    self.print_exact(printer)
    printer.print_string(" ")
    printer.print_ssa_value(self.lhs)
    printer.print_string(", ")
    printer.print_ssa_value(self.rhs)
    printer.print_op_attributes(self.attributes)
    printer.print_string(" : ")
    printer.print_attribute(self.lhs.type)

ArithmeticBinOpDisjoint

Bases: IRDLOperation, ABC

Class for arithmetic binary operations that use a disjoint flag.

Source code in xdsl/dialects/llvm.py

class ArithmeticBinOpDisjoint(IRDLOperation, ABC):
    """Class for arithmetic binary operations that use a disjoint flag."""

    T: ClassVar = VarConstraint(
        "T", SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )

    lhs = operand_def(T)
    rhs = operand_def(T)
    res = result_def(T)
    is_disjoint = opt_prop_def(UnitAttr, prop_name="isDisjoint")

    traits = traits_def(NoMemoryEffect())

    assembly_format = (
        "(`disjoint` $isDisjoint^)? $lhs `,` $rhs attr-dict `:` type($res)"
    )

    def __init__(
        self,
        lhs: SSAValue,
        rhs: SSAValue,
        attributes: dict[str, Attribute] = {},
        is_disjoint: UnitAttr | None = None,
    ):
        super().__init__(
            operands=[lhs, rhs],
            attributes=attributes,
            result_types=[lhs.type],
            properties={
                "isDisjoint": is_disjoint,
            },
        )

T: ClassVar = VarConstraint('T', SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

lhs = operand_def(T) class-attribute instance-attribute

rhs = operand_def(T) class-attribute instance-attribute

res = result_def(T) class-attribute instance-attribute

is_disjoint = opt_prop_def(UnitAttr, prop_name='isDisjoint') class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

assembly_format = '(`disjoint` $isDisjoint^)? $lhs `,` $rhs attr-dict `:` type($res)' class-attribute instance-attribute

__init__(lhs: SSAValue, rhs: SSAValue, attributes: dict[str, Attribute] = {}, is_disjoint: UnitAttr | None = None)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    lhs: SSAValue,
    rhs: SSAValue,
    attributes: dict[str, Attribute] = {},
    is_disjoint: UnitAttr | None = None,
):
    super().__init__(
        operands=[lhs, rhs],
        attributes=attributes,
        result_types=[lhs.type],
        properties={
            "isDisjoint": is_disjoint,
        },
    )

IntegerConversionOp

Bases: IRDLOperation, ABC

Source code in xdsl/dialects/llvm.py

class IntegerConversionOp(IRDLOperation, ABC):
    arg = operand_def(
        SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )

    res = result_def(
        SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )

    traits = traits_def(NoMemoryEffect())

    def __init__(
        self,
        arg: SSAValue,
        res_type: Attribute,
        attributes: dict[str, Attribute] = {},
    ):
        super().__init__(operands=[arg], attributes=attributes, result_types=[res_type])

    @classmethod
    def parse(cls, parser: Parser):
        arg = parser.parse_unresolved_operand()
        attributes = parser.parse_optional_attr_dict()
        parser.parse_characters(":")
        arg_type = parser.parse_type()
        parser.parse_characters("to")
        res_type = parser.parse_type()
        operands = parser.resolve_operands([arg], [arg_type], parser.pos)
        return cls(operands[0], res_type, attributes)

    def print(self, printer: Printer):
        printer.print_string(" ")
        printer.print_ssa_value(self.arg)
        printer.print_op_attributes(self.attributes)
        printer.print_string(" : ")
        printer.print_attribute(self.arg.type)
        printer.print_string(" to ")
        printer.print_attribute(self.res.type)

arg = operand_def(SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

res = result_def(SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(arg: SSAValue, res_type: Attribute, attributes: dict[str, Attribute] = {})

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    arg: SSAValue,
    res_type: Attribute,
    attributes: dict[str, Attribute] = {},
):
    super().__init__(operands=[arg], attributes=attributes, result_types=[res_type])

parse(parser: Parser) classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse(cls, parser: Parser):
    arg = parser.parse_unresolved_operand()
    attributes = parser.parse_optional_attr_dict()
    parser.parse_characters(":")
    arg_type = parser.parse_type()
    parser.parse_characters("to")
    res_type = parser.parse_type()
    operands = parser.resolve_operands([arg], [arg_type], parser.pos)
    return cls(operands[0], res_type, attributes)

print(printer: Printer)

Source code in xdsl/dialects/llvm.py

def print(self, printer: Printer):
    printer.print_string(" ")
    printer.print_ssa_value(self.arg)
    printer.print_op_attributes(self.attributes)
    printer.print_string(" : ")
    printer.print_attribute(self.arg.type)
    printer.print_string(" to ")
    printer.print_attribute(self.res.type)

IntegerConversionOpNNeg

Bases: IRDLOperation, ABC

Source code in xdsl/dialects/llvm.py

class IntegerConversionOpNNeg(IRDLOperation, ABC):
    arg = operand_def(
        SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )
    res = result_def(
        SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )
    traits = traits_def(NoMemoryEffect())
    non_neg = opt_prop_def(UnitAttr, prop_name="nonNeg")

    assembly_format = "(`nneg` $nonNeg^)? $arg attr-dict `:` type($arg) `to` type($res)"

    def __init__(
        self,
        arg: SSAValue,
        res_type: Attribute,
        attributes: dict[str, Attribute] = {},
        non_neg: UnitAttr | None = None,
    ):
        super().__init__(
            operands=(arg,),
            attributes=attributes,
            result_types=(res_type,),
            properties={
                "nonNeg": non_neg,
            },
        )

arg = operand_def(SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

res = result_def(SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

non_neg = opt_prop_def(UnitAttr, prop_name='nonNeg') class-attribute instance-attribute

assembly_format = '(`nneg` $nonNeg^)? $arg attr-dict `:` type($arg) `to` type($res)' class-attribute instance-attribute

__init__(arg: SSAValue, res_type: Attribute, attributes: dict[str, Attribute] = {}, non_neg: UnitAttr | None = None)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    arg: SSAValue,
    res_type: Attribute,
    attributes: dict[str, Attribute] = {},
    non_neg: UnitAttr | None = None,
):
    super().__init__(
        operands=(arg,),
        attributes=attributes,
        result_types=(res_type,),
        properties={
            "nonNeg": non_neg,
        },
    )

IntegerConversionOpOverflow

Bases: IRDLOperation, ABC

Source code in xdsl/dialects/llvm.py

class IntegerConversionOpOverflow(IRDLOperation, ABC):
    arg = operand_def(
        SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )
    res = result_def(
        SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )
    overflowFlags = opt_prop_def(OverflowAttr)
    traits = traits_def(NoMemoryEffect())

    def __init__(
        self,
        arg: SSAValue,
        res_type: Attribute,
        attributes: dict[str, Attribute] = {},
        overflow: OverflowAttr = OverflowAttr(None),
    ):
        super().__init__(
            operands=(arg,),
            attributes=attributes,
            result_types=(res_type,),
            properties={
                "overflowFlags": overflow,
            },
        )

    @classmethod
    def parse(cls, parser: Parser):
        arg = parser.parse_unresolved_operand()
        overflowFlags = OverflowAttr.parse(parser)
        attributes = parser.parse_optional_attr_dict()
        parser.parse_characters(":")
        arg_type = parser.parse_type()
        parser.parse_characters("to")
        res_type = parser.parse_type()
        operands = parser.resolve_operands([arg], [arg_type], parser.pos)
        return cls(operands[0], res_type, attributes, overflowFlags)

    def print(self, printer: Printer):
        printer.print_string(" ")
        printer.print_ssa_value(self.arg)
        if self.overflowFlags:
            self.overflowFlags.print(printer)
        printer.print_op_attributes(self.attributes)
        printer.print_string(" : ")
        printer.print_attribute(self.arg.type)
        printer.print_string(" to ")
        printer.print_attribute(self.res.type)

arg = operand_def(SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

res = result_def(SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

overflowFlags = opt_prop_def(OverflowAttr) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(arg: SSAValue, res_type: Attribute, attributes: dict[str, Attribute] = {}, overflow: OverflowAttr = OverflowAttr(None))

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    arg: SSAValue,
    res_type: Attribute,
    attributes: dict[str, Attribute] = {},
    overflow: OverflowAttr = OverflowAttr(None),
):
    super().__init__(
        operands=(arg,),
        attributes=attributes,
        result_types=(res_type,),
        properties={
            "overflowFlags": overflow,
        },
    )

parse(parser: Parser) classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse(cls, parser: Parser):
    arg = parser.parse_unresolved_operand()
    overflowFlags = OverflowAttr.parse(parser)
    attributes = parser.parse_optional_attr_dict()
    parser.parse_characters(":")
    arg_type = parser.parse_type()
    parser.parse_characters("to")
    res_type = parser.parse_type()
    operands = parser.resolve_operands([arg], [arg_type], parser.pos)
    return cls(operands[0], res_type, attributes, overflowFlags)

print(printer: Printer)

Source code in xdsl/dialects/llvm.py

def print(self, printer: Printer):
    printer.print_string(" ")
    printer.print_ssa_value(self.arg)
    if self.overflowFlags:
        self.overflowFlags.print(printer)
    printer.print_op_attributes(self.attributes)
    printer.print_string(" : ")
    printer.print_attribute(self.arg.type)
    printer.print_string(" to ")
    printer.print_attribute(self.res.type)

AddOp dataclass

Bases: ArithmeticBinOpOverflow

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class AddOp(ArithmeticBinOpOverflow):
    name = "llvm.add"

name = 'llvm.add' class-attribute instance-attribute

SubOp dataclass

Bases: ArithmeticBinOpOverflow

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class SubOp(ArithmeticBinOpOverflow):
    name = "llvm.sub"

name = 'llvm.sub' class-attribute instance-attribute

MulOp dataclass

Bases: ArithmeticBinOpOverflow

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class MulOp(ArithmeticBinOpOverflow):
    name = "llvm.mul"

name = 'llvm.mul' class-attribute instance-attribute

UDivOp dataclass

Bases: ArithmeticBinOpExact

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class UDivOp(ArithmeticBinOpExact):
    name = "llvm.udiv"

name = 'llvm.udiv' class-attribute instance-attribute

SDivOp dataclass

Bases: ArithmeticBinOpExact

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class SDivOp(ArithmeticBinOpExact):
    name = "llvm.sdiv"

name = 'llvm.sdiv' class-attribute instance-attribute

URemOp dataclass

Bases: ArithmeticBinOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class URemOp(ArithmeticBinOperation):
    name = "llvm.urem"

name = 'llvm.urem' class-attribute instance-attribute

SRemOp dataclass

Bases: ArithmeticBinOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class SRemOp(ArithmeticBinOperation):
    name = "llvm.srem"

name = 'llvm.srem' class-attribute instance-attribute

AndOp dataclass

Bases: ArithmeticBinOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class AndOp(ArithmeticBinOperation):
    name = "llvm.and"

name = 'llvm.and' class-attribute instance-attribute

OrOp dataclass

Bases: ArithmeticBinOpDisjoint

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class OrOp(ArithmeticBinOpDisjoint):
    name = "llvm.or"

name = 'llvm.or' class-attribute instance-attribute

XOrOp dataclass

Bases: ArithmeticBinOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class XOrOp(ArithmeticBinOperation):
    name = "llvm.xor"

name = 'llvm.xor' class-attribute instance-attribute

ShlOp dataclass

Bases: ArithmeticBinOpOverflow

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class ShlOp(ArithmeticBinOpOverflow):
    name = "llvm.shl"

name = 'llvm.shl' class-attribute instance-attribute

LShrOp dataclass

Bases: ArithmeticBinOpExact

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class LShrOp(ArithmeticBinOpExact):
    name = "llvm.lshr"

name = 'llvm.lshr' class-attribute instance-attribute

AShrOp dataclass

Bases: ArithmeticBinOpExact

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class AShrOp(ArithmeticBinOpExact):
    name = "llvm.ashr"

name = 'llvm.ashr' class-attribute instance-attribute

TruncOp dataclass

Bases: IntegerConversionOpOverflow

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class TruncOp(IntegerConversionOpOverflow):
    name = "llvm.trunc"

    def verify(self, verify_nested_ops: bool = True):
        arg_type = (
            arg_t.element_type if isa(arg_t := self.arg.type, VectorType) else arg_t
        )
        res_type = (
            res_t.element_type if isa(res_t := self.res.type, VectorType) else res_t
        )

        assert isa(arg_type, IntegerType)
        assert isa(res_type, IntegerType)

        if arg_type.bitwidth <= res_type.bitwidth:
            raise VerifyException(
                f"invalid cast opcode for cast from {arg_type} to {res_type}"
            )
        super().verify(verify_nested_ops)

name = 'llvm.trunc' class-attribute instance-attribute

verify(verify_nested_ops: bool = True)

Source code in xdsl/dialects/llvm.py

def verify(self, verify_nested_ops: bool = True):
    arg_type = (
        arg_t.element_type if isa(arg_t := self.arg.type, VectorType) else arg_t
    )
    res_type = (
        res_t.element_type if isa(res_t := self.res.type, VectorType) else res_t
    )

    assert isa(arg_type, IntegerType)
    assert isa(res_type, IntegerType)

    if arg_type.bitwidth <= res_type.bitwidth:
        raise VerifyException(
            f"invalid cast opcode for cast from {arg_type} to {res_type}"
        )
    super().verify(verify_nested_ops)

ZExtOp dataclass

Bases: IntegerConversionOpNNeg

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class ZExtOp(IntegerConversionOpNNeg):
    name = "llvm.zext"

    def verify(self, verify_nested_ops: bool = True):
        arg_type = (
            arg_t.element_type if isa(arg_t := self.arg.type, VectorType) else arg_t
        )
        res_type = (
            res_t.element_type if isa(res_t := self.res.type, VectorType) else res_t
        )

        assert isa(arg_type, IntegerType)
        assert isa(res_type, IntegerType)
        if arg_type.bitwidth >= res_type.bitwidth:
            raise VerifyException(
                f"invalid cast opcode for cast from {arg_type} to {res_type}"
            )
        super().verify(verify_nested_ops)

name = 'llvm.zext' class-attribute instance-attribute

verify(verify_nested_ops: bool = True)

Source code in xdsl/dialects/llvm.py

def verify(self, verify_nested_ops: bool = True):
    arg_type = (
        arg_t.element_type if isa(arg_t := self.arg.type, VectorType) else arg_t
    )
    res_type = (
        res_t.element_type if isa(res_t := self.res.type, VectorType) else res_t
    )

    assert isa(arg_type, IntegerType)
    assert isa(res_type, IntegerType)
    if arg_type.bitwidth >= res_type.bitwidth:
        raise VerifyException(
            f"invalid cast opcode for cast from {arg_type} to {res_type}"
        )
    super().verify(verify_nested_ops)

SExtOp dataclass

Bases: IntegerConversionOp

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class SExtOp(IntegerConversionOp):
    name = "llvm.sext"

    def verify(self, verify_nested_ops: bool = True):
        arg_type = (
            arg_t.element_type if isa(arg_t := self.arg.type, VectorType) else arg_t
        )
        res_type = (
            res_t.element_type if isa(res_t := self.res.type, VectorType) else res_t
        )

        assert isa(arg_type, IntegerType)
        assert isa(res_type, IntegerType)
        if arg_type.bitwidth >= res_type.bitwidth:
            raise VerifyException(
                f"invalid cast opcode for cast from {arg_type} to {res_type}"
            )
        super().verify(verify_nested_ops)

name = 'llvm.sext' class-attribute instance-attribute

verify(verify_nested_ops: bool = True)

Source code in xdsl/dialects/llvm.py

def verify(self, verify_nested_ops: bool = True):
    arg_type = (
        arg_t.element_type if isa(arg_t := self.arg.type, VectorType) else arg_t
    )
    res_type = (
        res_t.element_type if isa(res_t := self.res.type, VectorType) else res_t
    )

    assert isa(arg_type, IntegerType)
    assert isa(res_type, IntegerType)
    if arg_type.bitwidth >= res_type.bitwidth:
        raise VerifyException(
            f"invalid cast opcode for cast from {arg_type} to {res_type}"
        )
    super().verify(verify_nested_ops)

ICmpPredicateFlag

Bases: StrEnum

Source code in xdsl/dialects/llvm.py

class ICmpPredicateFlag(StrEnum):
    EQ = "eq"
    NE = "ne"
    SLT = "slt"
    SLE = "sle"
    SGT = "sgt"
    SGE = "sge"
    ULT = "ult"
    ULE = "ule"
    UGT = "ugt"
    UGE = "uge"

    @staticmethod
    def from_int(index: int) -> ICmpPredicateFlag:
        return ALL_ICMP_FLAGS[index]

    def to_int(self) -> int:
        return ICMP_INDEX_BY_FLAG[self]

EQ = 'eq' class-attribute instance-attribute

NE = 'ne' class-attribute instance-attribute

SLT = 'slt' class-attribute instance-attribute

SLE = 'sle' class-attribute instance-attribute

SGT = 'sgt' class-attribute instance-attribute

SGE = 'sge' class-attribute instance-attribute

ULT = 'ult' class-attribute instance-attribute

ULE = 'ule' class-attribute instance-attribute

UGT = 'ugt' class-attribute instance-attribute

UGE = 'uge' class-attribute instance-attribute

from_int(index: int) -> ICmpPredicateFlag staticmethod

Source code in xdsl/dialects/llvm.py

@staticmethod
def from_int(index: int) -> ICmpPredicateFlag:
    return ALL_ICMP_FLAGS[index]

to_int() -> int

Source code in xdsl/dialects/llvm.py

def to_int(self) -> int:
    return ICMP_INDEX_BY_FLAG[self]

ICmpOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class ICmpOp(IRDLOperation):
    name = "llvm.icmp"
    T: ClassVar = VarConstraint(
        "T", SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)
    )

    lhs = operand_def(T)
    rhs = operand_def(T)
    res = result_def(I1 | VectorType[I1])
    predicate = prop_def(IntegerAttr[i64])

    traits = traits_def(NoMemoryEffect())

    def __init__(
        self,
        lhs: SSAValue,
        rhs: SSAValue,
        predicate: IntegerAttr[IntegerType],
        attributes: dict[str, Attribute] = {},
    ):
        result_type = (
            VectorType(i1, lhs_type.shape)
            if isa(lhs_type := lhs.type, VectorType)
            else i1
        )

        super().__init__(
            operands=[lhs, rhs],
            attributes=attributes,
            result_types=[result_type],
            properties={
                "predicate": predicate,
            },
        )

    @classmethod
    def parse(cls, parser: Parser):
        predicate_literal = parser.parse_str_literal()
        predicate_value = ICmpPredicateFlag[predicate_literal.upper()]
        predicate_int = predicate_value.to_int()
        predicate = IntegerAttr(predicate_int, i64)
        lhs = parser.parse_unresolved_operand()
        parser.parse_characters(",")
        rhs = parser.parse_unresolved_operand()
        attributes = parser.parse_optional_attr_dict()
        parser.parse_characters(":")
        type = parser.parse_type()
        operands = parser.resolve_operands([lhs, rhs], [type, type], parser.pos)
        return cls(operands[0], operands[1], predicate, attributes)

    def print_predicate(self, printer: Printer):
        flag = ICmpPredicateFlag.from_int(self.predicate.value.data)
        printer.print_string(f"{flag}")

    def print(self, printer: Printer):
        printer.print_string(' "')
        self.print_predicate(printer)
        printer.print_string('" ')
        printer.print_ssa_value(self.lhs)
        printer.print_string(", ")
        printer.print_ssa_value(self.rhs)
        printer.print_op_attributes(self.attributes)
        printer.print_string(" : ")
        printer.print_attribute(self.lhs.type)

    def verify_(self, verify_nested_ops: bool = True) -> None:
        if isa(self.lhs.type, VectorType):
            if not isa(res_type := self.res.type, VectorType):
                raise VerifyException(
                    f"Result must be a vector if operands are vectors, got {res_type}"
                )
        else:
            if isa(res_type := self.res.type, VectorType):
                raise VerifyException(
                    f"Result must be scalar if operands are scalar, got {res_type}"
                )

name = 'llvm.icmp' class-attribute instance-attribute

T: ClassVar = VarConstraint('T', SignlessIntegerConstraint | VectorType.constr(SignlessIntegerConstraint)) class-attribute instance-attribute

lhs = operand_def(T) class-attribute instance-attribute

rhs = operand_def(T) class-attribute instance-attribute

res = result_def(I1 | VectorType[I1]) class-attribute instance-attribute

predicate = prop_def(IntegerAttr[i64]) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(lhs: SSAValue, rhs: SSAValue, predicate: IntegerAttr[IntegerType], attributes: dict[str, Attribute] = {})

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    lhs: SSAValue,
    rhs: SSAValue,
    predicate: IntegerAttr[IntegerType],
    attributes: dict[str, Attribute] = {},
):
    result_type = (
        VectorType(i1, lhs_type.shape)
        if isa(lhs_type := lhs.type, VectorType)
        else i1
    )

    super().__init__(
        operands=[lhs, rhs],
        attributes=attributes,
        result_types=[result_type],
        properties={
            "predicate": predicate,
        },
    )

parse(parser: Parser) classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse(cls, parser: Parser):
    predicate_literal = parser.parse_str_literal()
    predicate_value = ICmpPredicateFlag[predicate_literal.upper()]
    predicate_int = predicate_value.to_int()
    predicate = IntegerAttr(predicate_int, i64)
    lhs = parser.parse_unresolved_operand()
    parser.parse_characters(",")
    rhs = parser.parse_unresolved_operand()
    attributes = parser.parse_optional_attr_dict()
    parser.parse_characters(":")
    type = parser.parse_type()
    operands = parser.resolve_operands([lhs, rhs], [type, type], parser.pos)
    return cls(operands[0], operands[1], predicate, attributes)

print_predicate(printer: Printer)

Source code in xdsl/dialects/llvm.py

def print_predicate(self, printer: Printer):
    flag = ICmpPredicateFlag.from_int(self.predicate.value.data)
    printer.print_string(f"{flag}")

print(printer: Printer)

Source code in xdsl/dialects/llvm.py

def print(self, printer: Printer):
    printer.print_string(' "')
    self.print_predicate(printer)
    printer.print_string('" ')
    printer.print_ssa_value(self.lhs)
    printer.print_string(", ")
    printer.print_ssa_value(self.rhs)
    printer.print_op_attributes(self.attributes)
    printer.print_string(" : ")
    printer.print_attribute(self.lhs.type)

verify_(verify_nested_ops: bool = True) -> None

Source code in xdsl/dialects/llvm.py

def verify_(self, verify_nested_ops: bool = True) -> None:
    if isa(self.lhs.type, VectorType):
        if not isa(res_type := self.res.type, VectorType):
            raise VerifyException(
                f"Result must be a vector if operands are vectors, got {res_type}"
            )
    else:
        if isa(res_type := self.res.type, VectorType):
            raise VerifyException(
                f"Result must be scalar if operands are scalar, got {res_type}"
            )

GEPOp

Bases: IRDLOperation

llvm.getelementptr is an instruction to do pointer arithmetic by adding/subtracting offsets from a pointer.

See external documentation.

GetElementPtr is documented in various places online:

See the LLVM documentation. A good blogpost.

Note that the first two discuss LLVM IRs GEP operation, not the MLIR one. The semantics are the same, but the structure used by MLIR is not well documented (yet) and the syntax is a bit different.

Here we focus on MLIRs GEP operation:

%res = llvm.getelementptr %ptr [1, 2, %val] ^^^^ ^^^^^^^^^^ input indices

The central point to understanding GEP is that:

GEP never dereferences, it only does math on the given pointer

It always returns a pointer to the element "selected" that is some number of bytes offset from the input pointer:

result = ptr + x for some x parametrized by the arguments

Examples:

Given the following pointer:

%ptr : llvm.ptr<llvm.struct<(i32, i32, llvm.array<2xi32>)>>

The following indices point to the following things:

[0] -> The first element of the pointer, so a pointer to the struct: llvm.ptr<llvm.struct<(i32, i32, llvm.array<2xi32>)>>

[1] -> The next element of the pointer, useful if the pointer points to a list of structs. Equivalent to (ptr + 1), so points to llvm.ptr<llvm.struct<(i32, i32, llvm.array<2xi32>)>>

[0,0] -> The first member of the first struct: llvm.ptr

[1,0] -> The first member of the second struct pointed to by ptr (can result in out-of-bounds access if the ptr only points to a single struct) llvm.ptr

[0,2] -> The third member of the first struct. llvm.ptr<llvm.array<2,i32>>

[0,2,0] -> The first entry of the array that is the third member of the first struct pointed to by our ptr. llvm.ptr

[0,0,1] -> Invalid! The first element of the first struct has no "sub-elements"!

Here is an example of invalid GEP operation parameters:

Given a different pointer to the example above:

%ptr : llvm.ptr<llvm.struct<(llvm.ptr, i32)>>

Note the two pointers, one to the struct, one in the struct.

We can do math on the first pointer:

[0] -> First struct llvm.ptr<llvm.struct<(llvm.ptr, i32)>>

[0,1] -> Second member of first struct llvm.ptr

[0,0] -> First member of the first struct llvm.ptr>

[0,0,3] -> Invalid! In order to find the fourth element in the pointer it would need to be dereferenced! GEP can't do that!

Expressed in "C", this would equate to:

address of first struct

(ptr + 0)

address of first field of first struct

&((ptr + 0)->elm0) ^^^^^^ Even though it looks like it, we are not actually dereferencing ptr here.

address of fourth element:

&(((ptr + 0)->elm0 + 3)) ^^^^^^^^^^ This actually dereferences (ptr + 0) to access elm0!

Which translates to roughly this MLIR code:

%elm0_addr = llvm.gep %ptr[0,0] : (!llvm.ptr<...>) -> !llvm.ptr<!llvm.ptr> %elm0 = llvm.load %elm0_addr : (!llvm.ptr>) -> !llvm.ptr %elm0_3_addr = llvm.gep %elm0[3] : !llvm.ptr -> !llvm.ptr

Here the necessary dereferencing is very visible, as %elm0_3_addr is only accessible through an llvm.load on %elm0_addr.

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class GEPOp(IRDLOperation):
    """
    llvm.getelementptr is an instruction to do pointer arithmetic by
    adding/subtracting offsets from a pointer.

    See external [documentation](https://mlir.llvm.org/docs/Dialects/LLVM/#llvmgetelementptr-mlirllvmgepop).

    GetElementPtr is documented in various places online:

    See the LLVM [documentation](https://www.llvm.org/docs/GetElementPtr.html).
    A good [blogpost](https://blog.yossarian.net/2020/09/19/LLVMs-getelementptr-by-example).

    Note that the first two discuss *LLVM IRs* GEP operation, not the MLIR one.
    The semantics are the same, but the structure used by MLIR is not well
    documented (yet) and the syntax is a bit different.

    Here we focus on MLIRs GEP operation:

    %res = llvm.getelementptr %ptr  [1, 2, %val]
                              ^^^^   ^^^^^^^^^^
                              input   indices

    The central point to understanding GEP is that:
    > GEP never dereferences, it only does math on the given pointer

    It *always* returns a pointer to the element "selected" that is some
    number of bytes offset from the input pointer:

    `result = ptr + x` for some x parametrized by the arguments

    ## Examples:

    Given the following pointer:

    %ptr : llvm.ptr<llvm.struct<(i32, i32, llvm.array<2xi32>)>>

    The following indices point to the following things:

    [0]      -> The first element of the pointer, so a pointer to the struct:
                llvm.ptr<llvm.struct<(i32, i32, llvm.array<2xi32>)>>

    [1]      -> The *next* element of the pointer, useful if the
                pointer points to a list of structs.
                Equivalent to (ptr + 1), so points to
                llvm.ptr<llvm.struct<(i32, i32, llvm.array<2xi32>)>>

    [0,0]    -> The first member of the first struct:
                llvm.ptr<i32>

    [1,0]    -> The first member of the *second* struct pointed to by ptr
                (can result in out-of-bounds access if the ptr only points to a single struct)
                llvm.ptr<i32>

    [0,2]    -> The third member of the first struct.
                llvm.ptr<llvm.array<2,i32>>

    [0,2,0]  -> The first entry of the array that is the third member of
                the first struct pointed to by our ptr.
                llvm.ptr<i32>

    [0,0,1]  -> Invalid! The first element of the first struct has no "sub-elements"!


    Here is an example of invalid GEP operation parameters:

    Given a different pointer to the example above:

    %ptr : llvm.ptr<llvm.struct<(llvm.ptr<i32>, i32)>>

    Note the two pointers, one to the struct, one in the struct.

    We can do math on the first pointer:

    [0]      -> First struct
                llvm.ptr<llvm.struct<(llvm.ptr<i32>, i32)>>

    [0,1]    -> Second member of first struct
                llvm.ptr<i32>

    [0,0]    -> First member of the first struct
                llvm.ptr<llvm.ptr<i32>>

    [0,0,3]  -> Invalid! In order to find the fourth element in the pointer
                it would need to be dereferenced! GEP can't do that!

    Expressed in "C", this would equate to:

    # address of first struct
    (ptr + 0)

    # address of first field of first struct
    &((ptr + 0)->elm0)
               ^^^^^^
               Even though it looks like it, we are not actually
               dereferencing ptr here.

    # address of fourth element:
    &(((ptr + 0)->elm0 + 3))
                ^^^^^^^^^^
                This actually dereferences (ptr + 0) to access elm0!

    Which translates to roughly this MLIR code:

    %elm0_addr   = llvm.gep %ptr[0,0]   : (!llvm.ptr<...>) -> !llvm.ptr<!llvm.ptr<i32>>
    %elm0        = llvm.load %elm0_addr : (!llvm.ptr<llvm.ptr<i32>>) -> !llvm.ptr<i32>
    %elm0_3_addr = llvm.gep %elm0[3]    : !llvm.ptr<i32> -> !llvm.ptr<i32>

    Here the necessary dereferencing is very visible, as %elm0_3_addr is only
    accessible through an `llvm.load` on %elm0_addr.
    """

    name = "llvm.getelementptr"

    ptr = operand_def(LLVMPointerType)
    ssa_indices = var_operand_def(IntegerType)
    elem_type = prop_def()
    noWrapFlags = prop_def(IntegerAttr[I32])

    result = result_def(LLVMPointerType)

    rawConstantIndices = prop_def(DenseArrayBase.constr(i32))
    inbounds = opt_prop_def(UnitAttr)

    traits = traits_def(NoMemoryEffect())

    def __init__(
        self,
        ptr: SSAValue | Operation,
        indices: Sequence[int],
        pointee_type: Attribute,
        ssa_indices: Sequence[SSAValue | Operation] | None = None,
        result_type: LLVMPointerType = LLVMPointerType(),
        inbounds: bool = False,
    ):
        """
        A basic constructor for the GEPOp.

        Pass the GEP_USE_SSA_VAL magic value in place of each constant
        index that you want to be read from an SSA value.

        Take a look at `from_mixed_indices` for something without
        magic values.
        """
        if ssa_indices is None:
            ssa_indices = []

        props: dict[str, Attribute] = {
            "rawConstantIndices": DenseArrayBase.from_list(i32, indices),
            "elem_type": pointee_type,
            "noWrapFlags": IntegerAttr(0, 32),
        }

        props["elem_type"] = pointee_type

        if inbounds:
            props["inbounds"] = UnitAttr()

        super().__init__(
            operands=[ptr, ssa_indices], result_types=[result_type], properties=props
        )

    @staticmethod
    def from_mixed_indices(
        ptr: SSAValue | Operation,
        indices: Sequence[int | SSAValue | Operation],
        pointee_type: Attribute,
        result_type: LLVMPointerType = LLVMPointerType(),
        inbounds: bool = False,
    ):
        """
        This is a helper function that accepts a mixed list of SSA values and const
        indices. It will automatically construct the correct indices and ssa_indices
        lists from that.

        You can call this using [1, 2, some_ssa_val, 3] as the indices array.

        Other than that, this behaves exactly the same as `.get`
        """
        ssa_indices: list[SSAValue] = []
        const_indices: list[int] = []
        for idx in indices:
            if isinstance(idx, int):
                const_indices.append(idx)
            else:
                const_indices.append(GEP_USE_SSA_VAL)
                ssa_indices.append(SSAValue.get(idx))
        return GEPOp(
            ptr,
            const_indices,
            pointee_type,
            ssa_indices,
            result_type=result_type,
            inbounds=inbounds,
        )

name = 'llvm.getelementptr' class-attribute instance-attribute

ptr = operand_def(LLVMPointerType) class-attribute instance-attribute

ssa_indices = var_operand_def(IntegerType) class-attribute instance-attribute

elem_type = prop_def() class-attribute instance-attribute

noWrapFlags = prop_def(IntegerAttr[I32]) class-attribute instance-attribute

result = result_def(LLVMPointerType) class-attribute instance-attribute

rawConstantIndices = prop_def(DenseArrayBase.constr(i32)) class-attribute instance-attribute

inbounds = opt_prop_def(UnitAttr) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(ptr: SSAValue | Operation, indices: Sequence[int], pointee_type: Attribute, ssa_indices: Sequence[SSAValue | Operation] | None = None, result_type: LLVMPointerType = LLVMPointerType(), inbounds: bool = False)

A basic constructor for the GEPOp.

Pass the GEP_USE_SSA_VAL magic value in place of each constant index that you want to be read from an SSA value.

Take a look at from_mixed_indices for something without magic values.

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    ptr: SSAValue | Operation,
    indices: Sequence[int],
    pointee_type: Attribute,
    ssa_indices: Sequence[SSAValue | Operation] | None = None,
    result_type: LLVMPointerType = LLVMPointerType(),
    inbounds: bool = False,
):
    """
    A basic constructor for the GEPOp.

    Pass the GEP_USE_SSA_VAL magic value in place of each constant
    index that you want to be read from an SSA value.

    Take a look at `from_mixed_indices` for something without
    magic values.
    """
    if ssa_indices is None:
        ssa_indices = []

    props: dict[str, Attribute] = {
        "rawConstantIndices": DenseArrayBase.from_list(i32, indices),
        "elem_type": pointee_type,
        "noWrapFlags": IntegerAttr(0, 32),
    }

    props["elem_type"] = pointee_type

    if inbounds:
        props["inbounds"] = UnitAttr()

    super().__init__(
        operands=[ptr, ssa_indices], result_types=[result_type], properties=props
    )

from_mixed_indices(ptr: SSAValue | Operation, indices: Sequence[int | SSAValue | Operation], pointee_type: Attribute, result_type: LLVMPointerType = LLVMPointerType(), inbounds: bool = False) staticmethod

This is a helper function that accepts a mixed list of SSA values and const indices. It will automatically construct the correct indices and ssa_indices lists from that.

You can call this using [1, 2, some_ssa_val, 3] as the indices array.

Other than that, this behaves exactly the same as .get

Source code in xdsl/dialects/llvm.py

@staticmethod
def from_mixed_indices(
    ptr: SSAValue | Operation,
    indices: Sequence[int | SSAValue | Operation],
    pointee_type: Attribute,
    result_type: LLVMPointerType = LLVMPointerType(),
    inbounds: bool = False,
):
    """
    This is a helper function that accepts a mixed list of SSA values and const
    indices. It will automatically construct the correct indices and ssa_indices
    lists from that.

    You can call this using [1, 2, some_ssa_val, 3] as the indices array.

    Other than that, this behaves exactly the same as `.get`
    """
    ssa_indices: list[SSAValue] = []
    const_indices: list[int] = []
    for idx in indices:
        if isinstance(idx, int):
            const_indices.append(idx)
        else:
            const_indices.append(GEP_USE_SSA_VAL)
            ssa_indices.append(SSAValue.get(idx))
    return GEPOp(
        ptr,
        const_indices,
        pointee_type,
        ssa_indices,
        result_type=result_type,
        inbounds=inbounds,
    )

AllocaOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class AllocaOp(IRDLOperation):
    name = "llvm.alloca"

    size = operand_def(IntegerType)

    alignment = opt_prop_def(IntegerAttr)
    elem_type = opt_prop_def()

    res = result_def()

    def __init__(
        self,
        size: SSAValue | Operation,
        elem_type: Attribute,
        alignment: int = 32,
    ):
        props: dict[str, Attribute] = {
            "alignment": IntegerAttr.from_int_and_width(alignment, 64)
        }
        ptr_type = LLVMPointerType()
        props["elem_type"] = elem_type

        super().__init__(operands=[size], properties=props, result_types=[ptr_type])

name = 'llvm.alloca' class-attribute instance-attribute

size = operand_def(IntegerType) class-attribute instance-attribute

alignment = opt_prop_def(IntegerAttr) class-attribute instance-attribute

elem_type = opt_prop_def() class-attribute instance-attribute

res = result_def() class-attribute instance-attribute

__init__(size: SSAValue | Operation, elem_type: Attribute, alignment: int = 32)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    size: SSAValue | Operation,
    elem_type: Attribute,
    alignment: int = 32,
):
    props: dict[str, Attribute] = {
        "alignment": IntegerAttr.from_int_and_width(alignment, 64)
    }
    ptr_type = LLVMPointerType()
    props["elem_type"] = elem_type

    super().__init__(operands=[size], properties=props, result_types=[ptr_type])

IntToPtrOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class IntToPtrOp(IRDLOperation):
    name = "llvm.inttoptr"

    input = operand_def(IntegerType)

    output = result_def(LLVMPointerType)

    traits = traits_def(NoMemoryEffect())

    def __init__(self, input: SSAValue | Operation):
        ptr_type = LLVMPointerType()
        super().__init__(operands=[input], result_types=[ptr_type])

name = 'llvm.inttoptr' class-attribute instance-attribute

input = operand_def(IntegerType) class-attribute instance-attribute

output = result_def(LLVMPointerType) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(input: SSAValue | Operation)

Source code in xdsl/dialects/llvm.py

def __init__(self, input: SSAValue | Operation):
    ptr_type = LLVMPointerType()
    super().__init__(operands=[input], result_types=[ptr_type])

TailCallKind

Bases: StrEnum

Source code in xdsl/dialects/llvm.py

class TailCallKind(StrEnum):
    NONE = "none"
    TAIL = "tail"
    MUST_TAIL = "musttail"
    NOTAIL = "notail"

NONE = 'none' class-attribute instance-attribute

TAIL = 'tail' class-attribute instance-attribute

MUST_TAIL = 'musttail' class-attribute instance-attribute

NOTAIL = 'notail' class-attribute instance-attribute

TailCallKindAttr dataclass

Bases: EnumAttribute[TailCallKind]

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition
class TailCallKindAttr(EnumAttribute[TailCallKind]):
    name = "llvm.tailcallkind"

    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> TailCallKind:
        with parser.in_angle_brackets():
            return super().parse_parameter(parser)

    def print_parameter(self, printer: Printer) -> None:
        with printer.in_angle_brackets():
            super().print_parameter(printer)

name = 'llvm.tailcallkind' class-attribute instance-attribute

parse_parameter(parser: AttrParser) -> TailCallKind classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse_parameter(cls, parser: AttrParser) -> TailCallKind:
    with parser.in_angle_brackets():
        return super().parse_parameter(parser)

print_parameter(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print_parameter(self, printer: Printer) -> None:
    with printer.in_angle_brackets():
        super().print_parameter(printer)

InlineAsmOp

Bases: IRDLOperation

See external documentation.

To see what each field means, have a look here.

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class InlineAsmOp(IRDLOperation):
    """
    See external [documentation](https://mlir.llvm.org/docs/Dialects/LLVM/#llvminline_asm-llvminlineasmop).

    To see what each field means, have a look [here](https://llvm.org/docs/LangRef.html#inline-assembler-expressions).
    """

    name = "llvm.inline_asm"

    operands_ = var_operand_def()

    res = opt_result_def()

    # note: in MLIR upstream this is implemented as AsmDialectAttr;
    # which is an instantiation of an LLVM_EnumAttr
    # 0 for AT&T inline assembly dialect
    # 1 for Intel inline assembly dialect
    # In this context dialect does not refer to an MLIR dialect
    asm_dialect = opt_prop_def(IntegerAttr[I64])

    asm_string = prop_def(StringAttr)
    constraints = prop_def(StringAttr)

    has_side_effects = opt_prop_def(UnitAttr)
    is_align_stack = opt_prop_def(UnitAttr)

    tail_call_kind = prop_def(
        TailCallKindAttr, default_value=TailCallKindAttr(TailCallKind.NONE)
    )

    def __init__(
        self,
        asm_string: str,
        constraints: str,
        operands: Sequence[SSAValue | Operation],
        res_types: Sequence[Attribute] | None = None,
        asm_dialect: int = 0,
        has_side_effects: bool = False,
        is_align_stack: bool = False,
        tail_call_kind: TailCallKindAttr | None = None,
    ):
        props: dict[str, Attribute | None] = {
            "asm_string": StringAttr(asm_string),
            "constraints": StringAttr(constraints),
            "asm_dialect": IntegerAttr.from_int_and_width(asm_dialect, 64),
            "has_side_effects": UnitAttr() if has_side_effects else None,
            "is_align_stack": UnitAttr() if is_align_stack else None,
            "tail_call_kind": tail_call_kind,
        }

        if res_types is None:
            res_types = []

        super().__init__(
            operands=[operands],
            properties=props,
            result_types=[res_types],
        )

name = 'llvm.inline_asm' class-attribute instance-attribute

operands_ = var_operand_def() class-attribute instance-attribute

res = opt_result_def() class-attribute instance-attribute

asm_dialect = opt_prop_def(IntegerAttr[I64]) class-attribute instance-attribute

asm_string = prop_def(StringAttr) class-attribute instance-attribute

constraints = prop_def(StringAttr) class-attribute instance-attribute

has_side_effects = opt_prop_def(UnitAttr) class-attribute instance-attribute

is_align_stack = opt_prop_def(UnitAttr) class-attribute instance-attribute

tail_call_kind = prop_def(TailCallKindAttr, default_value=(TailCallKindAttr(TailCallKind.NONE))) class-attribute instance-attribute

__init__(asm_string: str, constraints: str, operands: Sequence[SSAValue | Operation], res_types: Sequence[Attribute] | None = None, asm_dialect: int = 0, has_side_effects: bool = False, is_align_stack: bool = False, tail_call_kind: TailCallKindAttr | None = None)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    asm_string: str,
    constraints: str,
    operands: Sequence[SSAValue | Operation],
    res_types: Sequence[Attribute] | None = None,
    asm_dialect: int = 0,
    has_side_effects: bool = False,
    is_align_stack: bool = False,
    tail_call_kind: TailCallKindAttr | None = None,
):
    props: dict[str, Attribute | None] = {
        "asm_string": StringAttr(asm_string),
        "constraints": StringAttr(constraints),
        "asm_dialect": IntegerAttr.from_int_and_width(asm_dialect, 64),
        "has_side_effects": UnitAttr() if has_side_effects else None,
        "is_align_stack": UnitAttr() if is_align_stack else None,
        "tail_call_kind": tail_call_kind,
    }

    if res_types is None:
        res_types = []

    super().__init__(
        operands=[operands],
        properties=props,
        result_types=[res_types],
    )

PtrToIntOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class PtrToIntOp(IRDLOperation):
    name = "llvm.ptrtoint"

    input = operand_def(LLVMPointerType)

    output = result_def(IntegerType)

    traits = traits_def(NoMemoryEffect())

    def __init__(self, arg: SSAValue | Operation, int_type: Attribute = i64):
        super().__init__(operands=[arg], result_types=[int_type])

name = 'llvm.ptrtoint' class-attribute instance-attribute

input = operand_def(LLVMPointerType) class-attribute instance-attribute

output = result_def(IntegerType) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(arg: SSAValue | Operation, int_type: Attribute = i64)

Source code in xdsl/dialects/llvm.py

def __init__(self, arg: SSAValue | Operation, int_type: Attribute = i64):
    super().__init__(operands=[arg], result_types=[int_type])

LoadOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class LoadOp(IRDLOperation):
    name = "llvm.load"

    ptr = operand_def(LLVMPointerType)

    alignment = opt_prop_def(IntegerAttr[IntegerType])
    ordering = prop_def(IntegerAttr[IntegerType], default_value=IntegerAttr(0, i64))

    dereferenced_value = result_def()

    def __init__(
        self,
        ptr: SSAValue | Operation,
        result_type: Attribute,
        alignment: int | None = None,
        ordering: int = 0,
    ):
        props: dict[str, Attribute] = {
            "ordering": IntegerAttr(ordering, i64),
        }

        if alignment is not None:
            props["alignment"] = IntegerAttr(alignment, i64)

        super().__init__(operands=[ptr], result_types=[result_type], properties=props)

name = 'llvm.load' class-attribute instance-attribute

ptr = operand_def(LLVMPointerType) class-attribute instance-attribute

alignment = opt_prop_def(IntegerAttr[IntegerType]) class-attribute instance-attribute

ordering = prop_def(IntegerAttr[IntegerType], default_value=(IntegerAttr(0, i64))) class-attribute instance-attribute

dereferenced_value = result_def() class-attribute instance-attribute

__init__(ptr: SSAValue | Operation, result_type: Attribute, alignment: int | None = None, ordering: int = 0)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    ptr: SSAValue | Operation,
    result_type: Attribute,
    alignment: int | None = None,
    ordering: int = 0,
):
    props: dict[str, Attribute] = {
        "ordering": IntegerAttr(ordering, i64),
    }

    if alignment is not None:
        props["alignment"] = IntegerAttr(alignment, i64)

    super().__init__(operands=[ptr], result_types=[result_type], properties=props)

StoreOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class StoreOp(IRDLOperation):
    name = "llvm.store"

    value = operand_def()
    ptr = operand_def(LLVMPointerType)

    alignment = opt_prop_def(IntegerAttr[IntegerType])
    ordering = opt_prop_def(IntegerAttr[IntegerType])
    volatile_ = opt_prop_def(UnitAttr)
    nontemporal = opt_prop_def(UnitAttr)

    def __init__(
        self,
        value: SSAValue | Operation,
        ptr: SSAValue | Operation,
        alignment: int | None = None,
        ordering: int = 0,
        volatile: bool = False,
        nontemporal: bool = False,
    ):
        props: dict[str, Attribute] = {
            "ordering": IntegerAttr(ordering, i64),
        }

        if alignment is not None:
            props["alignment"] = IntegerAttr[IntegerType](alignment, i64)
        if volatile:
            props["volatile_"] = UnitAttr()
        if nontemporal:
            props["nontemporal"] = UnitAttr()

        super().__init__(
            operands=[value, ptr],
            properties=props,
            result_types=[],
        )

name = 'llvm.store' class-attribute instance-attribute

value = operand_def() class-attribute instance-attribute

ptr = operand_def(LLVMPointerType) class-attribute instance-attribute

alignment = opt_prop_def(IntegerAttr[IntegerType]) class-attribute instance-attribute

ordering = opt_prop_def(IntegerAttr[IntegerType]) class-attribute instance-attribute

volatile_ = opt_prop_def(UnitAttr) class-attribute instance-attribute

nontemporal = opt_prop_def(UnitAttr) class-attribute instance-attribute

__init__(value: SSAValue | Operation, ptr: SSAValue | Operation, alignment: int | None = None, ordering: int = 0, volatile: bool = False, nontemporal: bool = False)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    value: SSAValue | Operation,
    ptr: SSAValue | Operation,
    alignment: int | None = None,
    ordering: int = 0,
    volatile: bool = False,
    nontemporal: bool = False,
):
    props: dict[str, Attribute] = {
        "ordering": IntegerAttr(ordering, i64),
    }

    if alignment is not None:
        props["alignment"] = IntegerAttr[IntegerType](alignment, i64)
    if volatile:
        props["volatile_"] = UnitAttr()
    if nontemporal:
        props["nontemporal"] = UnitAttr()

    super().__init__(
        operands=[value, ptr],
        properties=props,
        result_types=[],
    )

NullOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class NullOp(IRDLOperation):
    name = "llvm.mlir.null"

    nullptr = result_def(LLVMPointerType)

    traits = traits_def(NoMemoryEffect())

    def __init__(self, ptr_type: LLVMPointerType | None = None):
        if ptr_type is None:
            ptr_type = LLVMPointerType()

        super().__init__(result_types=[ptr_type])

name = 'llvm.mlir.null' class-attribute instance-attribute

nullptr = result_def(LLVMPointerType) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(ptr_type: LLVMPointerType | None = None)

Source code in xdsl/dialects/llvm.py

def __init__(self, ptr_type: LLVMPointerType | None = None):
    if ptr_type is None:
        ptr_type = LLVMPointerType()

    super().__init__(result_types=[ptr_type])

ExtractValueOp

Bases: IRDLOperation

See external documentation.

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class ExtractValueOp(IRDLOperation):
    """
    See external [documentation](https://mlir.llvm.org/docs/Dialects/LLVM/#llvmextractvalue-mlirllvmextractvalueop).
    """

    name = "llvm.extractvalue"

    position = prop_def(DenseArrayBase.constr(i64))
    container = operand_def(Attribute)

    res = result_def(Attribute)

    traits = traits_def(NoMemoryEffect())

    def __init__(
        self,
        position: DenseArrayBase,
        container: SSAValue | Operation,
        result_type: Attribute,
    ):
        super().__init__(
            operands=[container],
            properties={
                "position": position,
            },
            result_types=[result_type],
        )

name = 'llvm.extractvalue' class-attribute instance-attribute

position = prop_def(DenseArrayBase.constr(i64)) class-attribute instance-attribute

container = operand_def(Attribute) class-attribute instance-attribute

res = result_def(Attribute) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(position: DenseArrayBase, container: SSAValue | Operation, result_type: Attribute)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    position: DenseArrayBase,
    container: SSAValue | Operation,
    result_type: Attribute,
):
    super().__init__(
        operands=[container],
        properties={
            "position": position,
        },
        result_types=[result_type],
    )

InsertValueOp

Bases: IRDLOperation

See external documentation.

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class InsertValueOp(IRDLOperation):
    """
    See external [documentation](https://mlir.llvm.org/docs/Dialects/LLVM/#llvminsertvalue-mlirllvminsertvalueop).
    """

    name = "llvm.insertvalue"

    position = prop_def(DenseArrayBase.constr(i64))
    container = operand_def(Attribute)
    value = operand_def(Attribute)

    res = result_def(Attribute)

    traits = traits_def(NoMemoryEffect())

    def __init__(
        self,
        position: DenseArrayBase,
        container: SSAValue,
        value: SSAValue,
    ):
        super().__init__(
            operands=[container, value],
            properties={
                "position": position,
            },
            result_types=[container.type],
        )

name = 'llvm.insertvalue' class-attribute instance-attribute

position = prop_def(DenseArrayBase.constr(i64)) class-attribute instance-attribute

container = operand_def(Attribute) class-attribute instance-attribute

value = operand_def(Attribute) class-attribute instance-attribute

res = result_def(Attribute) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(position: DenseArrayBase, container: SSAValue, value: SSAValue)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    position: DenseArrayBase,
    container: SSAValue,
    value: SSAValue,
):
    super().__init__(
        operands=[container, value],
        properties={
            "position": position,
        },
        result_types=[container.type],
    )

UndefOp

Bases: IRDLOperation

See external documentation.

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class UndefOp(IRDLOperation):
    """
    See external [documentation](https://mlir.llvm.org/docs/Dialects/LLVM/#llvmmlirundef-mlirllvmundefop).
    """

    name = "llvm.mlir.undef"

    res = result_def(Attribute)

    traits = traits_def(NoMemoryEffect())

    def __init__(self, result_type: Attribute):
        super().__init__(result_types=[result_type])

name = 'llvm.mlir.undef' class-attribute instance-attribute

res = result_def(Attribute) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(result_type: Attribute)

Source code in xdsl/dialects/llvm.py

def __init__(self, result_type: Attribute):
    super().__init__(result_types=[result_type])

GlobalOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class GlobalOp(IRDLOperation):
    name = "llvm.mlir.global"

    global_type = prop_def()
    constant = opt_prop_def(UnitAttr)
    sym_name = prop_def(SymbolNameConstraint())
    linkage = prop_def(LinkageAttr)
    dso_local = opt_prop_def(UnitAttr)
    thread_local_ = opt_prop_def(UnitAttr)
    visibility_ = opt_prop_def(IntegerAttr[IntegerType])
    value = opt_prop_def()
    alignment = opt_prop_def(IntegerAttr)
    addr_space = prop_def(IntegerAttr)
    unnamed_addr = opt_prop_def(IntegerAttr)
    section = opt_prop_def(StringAttr)

    # This always needs an empty region as it is in the top level module definition
    body = region_def()

    traits = traits_def(SymbolOpInterface())

    def __init__(
        self,
        global_type: Attribute,
        sym_name: str | StringAttr,
        linkage: str | LinkageAttr,
        addr_space: int = 0,
        constant: bool | None = None,
        dso_local: bool | None = None,
        thread_local_: bool | None = None,
        value: Attribute | None = None,
        alignment: int | None = None,
        unnamed_addr: int | None = None,
        section: str | StringAttr | None = None,
        body: Region | None = None,
    ):
        if isinstance(sym_name, str):
            sym_name = StringAttr(sym_name)

        if isinstance(linkage, str):
            linkage = LinkageAttr(linkage)

        props: dict[str, Attribute] = {
            "global_type": global_type,
            "sym_name": sym_name,
            "linkage": linkage,
            "addr_space": IntegerAttr(addr_space, 32),
        }

        if constant is not None and constant:
            props["constant"] = UnitAttr()

        if dso_local is not None and dso_local:
            props["dso_local"] = UnitAttr()

        if thread_local_ is not None and thread_local_:
            props["thread_local_"] = UnitAttr()

        if value is not None:
            props["value"] = value

        if alignment is not None:
            props["alignment"] = IntegerAttr(alignment, 64)

        if unnamed_addr is not None:
            props["unnamed_addr"] = IntegerAttr(unnamed_addr, 64)

        if section is not None:
            if isinstance(section, str):
                section = StringAttr(section)
            props["section"] = section

        if body is None:
            body = Region()

        super().__init__(properties=props, regions=(body,))

name = 'llvm.mlir.global' class-attribute instance-attribute

global_type = prop_def() class-attribute instance-attribute

constant = opt_prop_def(UnitAttr) class-attribute instance-attribute

sym_name = prop_def(SymbolNameConstraint()) class-attribute instance-attribute

linkage = prop_def(LinkageAttr) class-attribute instance-attribute

dso_local = opt_prop_def(UnitAttr) class-attribute instance-attribute

thread_local_ = opt_prop_def(UnitAttr) class-attribute instance-attribute

visibility_ = opt_prop_def(IntegerAttr[IntegerType]) class-attribute instance-attribute

value = opt_prop_def() class-attribute instance-attribute

alignment = opt_prop_def(IntegerAttr) class-attribute instance-attribute

addr_space = prop_def(IntegerAttr) class-attribute instance-attribute

unnamed_addr = opt_prop_def(IntegerAttr) class-attribute instance-attribute

section = opt_prop_def(StringAttr) class-attribute instance-attribute

body = region_def() class-attribute instance-attribute

traits = traits_def(SymbolOpInterface()) class-attribute instance-attribute

__init__(global_type: Attribute, sym_name: str | StringAttr, linkage: str | LinkageAttr, addr_space: int = 0, constant: bool | None = None, dso_local: bool | None = None, thread_local_: bool | None = None, value: Attribute | None = None, alignment: int | None = None, unnamed_addr: int | None = None, section: str | StringAttr | None = None, body: Region | None = None)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    global_type: Attribute,
    sym_name: str | StringAttr,
    linkage: str | LinkageAttr,
    addr_space: int = 0,
    constant: bool | None = None,
    dso_local: bool | None = None,
    thread_local_: bool | None = None,
    value: Attribute | None = None,
    alignment: int | None = None,
    unnamed_addr: int | None = None,
    section: str | StringAttr | None = None,
    body: Region | None = None,
):
    if isinstance(sym_name, str):
        sym_name = StringAttr(sym_name)

    if isinstance(linkage, str):
        linkage = LinkageAttr(linkage)

    props: dict[str, Attribute] = {
        "global_type": global_type,
        "sym_name": sym_name,
        "linkage": linkage,
        "addr_space": IntegerAttr(addr_space, 32),
    }

    if constant is not None and constant:
        props["constant"] = UnitAttr()

    if dso_local is not None and dso_local:
        props["dso_local"] = UnitAttr()

    if thread_local_ is not None and thread_local_:
        props["thread_local_"] = UnitAttr()

    if value is not None:
        props["value"] = value

    if alignment is not None:
        props["alignment"] = IntegerAttr(alignment, 64)

    if unnamed_addr is not None:
        props["unnamed_addr"] = IntegerAttr(unnamed_addr, 64)

    if section is not None:
        if isinstance(section, str):
            section = StringAttr(section)
        props["section"] = section

    if body is None:
        body = Region()

    super().__init__(properties=props, regions=(body,))

AddressOfOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class AddressOfOp(IRDLOperation):
    name = "llvm.mlir.addressof"

    global_name = prop_def(SymbolRefAttr)
    result = result_def(LLVMPointerType)

    traits = traits_def(NoMemoryEffect())

    def __init__(
        self,
        global_name: str | StringAttr | SymbolRefAttr,
        result_type: LLVMPointerType,
    ):
        if isinstance(global_name, StringAttr | str):
            global_name = SymbolRefAttr(global_name)

        super().__init__(
            properties={"global_name": global_name}, result_types=[result_type]
        )

name = 'llvm.mlir.addressof' class-attribute instance-attribute

global_name = prop_def(SymbolRefAttr) class-attribute instance-attribute

result = result_def(LLVMPointerType) class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(global_name: str | StringAttr | SymbolRefAttr, result_type: LLVMPointerType)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    global_name: str | StringAttr | SymbolRefAttr,
    result_type: LLVMPointerType,
):
    if isinstance(global_name, StringAttr | str):
        global_name = SymbolRefAttr(global_name)

    super().__init__(
        properties={"global_name": global_name}, result_types=[result_type]
    )

CallingConventionAttr

Bases: ParametrizedAttribute

LLVM Calling convention, default is ccc.

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition
class CallingConventionAttr(ParametrizedAttribute):
    """
    LLVM Calling convention, default is ccc.
    """

    name = "llvm.cconv"

    convention: StringAttr

    @property
    def cconv_name(self) -> str:
        return self.convention.data

    def __init__(self, conv: str):
        super().__init__(StringAttr(conv))

    def _verify(self):
        if self.cconv_name not in LLVM_CALLING_CONVS:
            raise VerifyException(f'Invalid calling convention "{self.cconv_name}"')

    def print_parameters(self, printer: Printer) -> None:
        printer.print_string("<" + self.convention.data + ">")

    @classmethod
    def parse_parameters(cls, parser: AttrParser) -> list[Attribute]:
        parser.parse_characters("<")
        for conv in LLVM_CALLING_CONVS:
            if parser.parse_optional_characters(conv) is not None:
                parser.parse_characters(">")
                return [StringAttr(conv)]
        parser.raise_error("Unknown calling convention")

name = 'llvm.cconv' class-attribute instance-attribute

convention: StringAttr instance-attribute

cconv_name: str property

__init__(conv: str)

Source code in xdsl/dialects/llvm.py

def __init__(self, conv: str):
    super().__init__(StringAttr(conv))

print_parameters(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print_parameters(self, printer: Printer) -> None:
    printer.print_string("<" + self.convention.data + ">")

parse_parameters(parser: AttrParser) -> list[Attribute] classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse_parameters(cls, parser: AttrParser) -> list[Attribute]:
    parser.parse_characters("<")
    for conv in LLVM_CALLING_CONVS:
        if parser.parse_optional_characters(conv) is not None:
            parser.parse_characters(">")
            return [StringAttr(conv)]
    parser.raise_error("Unknown calling convention")

FramePointerKind

Bases: StrEnum

Source code in xdsl/dialects/llvm.py

class FramePointerKind(StrEnum):
    NONE = "none"
    NONLEAF = "non-leaf"
    ALL = "all"
    RESERVED = "reserved"

NONE = 'none' class-attribute instance-attribute

NONLEAF = 'non-leaf' class-attribute instance-attribute

ALL = 'all' class-attribute instance-attribute

RESERVED = 'reserved' class-attribute instance-attribute

FramePointerKindAttr dataclass

Bases: EnumAttribute[FramePointerKind]

LLVM Frame Pointer Kind.

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition
class FramePointerKindAttr(EnumAttribute[FramePointerKind]):
    """LLVM Frame Pointer Kind."""

    name = "llvm.framePointerKind"

    def print_parameter(self, printer: Printer) -> None:
        with printer.in_angle_brackets():
            super().print_parameter(printer)

    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> FramePointerKind:
        with parser.in_angle_brackets():
            return super().parse_parameter(parser)

name = 'llvm.framePointerKind' class-attribute instance-attribute

print_parameter(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print_parameter(self, printer: Printer) -> None:
    with printer.in_angle_brackets():
        super().print_parameter(printer)

parse_parameter(parser: AttrParser) -> FramePointerKind classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse_parameter(cls, parser: AttrParser) -> FramePointerKind:
    with parser.in_angle_brackets():
        return super().parse_parameter(parser)

TargetFeaturesAttr dataclass

Bases: ParametrizedAttribute

Represents the LLVM target features as a list that can be checked within passes/rewrites.

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition
class TargetFeaturesAttr(ParametrizedAttribute):
    """
    Represents the LLVM target features as a list that can be checked within
    passes/rewrites.
    """

    name = "llvm.target_features"

    features: ArrayAttr[StringAttr]

    def verify(self):
        for feature in self.features:
            if not feature.data.startswith(("-", "+")):
                raise VerifyException("target features must start with '+' or '-'")

name = 'llvm.target_features' class-attribute instance-attribute

features: ArrayAttr[StringAttr] instance-attribute

verify()

Source code in xdsl/dialects/llvm.py

def verify(self):
    for feature in self.features:
        if not feature.data.startswith(("-", "+")):
            raise VerifyException("target features must start with '+' or '-'")

FuncOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class FuncOp(IRDLOperation):
    name = "llvm.func"

    body = region_def()
    sym_name = prop_def(SymbolNameConstraint())
    function_type = prop_def(LLVMFunctionType)
    CConv = prop_def(CallingConventionAttr)
    linkage = prop_def(LinkageAttr)
    sym_visibility = opt_prop_def(StringAttr)
    visibility_ = prop_def(IntegerAttr[IntegerType])

    # The following properties are not yet verified by the xDSL verifier, but
    # are verified to at least allow the IR to be parsed and printed correctly.
    arg_attrs = opt_prop_def(ArrayAttr[DictionaryAttr])
    frame_pointer = opt_prop_def(FramePointerKindAttr)
    no_inline = opt_prop_def(UnitAttr)
    no_unwind = opt_prop_def(UnitAttr)
    optimize_none = opt_prop_def(UnitAttr)
    passthrough = opt_prop_def(ArrayAttr[Attribute])
    target_cpu = opt_prop_def(StringAttr)
    target_features = opt_prop_def(TargetFeaturesAttr)
    tune_cpu = opt_prop_def(StringAttr)
    unnamed_addr = opt_prop_def(IntegerAttr)

    def __init__(
        self,
        sym_name: str | StringAttr,
        function_type: LLVMFunctionType,
        linkage: LinkageAttr = LinkageAttr("internal"),
        cconv: CallingConventionAttr = CallingConventionAttr("ccc"),
        visibility: int | IntegerAttr[IntegerType] = 0,
        sym_visibility: str | StringAttr | None = None,
        body: Region | None = None,
        other_props: dict[str, Attribute | None] | None = None,
    ):
        if isinstance(sym_name, str):
            sym_name = StringAttr(sym_name)
        if isinstance(visibility, int):
            visibility = IntegerAttr.from_int_and_width(visibility, 64)
        if body is None:
            body = Region([])
        if isinstance(sym_visibility, str):
            sym_visibility = StringAttr(sym_visibility)
        properties = other_props if other_props is not None else {}
        properties.update(
            {
                "sym_name": sym_name,
                "function_type": function_type,
                "CConv": cconv,
                "linkage": linkage,
                "visibility_": visibility,
                "sym_visibility": sym_visibility,
            }
        )
        super().__init__(
            operands=[],
            regions=[body],
            properties=properties,
        )

name = 'llvm.func' class-attribute instance-attribute

body = region_def() class-attribute instance-attribute

sym_name = prop_def(SymbolNameConstraint()) class-attribute instance-attribute

function_type = prop_def(LLVMFunctionType) class-attribute instance-attribute

CConv = prop_def(CallingConventionAttr) class-attribute instance-attribute

linkage = prop_def(LinkageAttr) class-attribute instance-attribute

sym_visibility = opt_prop_def(StringAttr) class-attribute instance-attribute

visibility_ = prop_def(IntegerAttr[IntegerType]) class-attribute instance-attribute

arg_attrs = opt_prop_def(ArrayAttr[DictionaryAttr]) class-attribute instance-attribute

frame_pointer = opt_prop_def(FramePointerKindAttr) class-attribute instance-attribute

no_inline = opt_prop_def(UnitAttr) class-attribute instance-attribute

no_unwind = opt_prop_def(UnitAttr) class-attribute instance-attribute

optimize_none = opt_prop_def(UnitAttr) class-attribute instance-attribute

passthrough = opt_prop_def(ArrayAttr[Attribute]) class-attribute instance-attribute

target_cpu = opt_prop_def(StringAttr) class-attribute instance-attribute

target_features = opt_prop_def(TargetFeaturesAttr) class-attribute instance-attribute

tune_cpu = opt_prop_def(StringAttr) class-attribute instance-attribute

unnamed_addr = opt_prop_def(IntegerAttr) class-attribute instance-attribute

__init__(sym_name: str | StringAttr, function_type: LLVMFunctionType, linkage: LinkageAttr = LinkageAttr('internal'), cconv: CallingConventionAttr = CallingConventionAttr('ccc'), visibility: int | IntegerAttr[IntegerType] = 0, sym_visibility: str | StringAttr | None = None, body: Region | None = None, other_props: dict[str, Attribute | None] | None = None)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    sym_name: str | StringAttr,
    function_type: LLVMFunctionType,
    linkage: LinkageAttr = LinkageAttr("internal"),
    cconv: CallingConventionAttr = CallingConventionAttr("ccc"),
    visibility: int | IntegerAttr[IntegerType] = 0,
    sym_visibility: str | StringAttr | None = None,
    body: Region | None = None,
    other_props: dict[str, Attribute | None] | None = None,
):
    if isinstance(sym_name, str):
        sym_name = StringAttr(sym_name)
    if isinstance(visibility, int):
        visibility = IntegerAttr.from_int_and_width(visibility, 64)
    if body is None:
        body = Region([])
    if isinstance(sym_visibility, str):
        sym_visibility = StringAttr(sym_visibility)
    properties = other_props if other_props is not None else {}
    properties.update(
        {
            "sym_name": sym_name,
            "function_type": function_type,
            "CConv": cconv,
            "linkage": linkage,
            "visibility_": visibility,
            "sym_visibility": sym_visibility,
        }
    )
    super().__init__(
        operands=[],
        regions=[body],
        properties=properties,
    )

ReturnOp

Bases: IRDLOperation

See external documentation.

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class ReturnOp(IRDLOperation):
    """
    See external [documentation](https://mlir.llvm.org/docs/Dialects/LLVM/#llvmreturn-mlirllvmreturnop).
    """

    name = "llvm.return"

    arg = opt_operand_def(Attribute)

    traits = traits_def(IsTerminator(), NoMemoryEffect())

    def __init__(self, value: SSAValue | None = None):
        super().__init__(operands=[value])

name = 'llvm.return' class-attribute instance-attribute

arg = opt_operand_def(Attribute) class-attribute instance-attribute

traits = traits_def(IsTerminator(), NoMemoryEffect()) class-attribute instance-attribute

__init__(value: SSAValue | None = None)

Source code in xdsl/dialects/llvm.py

def __init__(self, value: SSAValue | None = None):
    super().__init__(operands=[value])

ConstantOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class ConstantOp(IRDLOperation):
    name = "llvm.mlir.constant"
    result = result_def(Attribute)
    value = prop_def()

    traits = traits_def(NoMemoryEffect())

    def __init__(self, value: Attribute, value_type: Attribute):
        super().__init__(properties={"value": value}, result_types=[value_type])

    @classmethod
    def parse_value(cls, parser: Parser) -> Attribute:
        b = parser.parse_optional_boolean()
        if b is not None:
            return IntegerAttr.from_bool(b)
        attr = parser.parse_optional_attribute()
        if attr:
            return attr
        return IntegerAttr(parser.parse_integer(), 64)

    @classmethod
    def parse(cls, parser: Parser):
        parser.parse_characters("(")
        value = cls.parse_value(parser)
        parser.parse_characters(")")
        parser.parse_characters(":")
        value_type = parser.parse_type()
        return cls(value, value_type)

    def print(self, printer: Printer) -> None:
        with printer.in_parens():
            if isa(self.value, IntegerAttr) and self.result.type == IntegerType(64):
                self.value.print_without_type(printer)
            else:
                printer.print_attribute(self.value)
        printer.print_string(" : ")
        printer.print_attribute(self.result.type)

name = 'llvm.mlir.constant' class-attribute instance-attribute

result = result_def(Attribute) class-attribute instance-attribute

value = prop_def() class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

__init__(value: Attribute, value_type: Attribute)

Source code in xdsl/dialects/llvm.py

def __init__(self, value: Attribute, value_type: Attribute):
    super().__init__(properties={"value": value}, result_types=[value_type])

parse_value(parser: Parser) -> Attribute classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse_value(cls, parser: Parser) -> Attribute:
    b = parser.parse_optional_boolean()
    if b is not None:
        return IntegerAttr.from_bool(b)
    attr = parser.parse_optional_attribute()
    if attr:
        return attr
    return IntegerAttr(parser.parse_integer(), 64)

parse(parser: Parser) classmethod

Source code in xdsl/dialects/llvm.py

@classmethod
def parse(cls, parser: Parser):
    parser.parse_characters("(")
    value = cls.parse_value(parser)
    parser.parse_characters(")")
    parser.parse_characters(":")
    value_type = parser.parse_type()
    return cls(value, value_type)

print(printer: Printer) -> None

Source code in xdsl/dialects/llvm.py

def print(self, printer: Printer) -> None:
    with printer.in_parens():
        if isa(self.value, IntegerAttr) and self.result.type == IntegerType(64):
            self.value.print_without_type(printer)
        else:
            printer.print_attribute(self.value)
    printer.print_string(" : ")
    printer.print_attribute(self.result.type)

FastMathAttr dataclass

Bases: FastMathAttrBase

Source code in xdsl/dialects/llvm.py

@irdl_attr_definition(init=False)
class FastMathAttr(FastMathAttrBase):
    name = "llvm.fastmath"

name = 'llvm.fastmath' class-attribute instance-attribute

CallIntrinsicOp

Bases: IRDLOperation

See external documentation.

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class CallIntrinsicOp(IRDLOperation):
    """
    See external [documentation](https://mlir.llvm.org/docs/Dialects/LLVM/#llvmcall_intrinsic-mlirllvmcallintrinsicop).
    """

    name = "llvm.call_intrinsic"

    fastmathFlags = opt_prop_def(FastMathAttr)
    intrin = prop_def(StringAttr)
    op_bundle_sizes = prop_def(DenseArrayBase.constr(i32))
    args = var_operand_def()
    op_bundle_operands = var_operand_def()
    ress = opt_result_def()

    irdl_options = (AttrSizedOperandSegments(as_property=True),)

    def __init__(
        self,
        intrin: StringAttr | str,
        args: Sequence[SSAValue],
        result_types: Sequence[Attribute],
        *,
        op_bundle_sizes: DenseArrayBase,
        op_bundle_operands: Sequence[SSAValue] = (),
    ):
        if isinstance(intrin, str):
            intrin = StringAttr(intrin)
        super().__init__(
            operands=[args, op_bundle_operands],
            result_types=(result_types,),
            properties={
                "intrin": intrin,
                "op_bundle_sizes": op_bundle_sizes,
            },
        )

name = 'llvm.call_intrinsic' class-attribute instance-attribute

fastmathFlags = opt_prop_def(FastMathAttr) class-attribute instance-attribute

intrin = prop_def(StringAttr) class-attribute instance-attribute

op_bundle_sizes = prop_def(DenseArrayBase.constr(i32)) class-attribute instance-attribute

args = var_operand_def() class-attribute instance-attribute

op_bundle_operands = var_operand_def() class-attribute instance-attribute

ress = opt_result_def() class-attribute instance-attribute

irdl_options = (AttrSizedOperandSegments(as_property=True),) class-attribute instance-attribute

__init__(intrin: StringAttr | str, args: Sequence[SSAValue], result_types: Sequence[Attribute], *, op_bundle_sizes: DenseArrayBase, op_bundle_operands: Sequence[SSAValue] = ())

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    intrin: StringAttr | str,
    args: Sequence[SSAValue],
    result_types: Sequence[Attribute],
    *,
    op_bundle_sizes: DenseArrayBase,
    op_bundle_operands: Sequence[SSAValue] = (),
):
    if isinstance(intrin, str):
        intrin = StringAttr(intrin)
    super().__init__(
        operands=[args, op_bundle_operands],
        result_types=(result_types,),
        properties={
            "intrin": intrin,
            "op_bundle_sizes": op_bundle_sizes,
        },
    )

CallOp

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class CallOp(IRDLOperation):
    name = "llvm.call"

    args = var_operand_def()
    op_bundle_operands = var_operand_def()

    callee = opt_prop_def(SymbolRefAttr)
    var_callee_type = opt_prop_def(LLVMFunctionType)
    fastmathFlags = prop_def(FastMathAttr, default_value=FastMathAttr("none"))
    CConv = prop_def(CallingConventionAttr, default_value=CallingConventionAttr("ccc"))
    op_bundle_sizes = prop_def(
        DenseArrayBase.constr(i32),
        default_value=DenseArrayBase.from_list(i32, ()),
    )
    TailCallKind = prop_def(
        TailCallKindAttr, default_value=TailCallKindAttr(TailCallKind.NONE)
    )
    returned = opt_result_def()

    irdl_options = (AttrSizedOperandSegments(as_property=True),)

    def __init__(
        self,
        callee: str | SymbolRefAttr | StringAttr,
        *args: SSAValue | Operation,
        op_bundle_sizes: DenseArrayBase = DenseArrayBase.from_list(i32, ()),
        op_bundle_operands: tuple[SSAValue, ...] = (),
        return_type: Attribute | None = None,
        calling_convention: CallingConventionAttr = CallingConventionAttr("ccc"),
        fastmath: FastMathAttr = FastMathAttr(None),
        variadic_args: int = 0,
    ):
        if isinstance(callee, str):
            callee = SymbolRefAttr(callee)
        op_result_type = [return_type]
        if return_type is None:
            return_type = LLVMVoidType()
        input_types = [
            SSAValue.get(arg).type for arg in args[: len(args) - variadic_args]
        ]
        if variadic_args:
            var_callee_type = LLVMFunctionType(
                input_types, return_type, bool(variadic_args)
            )
        else:
            var_callee_type = None
        super().__init__(
            operands=[args, op_bundle_operands],
            properties={
                "callee": callee,
                "var_callee_type": var_callee_type,
                "fastmathFlags": fastmath,
                "CConv": calling_convention,
                "op_bundle_sizes": op_bundle_sizes,
            },
            result_types=op_result_type,
        )

name = 'llvm.call' class-attribute instance-attribute

args = var_operand_def() class-attribute instance-attribute

op_bundle_operands = var_operand_def() class-attribute instance-attribute

callee = opt_prop_def(SymbolRefAttr) class-attribute instance-attribute

var_callee_type = opt_prop_def(LLVMFunctionType) class-attribute instance-attribute

fastmathFlags = prop_def(FastMathAttr, default_value=(FastMathAttr('none'))) class-attribute instance-attribute

CConv = prop_def(CallingConventionAttr, default_value=(CallingConventionAttr('ccc'))) class-attribute instance-attribute

op_bundle_sizes = prop_def(DenseArrayBase.constr(i32), default_value=(DenseArrayBase.from_list(i32, ()))) class-attribute instance-attribute

TailCallKind = prop_def(TailCallKindAttr, default_value=(TailCallKindAttr(TailCallKind.NONE))) class-attribute instance-attribute

returned = opt_result_def() class-attribute instance-attribute

irdl_options = (AttrSizedOperandSegments(as_property=True),) class-attribute instance-attribute

__init__(callee: str | SymbolRefAttr | StringAttr, *args: SSAValue | Operation, op_bundle_sizes: DenseArrayBase = DenseArrayBase.from_list(i32, ()), op_bundle_operands: tuple[SSAValue, ...] = (), return_type: Attribute | None = None, calling_convention: CallingConventionAttr = CallingConventionAttr('ccc'), fastmath: FastMathAttr = FastMathAttr(None), variadic_args: int = 0)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    callee: str | SymbolRefAttr | StringAttr,
    *args: SSAValue | Operation,
    op_bundle_sizes: DenseArrayBase = DenseArrayBase.from_list(i32, ()),
    op_bundle_operands: tuple[SSAValue, ...] = (),
    return_type: Attribute | None = None,
    calling_convention: CallingConventionAttr = CallingConventionAttr("ccc"),
    fastmath: FastMathAttr = FastMathAttr(None),
    variadic_args: int = 0,
):
    if isinstance(callee, str):
        callee = SymbolRefAttr(callee)
    op_result_type = [return_type]
    if return_type is None:
        return_type = LLVMVoidType()
    input_types = [
        SSAValue.get(arg).type for arg in args[: len(args) - variadic_args]
    ]
    if variadic_args:
        var_callee_type = LLVMFunctionType(
            input_types, return_type, bool(variadic_args)
        )
    else:
        var_callee_type = None
    super().__init__(
        operands=[args, op_bundle_operands],
        properties={
            "callee": callee,
            "var_callee_type": var_callee_type,
            "fastmathFlags": fastmath,
            "CConv": calling_convention,
            "op_bundle_sizes": op_bundle_sizes,
        },
        result_types=op_result_type,
    )

ZeroOp dataclass

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class ZeroOp(IRDLOperation):
    name = "llvm.mlir.zero"

    assembly_format = "attr-dict `:` type($res)"

    traits = traits_def(NoMemoryEffect())

    res = result_def(LLVMTypeConstr)

name = 'llvm.mlir.zero' class-attribute instance-attribute

assembly_format = 'attr-dict `:` type($res)' class-attribute instance-attribute

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

res = result_def(LLVMTypeConstr) class-attribute instance-attribute

GenericCastOp

Bases: IRDLOperation, ABC

Source code in xdsl/dialects/llvm.py

class GenericCastOp(IRDLOperation, ABC):
    arg = operand_def(Attribute)
    """
    LLVM-compatible non-aggregate type
    """

    result = result_def(Attribute)
    """
    LLVM-compatible non-aggregate type
    """

    traits = traits_def(NoMemoryEffect())

    assembly_format = "$arg attr-dict `:` type($arg) `to` type($result)"

    def __init__(self, val: Operation | SSAValue, res_type: Attribute):
        super().__init__(
            operands=[SSAValue.get(val)],
            result_types=[res_type],
        )

arg = operand_def(Attribute) class-attribute instance-attribute

LLVM-compatible non-aggregate type

result = result_def(Attribute) class-attribute instance-attribute

LLVM-compatible non-aggregate type

traits = traits_def(NoMemoryEffect()) class-attribute instance-attribute

assembly_format = '$arg attr-dict `:` type($arg) `to` type($result)' class-attribute instance-attribute

__init__(val: Operation | SSAValue, res_type: Attribute)

Source code in xdsl/dialects/llvm.py

def __init__(self, val: Operation | SSAValue, res_type: Attribute):
    super().__init__(
        operands=[SSAValue.get(val)],
        result_types=[res_type],
    )

AbstractFloatArithOp

Bases: IRDLOperation, ABC

Source code in xdsl/dialects/llvm.py

class AbstractFloatArithOp(IRDLOperation, ABC):
    T: ClassVar = VarConstraint("T", AnyFloatConstr | VectorType.constr(AnyFloatConstr))

    lhs = operand_def(T)
    rhs = operand_def(T)
    res = result_def(T)

    fastmathFlags = prop_def(FastMathAttr, default_value=FastMathAttr(None))

    traits = traits_def(Pure(), SameOperandsAndResultType())

    assembly_format = "$lhs `,` $rhs attr-dict `:` type($lhs)"

    irdl_options = (ParsePropInAttrDict(),)

    def __init__(
        self,
        lhs: SSAValue | Operation,
        rhs: SSAValue | Operation,
        fast_math: FastMathAttr | FastMathFlag | None = None,
        attrs: dict[str, Attribute] | None = None,
    ):
        if isinstance(fast_math, FastMathFlag | str | None):
            fast_math = FastMathAttr(fast_math)

        super().__init__(
            operands=[lhs, rhs],
            result_types=[SSAValue.get(lhs).type],
            properties={"fastmathFlags": fast_math},
            attributes=attrs,
        )

T: ClassVar = VarConstraint('T', AnyFloatConstr | VectorType.constr(AnyFloatConstr)) class-attribute instance-attribute

lhs = operand_def(T) class-attribute instance-attribute

rhs = operand_def(T) class-attribute instance-attribute

res = result_def(T) class-attribute instance-attribute

fastmathFlags = prop_def(FastMathAttr, default_value=(FastMathAttr(None))) class-attribute instance-attribute

traits = traits_def(Pure(), SameOperandsAndResultType()) class-attribute instance-attribute

assembly_format = '$lhs `,` $rhs attr-dict `:` type($lhs)' class-attribute instance-attribute

irdl_options = (ParsePropInAttrDict(),) class-attribute instance-attribute

__init__(lhs: SSAValue | Operation, rhs: SSAValue | Operation, fast_math: FastMathAttr | FastMathFlag | None = None, attrs: dict[str, Attribute] | None = None)

Source code in xdsl/dialects/llvm.py

def __init__(
    self,
    lhs: SSAValue | Operation,
    rhs: SSAValue | Operation,
    fast_math: FastMathAttr | FastMathFlag | None = None,
    attrs: dict[str, Attribute] | None = None,
):
    if isinstance(fast_math, FastMathFlag | str | None):
        fast_math = FastMathAttr(fast_math)

    super().__init__(
        operands=[lhs, rhs],
        result_types=[SSAValue.get(lhs).type],
        properties={"fastmathFlags": fast_math},
        attributes=attrs,
    )

FAddOp dataclass

Bases: AbstractFloatArithOp

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class FAddOp(AbstractFloatArithOp):
    name = "llvm.fadd"

name = 'llvm.fadd' class-attribute instance-attribute

FMulOp dataclass

Bases: AbstractFloatArithOp

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class FMulOp(AbstractFloatArithOp):
    name = "llvm.fmul"

name = 'llvm.fmul' class-attribute instance-attribute

FDivOp dataclass

Bases: AbstractFloatArithOp

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class FDivOp(AbstractFloatArithOp):
    name = "llvm.fdiv"

name = 'llvm.fdiv' class-attribute instance-attribute

FSubOp dataclass

Bases: AbstractFloatArithOp

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class FSubOp(AbstractFloatArithOp):
    name = "llvm.fsub"

name = 'llvm.fsub' class-attribute instance-attribute

FRemOp dataclass

Bases: AbstractFloatArithOp

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class FRemOp(AbstractFloatArithOp):
    name = "llvm.frem"

name = 'llvm.frem' class-attribute instance-attribute

BitcastOp dataclass

Bases: GenericCastOp

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class BitcastOp(GenericCastOp):
    name = "llvm.bitcast"

name = 'llvm.bitcast' class-attribute instance-attribute

SIToFPOp dataclass

Bases: GenericCastOp

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class SIToFPOp(GenericCastOp):
    name = "llvm.sitofp"

name = 'llvm.sitofp' class-attribute instance-attribute

FPExtOp dataclass

Bases: GenericCastOp

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class FPExtOp(GenericCastOp):
    name = "llvm.fpext"

name = 'llvm.fpext' class-attribute instance-attribute

UnreachableOp dataclass

Bases: IRDLOperation

Source code in xdsl/dialects/llvm.py

@irdl_op_definition
class UnreachableOp(IRDLOperation):
    name = "llvm.unreachable"

    traits = traits_def(IsTerminator())
    assembly_format = "attr-dict"

name = 'llvm.unreachable' class-attribute instance-attribute

traits = traits_def(IsTerminator()) class-attribute instance-attribute

assembly_format = 'attr-dict' class-attribute instance-attribute

parse_llvm_type(parser: AttrParser) -> Attribute

Source code in xdsl/dialects/llvm.py

def parse_llvm_type(parser: AttrParser) -> Attribute:
    if (l := _parse_optional_llvm_type(parser)) is not None:
        return l
    return parser.parse_attribute()

parse_optional_llvm_type(parser: AttrParser) -> Attribute | None

Source code in xdsl/dialects/llvm.py

def parse_optional_llvm_type(parser: AttrParser) -> Attribute | None:
    if (l := _parse_optional_llvm_type(parser)) is not None:
        return l
    return parser.parse_optional_attribute()