Registers

class X86RegisterType(RegisterType, ABC):
    """
    The abstract class for all x86 register types.
    """

class GeneralRegisterType(X86RegisterType, ABC):
    """
    Abstract base for x86 scalar general-purpose register types (64/32/16/8-bit names).

    Concrete subclasses set the assembly name width; all share :data:`X86_GPR_POOL_KEY`
    for register allocation.
    """

    @classmethod
    @override
    def register_pool_key(cls) -> str:
        return X86_GPR_POOL_KEY

    @classmethod
    def allocatable_registers(cls):
        """
        Registers of this type that can be used for register allocation.

        Returns a tuple of GeneralRegisterType instances corresponding to registers that
        are allocatable according to the x86-64 System V ABI.
        This excludes registers with special purposes (e.g., stack pointer, base pointer).
        """
        return tuple(cls.from_index(i) for i in _ALLOCATABLE_GPR_INDICES)

@irdl_attr_definition
class Reg64Type(GeneralRegisterType):
    """
    64-bit x86 general-purpose register names (``rax``, ``r8``, …).
    """

    name = "x86.reg64"

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return X86_INDEX_BY_NAME

    @classmethod
    def infinite_register_prefix(cls):
        return "inf_reg_"

@irdl_attr_definition
class Reg32Type(GeneralRegisterType):
    """
    32-bit x86 general-purpose register names (``eax``, ``r8d``, …).
    """

    name = "x86.reg32"

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return REG32_INDEX_BY_NAME

    @classmethod
    def infinite_register_prefix(cls):
        return "inf_reg32_"

@irdl_attr_definition
class Reg16Type(GeneralRegisterType):
    """
    16-bit x86 general-purpose register names (``ax``, ``r8w``, …).
    """

    name = "x86.reg16"

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return REG16_INDEX_BY_NAME

    @classmethod
    def infinite_register_prefix(cls):
        return "inf_reg16_"

@irdl_attr_definition
class Reg8Type(GeneralRegisterType):
    """
    8-bit x86 low-byte register names (``al``, ``r8b``, …).

    High-byte names ``ah``/``ch``/``dh``/``bh`` are not represented: they share indices
    with low bytes but :class:`~xdsl.backend.register_type.RegisterType` assumes one
    canonical name per pool index.
    """

    name = "x86.reg8"

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return REG8_INDEX_BY_NAME

    @classmethod
    def infinite_register_prefix(cls):
        return "inf_reg8_"

@irdl_attr_definition
class RFLAGSRegisterType(X86RegisterType):
    """
    A scalar x86 register type representing the RFLAGS register.
    """

    name = "x86.rflags"

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return RFLAGS_INDEX_BY_NAME

    @classmethod
    def infinite_register_prefix(cls):
        return "inf_rflags_"

class X86VectorRegisterType(X86RegisterType, ABC):
    """
    The abstract class for all x86 vector register types.
    """

    @override
    @classmethod
    def register_pool_key(cls) -> str:
        return X86_VECTOR_POOL_KEY

    @classmethod
    @abstractmethod
    def bitwidth(cls) -> int:
        """
        The width of this register bank in bits.
        """
        ...

@irdl_attr_definition
class SSERegisterType(X86VectorRegisterType):
    """
    An x86 register type for SSE instructions.
    """

    name = "x86.ssereg"

    @classmethod
    def bitwidth(cls) -> int:
        return 128

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return SSE_INDEX_BY_NAME

    @classmethod
    def infinite_register_prefix(cls):
        return "inf_sse_"

    @classmethod
    def allocatable_registers(cls):
        return XMM

@irdl_attr_definition
class AVX2RegisterType(X86VectorRegisterType):
    """
    An x86 register type for AVX2 instructions.
    """

    name = "x86.avx2reg"

    @classmethod
    def bitwidth(cls) -> int:
        return 256

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return AVX2_INDEX_BY_NAME

    @classmethod
    def infinite_register_prefix(cls):
        return "inf_avx2_"

    @classmethod
    def allocatable_registers(cls):
        return YMM

@irdl_attr_definition
class AVX512RegisterType(X86VectorRegisterType):
    """
    An x86 register type for AVX512 instructions.
    """

    name = "x86.avx512reg"

    @classmethod
    def bitwidth(cls) -> int:
        return 512

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return X86AVX512_INDEX_BY_NAME

    @classmethod
    def infinite_register_prefix(cls):
        return "inf_avx512_"

    @classmethod
    def allocatable_registers(cls):
        return ZMM

@irdl_attr_definition
class AVX512MaskRegisterType(X86RegisterType):
    """
    An x86 mask register type for AVX512 instructions.
    """

    name = "x86.avx512maskreg"

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return X86AVX512_MASK_INDEX_BY_NAME

    @classmethod
    def infinite_register_prefix(cls):
        return "inf_avx512_mask_"

    @classmethod
    def allocatable_registers(cls):
        return K