Bigint

bigint

Dialect for unlimited precision integers with Python int semantics.

bigint = BigIntegerType() module-attribute

BigInt = Dialect('bigint', [ConstantOp, TruncateToIntOp, AddOp, SubOp, MulOp, FloorDivOp, ModOp, PowOp, LShiftOp, RShiftOp, BitOrOp, BitXorOp, BitAndOp, DivOp, EqOp, NeqOp, GtOp, GteOp, LtOp, LteOp], [BigIntegerType]) module-attribute

BigIntegerType dataclass

Bases: ParametrizedAttribute, TypeAttribute

Type for unlimited precision integers, with Python int semantics.

Source code in xdsl/dialects/bigint.py

@irdl_attr_definition
class BigIntegerType(ParametrizedAttribute, TypeAttribute):
    """Type for unlimited precision integers, with Python `int` semantics."""

    name = "bigint.bigint"

name = 'bigint.bigint' class-attribute instance-attribute

BinaryOperation

Bases: IRDLOperation, ABC

Binary operation where all operands and results are bigints.

Source code in xdsl/dialects/bigint.py

class BinaryOperation(IRDLOperation, abc.ABC):
    """Binary operation where all operands and results are `bigint`s."""

    lhs = operand_def(bigint)
    rhs = operand_def(bigint)
    result = result_def(bigint)

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

    def __init__(
        self,
        operand1: Operation | SSAValue,
        operand2: Operation | SSAValue,
    ):
        super().__init__(operands=[operand1, operand2], result_types=[bigint])

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

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

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

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

__init__(operand1: Operation | SSAValue, operand2: Operation | SSAValue)

Source code in xdsl/dialects/bigint.py

def __init__(
    self,
    operand1: Operation | SSAValue,
    operand2: Operation | SSAValue,
):
    super().__init__(operands=[operand1, operand2], result_types=[bigint])

ConstantOp

Bases: IRDLOperation

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class ConstantOp(IRDLOperation):
    name = "bigint.constant"
    result = result_def(bigint)
    value = prop_def(IntAttr)

    traits = traits_def(ConstantLike(), HasFolder(), Pure())

    @classmethod
    def parse(cls, parser: Parser):
        integer = parser.parse_integer()
        attrDict = parser.parse_optional_attr_dict()
        return cls(value=IntAttr(integer), attrs=attrDict)

    def print(self, printer: Printer):
        printer.print_string(" ")
        printer.print_int(self.value.data)
        if self.attributes:
            printer.print_string(" ")
            printer.print_attr_dict(self.attributes)

    def __init__(
        self,
        value: IntAttr | int,
        attrs: dict[str, Attribute] | None = None,
    ):
        if isinstance(value, int):
            value = IntAttr(value)

        super().__init__(
            operands=[],
            result_types=[bigint],
            properties={"value": value},
            attributes=attrs,
        )

    def fold(self) -> Sequence[SSAValue | Attribute] | None:
        return (self.value,)

name = 'bigint.constant' class-attribute instance-attribute

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

value = prop_def(IntAttr) class-attribute instance-attribute

traits = traits_def(ConstantLike(), HasFolder(), Pure()) class-attribute instance-attribute

parse(parser: Parser) classmethod

Source code in xdsl/dialects/bigint.py

@classmethod
def parse(cls, parser: Parser):
    integer = parser.parse_integer()
    attrDict = parser.parse_optional_attr_dict()
    return cls(value=IntAttr(integer), attrs=attrDict)

print(printer: Printer)

Source code in xdsl/dialects/bigint.py

def print(self, printer: Printer):
    printer.print_string(" ")
    printer.print_int(self.value.data)
    if self.attributes:
        printer.print_string(" ")
        printer.print_attr_dict(self.attributes)

__init__(value: IntAttr | int, attrs: dict[str, Attribute] | None = None)

Source code in xdsl/dialects/bigint.py

def __init__(
    self,
    value: IntAttr | int,
    attrs: dict[str, Attribute] | None = None,
):
    if isinstance(value, int):
        value = IntAttr(value)

    super().__init__(
        operands=[],
        result_types=[bigint],
        properties={"value": value},
        attributes=attrs,
    )

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

Source code in xdsl/dialects/bigint.py

def fold(self) -> Sequence[SSAValue | Attribute] | None:
    return (self.value,)

TruncateToIntOp

Bases: IRDLOperation

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class TruncateToIntOp(IRDLOperation):
    name = "bigint.truncate_to_int"
    result = result_def(IntegerType)
    value = operand_def(bigint)

    traits = traits_def(Pure())

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

    def __init__(
        self,
        value: Operation | SSAValue,
        type: IntegerType = IntegerType(64),
    ):
        super().__init__(operands=[value], result_types=[type])

name = 'bigint.truncate_to_int' class-attribute instance-attribute

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

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

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

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

__init__(value: Operation | SSAValue, type: IntegerType = IntegerType(64))

Source code in xdsl/dialects/bigint.py

def __init__(
    self,
    value: Operation | SSAValue,
    type: IntegerType = IntegerType(64),
):
    super().__init__(operands=[value], result_types=[type])

AddOp dataclass

Bases: BinaryOperation

Add two bigints.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class AddOp(BinaryOperation):
    """Add two `bigint`s."""

    name = "bigint.add"

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

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

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

SubOp dataclass

Bases: BinaryOperation

Subtract two bigints.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class SubOp(BinaryOperation):
    """Subtract two `bigint`s."""

    name = "bigint.sub"

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

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

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

MulOp dataclass

Bases: BinaryOperation

Multiply two bigints.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class MulOp(BinaryOperation):
    """Multiply two `bigint`s."""

    name = "bigint.mul"

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

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

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

FloorDivOp dataclass

Bases: BinaryOperation

Floor divide two bigints, rounding down to the nearest integer.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class FloorDivOp(BinaryOperation):
    """Floor divide two `bigint`s, rounding down to the nearest integer."""

    name = "bigint.floordiv"

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

name = 'bigint.floordiv' class-attribute instance-attribute

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

ModOp dataclass

Bases: BinaryOperation

Modulo two bigints, taking the sign of the divisor.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class ModOp(BinaryOperation):
    """Modulo two `bigint`s, taking the sign of the divisor."""

    name = "bigint.mod"

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

name = 'bigint.mod' class-attribute instance-attribute

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

PowOp dataclass

Bases: BinaryOperation

Exponentiate a bigint by another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class PowOp(BinaryOperation):
    """Exponentiate a `bigint` by another."""

    name = "bigint.pow"

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

name = 'bigint.pow' class-attribute instance-attribute

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

LShiftOp dataclass

Bases: BinaryOperation

Left shift a bigint by another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class LShiftOp(BinaryOperation):
    """Left shift a `bigint` by another."""

    name = "bigint.lshift"

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

name = 'bigint.lshift' class-attribute instance-attribute

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

RShiftOp dataclass

Bases: BinaryOperation

Right shift a bigint by another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class RShiftOp(BinaryOperation):
    """Right shift a `bigint` by another."""

    name = "bigint.rshift"

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

name = 'bigint.rshift' class-attribute instance-attribute

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

BitOrOp dataclass

Bases: BinaryOperation

Bitwise OR a bigint with another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class BitOrOp(BinaryOperation):
    """Bitwise OR a `bigint` with another."""

    name = "bigint.bitor"

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

name = 'bigint.bitor' class-attribute instance-attribute

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

BitXorOp dataclass

Bases: BinaryOperation

Bitwise XOR a bigint with another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class BitXorOp(BinaryOperation):
    """Bitwise XOR a `bigint` with another."""

    name = "bigint.bitxor"

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

name = 'bigint.bitxor' class-attribute instance-attribute

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

BitAndOp dataclass

Bases: BinaryOperation

Bitwise AND a bigint with another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class BitAndOp(BinaryOperation):
    """Bitwise AND a `bigint` with another."""

    name = "bigint.bitand"

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

name = 'bigint.bitand' class-attribute instance-attribute

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

DivOp

Bases: IRDLOperation

Divide two bigints, yielding a 64-bit floating point type.

Note that this operation follows Python semantics, for example by rounding to minus infinity.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class DivOp(IRDLOperation):
    """Divide two `bigint`s, yielding a 64-bit floating point type.

    Note that this operation follows Python semantics, for example by rounding
    to minus infinity.
    """

    name = "bigint.div"

    lhs = operand_def(bigint)
    rhs = operand_def(bigint)
    result = result_def(f64)

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

    traits = traits_def(
        Pure(),
    )

    def __init__(
        self,
        operand1: Operation | SSAValue,
        operand2: Operation | SSAValue,
    ):
        super().__init__(operands=[operand1, operand2], result_types=[f64])

name = 'bigint.div' class-attribute instance-attribute

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

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

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

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

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

__init__(operand1: Operation | SSAValue, operand2: Operation | SSAValue)

Source code in xdsl/dialects/bigint.py

def __init__(
    self,
    operand1: Operation | SSAValue,
    operand2: Operation | SSAValue,
):
    super().__init__(operands=[operand1, operand2], result_types=[f64])

ComparisonOperation

Bases: IRDLOperation, ABC

Binary operation comparing two bigints and returning a boolean.

Source code in xdsl/dialects/bigint.py

class ComparisonOperation(IRDLOperation, abc.ABC):
    """Binary operation comparing two `bigint`s and returning a boolean."""

    lhs = operand_def(bigint)
    rhs = operand_def(bigint)
    result = result_def(i1)

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

    def __init__(
        self,
        operand1: Operation | SSAValue,
        operand2: Operation | SSAValue,
    ):
        super().__init__(operands=[operand1, operand2], result_types=[i1])

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

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

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

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

__init__(operand1: Operation | SSAValue, operand2: Operation | SSAValue)

Source code in xdsl/dialects/bigint.py

def __init__(
    self,
    operand1: Operation | SSAValue,
    operand2: Operation | SSAValue,
):
    super().__init__(operands=[operand1, operand2], result_types=[i1])

EqOp dataclass

Bases: ComparisonOperation

Check equality of two bigints.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class EqOp(ComparisonOperation):
    """Check equality of two `bigint`s."""

    name = "bigint.eq"

    traits = traits_def(
        Pure(),
        Commutative(),
    )

name = 'bigint.eq' class-attribute instance-attribute

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

NeqOp dataclass

Bases: ComparisonOperation

Check inequality of two bigints.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class NeqOp(ComparisonOperation):
    """Check inequality of two `bigint`s."""

    name = "bigint.neq"

    traits = traits_def(
        Pure(),
        Commutative(),
    )

name = 'bigint.neq' class-attribute instance-attribute

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

GtOp dataclass

Bases: ComparisonOperation

Check if one bigint is greater than another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class GtOp(ComparisonOperation):
    """Check if one `bigint` is greater than another."""

    name = "bigint.gt"

    traits = traits_def(
        Pure(),
    )

name = 'bigint.gt' class-attribute instance-attribute

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

GteOp dataclass

Bases: ComparisonOperation

Check if one bigint is greater than or equal to another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class GteOp(ComparisonOperation):
    """Check if one `bigint` is greater than or equal to another."""

    name = "bigint.gte"

    traits = traits_def(
        Pure(),
    )

name = 'bigint.gte' class-attribute instance-attribute

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

LtOp dataclass

Bases: ComparisonOperation

Check if one bigint is less than another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class LtOp(ComparisonOperation):
    """Check if one `bigint` is less than another."""

    name = "bigint.lt"

    traits = traits_def(
        Pure(),
    )

name = 'bigint.lt' class-attribute instance-attribute

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

LteOp dataclass

Bases: ComparisonOperation

Check if one bigint is less than or equal to another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class LteOp(ComparisonOperation):
    """Check if one `bigint` is less than or equal to another."""

    name = "bigint.lte"

    traits = traits_def(
        Pure(),
    )

name = 'bigint.lte' class-attribute instance-attribute

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