Skip to content

Arch

arch

ARCH_ATTR_NAME = 'x86.arch' module-attribute

Name of the module attribute recording the target this module is compiled for.

Set once at the top of a pipeline so that passes downstream do not each need their own arch option, in the same spirit as an LLVM module carrying its target triple.

UNKNOWN = X86Arch() module-attribute

AVX2 = AVX2Arch() module-attribute

AVX512 = AVX512Arch() module-attribute

X86Arch

Bases: Arch

Source code in xdsl/backend/x86/arch.py
class X86Arch(Arch):
    VECTOR_TYPES_BY_BITWIDTH: ClassVar[
        dict[int, type[x86.registers.X86VectorRegisterType]]
    ] = {128: x86.registers.SSERegisterType}
    """
    Supported vector type for a given vector size.
    """

    @staticmethod
    def name() -> str:
        return "unknown"

    @staticmethod
    def arch_for_name(name: str | None) -> X86Arch:
        if name is None:
            return UNKNOWN
        try:
            return _ARCH_BY_NAME[name]
        except KeyError:
            # Same reason as below: without `from None` the traceback leads with
            # `KeyError: 'sse9'` rather than with the diagnostic.
            raise DiagnosticException(
                f"Unsupported arch {name}. Supported arches are "
                f"{sorted(_ARCH_BY_NAME)}."
            ) from None

    @staticmethod
    def from_module(module: ModuleOp) -> X86Arch:
        """
        Read the target from the module, defaulting to the conservative
        `unknown` target when it is not recorded.
        """
        attr = module.attributes.get(ARCH_ATTR_NAME)
        if attr is None:
            return UNKNOWN
        if not isinstance(attr, StringAttr):
            raise DiagnosticException(
                f"`{ARCH_ATTR_NAME}` must be a string attribute, got {attr}."
            )
        return X86Arch.arch_for_name(attr.data)

    def set_on_module(self, module: ModuleOp) -> None:
        """
        Record this target on the module.
        """
        module.attributes[ARCH_ATTR_NAME] = StringAttr(self.name())

    def default_allocatable_registers(
        self,
    ) -> tuple[x86.registers.X86RegisterType, ...]:
        """
        The registers the allocator may use on this target.

        The upper half of each vector bank, xmm16-31 and ymm16-31, is only
        reachable through EVEX, so it exists on AVX-512 targets and nowhere
        else. Every vector bank shares one allocation pool, so the vector half
        is indexed off a single bank rather than listing each of them.
        """
        return (
            *x86.registers.Reg64Type.allocatable_registers(),
            *x86.registers.AVX2RegisterType.allocatable_registers()[:16],
        )

    def _register_type_for_vector_type(
        self, value_type: VectorType
    ) -> type[x86.registers.X86VectorRegisterType]:
        """
        Given any vector type, returns the appropriate register type.
        The vector type must fit exactly into a full bitwidth vector supported by the
        ISA, otherwise a `DiagnosticException` is raised.
        """
        vector_num_elements = value_type.element_count()
        element_type = cast(FixedBitwidthType, value_type.get_element_type())
        element_size = element_type.bitwidth
        vector_size = vector_num_elements * element_size
        try:
            return self.VECTOR_TYPES_BY_BITWIDTH[vector_size]
        except KeyError:
            # `from None` keeps the raw `KeyError: 512` out of the traceback, so
            # the reported cause is the diagnostic rather than a dict lookup.
            raise DiagnosticException(
                f"The vector size ({vector_size} bits) and target architecture "
                f"`{self.name()}` are inconsistent. Supported vector sizes are "
                f"{sorted(self.VECTOR_TYPES_BY_BITWIDTH)}."
            ) from None

    def _scalar_type_for_type(
        self, value_type: Attribute
    ) -> type[x86.registers.GeneralRegisterType]:
        if isinstance(value_type, FixedBitwidthType):
            match value_type.bitwidth:
                case 64:
                    return x86.registers.Reg64Type
                case 32:
                    return x86.registers.Reg32Type
                case 16:
                    return x86.registers.Reg16Type
                case 8:
                    return x86.registers.Reg8Type
                case _:
                    ...
        if isinstance(value_type, IndexType) or isinstance(value_type, ptr.PtrType):
            return x86.registers.Reg64Type
        raise DiagnosticException(f"Register type for type {value_type} not supported.")

    @overload
    def register_type_for_type(
        self, value_type: VectorType
    ) -> type[x86.registers.X86VectorRegisterType]: ...

    @overload
    def register_type_for_type(
        self, value_type: Attribute
    ) -> type[x86.registers.X86RegisterType]: ...

    def register_type_for_type(
        self, value_type: Attribute
    ) -> type[x86.registers.X86RegisterType]:
        if isinstance(value_type, x86.registers.X86RegisterType):
            return type(value_type)
        if isa(value_type, VectorType):
            return self._register_type_for_vector_type(value_type)
        return self._scalar_type_for_type(value_type)

    def cast_to_regs(
        self, values: Sequence[SSAValue], builder: Builder
    ) -> list[SSAValue]:
        return [
            builder.insert(
                asm.ToRegOp.get(v, self.register_type_for_type(v.type).unallocated())
            ).register
            for v in values
        ]

    def move_value_to_unallocated(
        self,
        value: SSAValue,
        builder: Builder,
        *,
        value_type: Attribute | None,
        insertion_point: InsertPoint | None = None,
    ) -> SSAValue:
        """
        Move the value to a new register.
        If the value type is known, use a specialised move operation, otherwise use a
        default move operation for the input register.
        """
        if value_type is not None and isa(value_type, VectorType[FixedBitwidthType]):
            if not isinstance(
                reg_type := value.type, x86.registers.X86VectorRegisterType
            ):
                raise ValueError(f"Invalid type for move {value_type}")
            # Choose the x86 vector instruction according to the
            # abstract vector element size
            match value_type.get_element_type().bitwidth:
                case 16:
                    raise DiagnosticException(
                        "Half-precision floating point vector move is not implemented yet."
                    )
                case 32:
                    raise DiagnosticException(
                        "Half-precision floating point vector move is not implemented yet."
                    )
                case 64:
                    mov_op = x86.ops.DS_VmovapdOp(
                        value, destination=type(reg_type).unallocated()
                    )
                case _:
                    raise DiagnosticException(
                        "Float precision must be half, single or double."
                    )
        elif isinstance(reg_type := value.type, x86.registers.X86VectorRegisterType):
            # In the future, we want to be more careful about register types.
            mov_op = x86.ops.DS_VmovapdOp(
                value, destination=type(reg_type).unallocated()
            )
        elif isinstance(reg_type, x86.registers.GeneralRegisterType):
            mov_op = x86.ops.DS_MovOp(value, destination=type(reg_type).unallocated())
        else:
            raise ValueError(f"Invalid type for move {value.type}")

        result = builder.insert(mov_op, insertion_point).results[0]
        result.name_hint = value.name_hint
        return result

VECTOR_TYPES_BY_BITWIDTH: dict[int, type[x86.registers.X86VectorRegisterType]] = {128: x86.registers.SSERegisterType} class-attribute

Supported vector type for a given vector size.

name() -> str staticmethod

Source code in xdsl/backend/x86/arch.py
@staticmethod
def name() -> str:
    return "unknown"

arch_for_name(name: str | None) -> X86Arch staticmethod

Source code in xdsl/backend/x86/arch.py
@staticmethod
def arch_for_name(name: str | None) -> X86Arch:
    if name is None:
        return UNKNOWN
    try:
        return _ARCH_BY_NAME[name]
    except KeyError:
        # Same reason as below: without `from None` the traceback leads with
        # `KeyError: 'sse9'` rather than with the diagnostic.
        raise DiagnosticException(
            f"Unsupported arch {name}. Supported arches are "
            f"{sorted(_ARCH_BY_NAME)}."
        ) from None

from_module(module: ModuleOp) -> X86Arch staticmethod

Read the target from the module, defaulting to the conservative unknown target when it is not recorded.

Source code in xdsl/backend/x86/arch.py
@staticmethod
def from_module(module: ModuleOp) -> X86Arch:
    """
    Read the target from the module, defaulting to the conservative
    `unknown` target when it is not recorded.
    """
    attr = module.attributes.get(ARCH_ATTR_NAME)
    if attr is None:
        return UNKNOWN
    if not isinstance(attr, StringAttr):
        raise DiagnosticException(
            f"`{ARCH_ATTR_NAME}` must be a string attribute, got {attr}."
        )
    return X86Arch.arch_for_name(attr.data)

set_on_module(module: ModuleOp) -> None

Record this target on the module.

Source code in xdsl/backend/x86/arch.py
def set_on_module(self, module: ModuleOp) -> None:
    """
    Record this target on the module.
    """
    module.attributes[ARCH_ATTR_NAME] = StringAttr(self.name())

default_allocatable_registers() -> tuple[x86.registers.X86RegisterType, ...]

The registers the allocator may use on this target.

The upper half of each vector bank, xmm16-31 and ymm16-31, is only reachable through EVEX, so it exists on AVX-512 targets and nowhere else. Every vector bank shares one allocation pool, so the vector half is indexed off a single bank rather than listing each of them.

Source code in xdsl/backend/x86/arch.py
def default_allocatable_registers(
    self,
) -> tuple[x86.registers.X86RegisterType, ...]:
    """
    The registers the allocator may use on this target.

    The upper half of each vector bank, xmm16-31 and ymm16-31, is only
    reachable through EVEX, so it exists on AVX-512 targets and nowhere
    else. Every vector bank shares one allocation pool, so the vector half
    is indexed off a single bank rather than listing each of them.
    """
    return (
        *x86.registers.Reg64Type.allocatable_registers(),
        *x86.registers.AVX2RegisterType.allocatable_registers()[:16],
    )

register_type_for_type(value_type: Attribute) -> type[x86.registers.X86RegisterType]

register_type_for_type(
    value_type: VectorType,
) -> type[x86.registers.X86VectorRegisterType]
register_type_for_type(
    value_type: Attribute,
) -> type[x86.registers.X86RegisterType]
Source code in xdsl/backend/x86/arch.py
def register_type_for_type(
    self, value_type: Attribute
) -> type[x86.registers.X86RegisterType]:
    if isinstance(value_type, x86.registers.X86RegisterType):
        return type(value_type)
    if isa(value_type, VectorType):
        return self._register_type_for_vector_type(value_type)
    return self._scalar_type_for_type(value_type)

cast_to_regs(values: Sequence[SSAValue], builder: Builder) -> list[SSAValue]

Source code in xdsl/backend/x86/arch.py
def cast_to_regs(
    self, values: Sequence[SSAValue], builder: Builder
) -> list[SSAValue]:
    return [
        builder.insert(
            asm.ToRegOp.get(v, self.register_type_for_type(v.type).unallocated())
        ).register
        for v in values
    ]

move_value_to_unallocated(value: SSAValue, builder: Builder, *, value_type: Attribute | None, insertion_point: InsertPoint | None = None) -> SSAValue

Move the value to a new register. If the value type is known, use a specialised move operation, otherwise use a default move operation for the input register.

Source code in xdsl/backend/x86/arch.py
def move_value_to_unallocated(
    self,
    value: SSAValue,
    builder: Builder,
    *,
    value_type: Attribute | None,
    insertion_point: InsertPoint | None = None,
) -> SSAValue:
    """
    Move the value to a new register.
    If the value type is known, use a specialised move operation, otherwise use a
    default move operation for the input register.
    """
    if value_type is not None and isa(value_type, VectorType[FixedBitwidthType]):
        if not isinstance(
            reg_type := value.type, x86.registers.X86VectorRegisterType
        ):
            raise ValueError(f"Invalid type for move {value_type}")
        # Choose the x86 vector instruction according to the
        # abstract vector element size
        match value_type.get_element_type().bitwidth:
            case 16:
                raise DiagnosticException(
                    "Half-precision floating point vector move is not implemented yet."
                )
            case 32:
                raise DiagnosticException(
                    "Half-precision floating point vector move is not implemented yet."
                )
            case 64:
                mov_op = x86.ops.DS_VmovapdOp(
                    value, destination=type(reg_type).unallocated()
                )
            case _:
                raise DiagnosticException(
                    "Float precision must be half, single or double."
                )
    elif isinstance(reg_type := value.type, x86.registers.X86VectorRegisterType):
        # In the future, we want to be more careful about register types.
        mov_op = x86.ops.DS_VmovapdOp(
            value, destination=type(reg_type).unallocated()
        )
    elif isinstance(reg_type, x86.registers.GeneralRegisterType):
        mov_op = x86.ops.DS_MovOp(value, destination=type(reg_type).unallocated())
    else:
        raise ValueError(f"Invalid type for move {value.type}")

    result = builder.insert(mov_op, insertion_point).results[0]
    result.name_hint = value.name_hint
    return result

AVX2Arch

Bases: X86Arch

Source code in xdsl/backend/x86/arch.py
class AVX2Arch(X86Arch):
    @staticmethod
    def name() -> str:
        return "avx2"

    VECTOR_TYPES_BY_BITWIDTH: ClassVar = {
        128: x86.registers.SSERegisterType,
        256: x86.registers.AVX2RegisterType,
    }

VECTOR_TYPES_BY_BITWIDTH: ClassVar = {128: x86.registers.SSERegisterType, 256: x86.registers.AVX2RegisterType} class-attribute instance-attribute

name() -> str staticmethod

Source code in xdsl/backend/x86/arch.py
@staticmethod
def name() -> str:
    return "avx2"

AVX512Arch

Bases: X86Arch

Source code in xdsl/backend/x86/arch.py
class AVX512Arch(X86Arch):
    @staticmethod
    def name() -> str:
        return "avx512"

    VECTOR_TYPES_BY_BITWIDTH: ClassVar = {
        128: x86.registers.SSERegisterType,
        256: x86.registers.AVX2RegisterType,
        512: x86.registers.AVX512RegisterType,
    }

    def default_allocatable_registers(
        self,
    ) -> tuple[x86.registers.X86RegisterType, ...]:
        return (
            *x86.registers.Reg64Type.allocatable_registers(),
            *x86.registers.AVX2RegisterType.allocatable_registers(),
        )

VECTOR_TYPES_BY_BITWIDTH: ClassVar = {128: x86.registers.SSERegisterType, 256: x86.registers.AVX2RegisterType, 512: x86.registers.AVX512RegisterType} class-attribute instance-attribute

name() -> str staticmethod

Source code in xdsl/backend/x86/arch.py
@staticmethod
def name() -> str:
    return "avx512"

default_allocatable_registers() -> tuple[x86.registers.X86RegisterType, ...]

Source code in xdsl/backend/x86/arch.py
def default_allocatable_registers(
    self,
) -> tuple[x86.registers.X86RegisterType, ...]:
    return (
        *x86.registers.Reg64Type.allocatable_registers(),
        *x86.registers.AVX2RegisterType.allocatable_registers(),
    )