qbepy 2026.2.1__cp312-cp312-macosx_14_0_arm64.whl

qbepy/ir/control.py

@@ -0,0 +1,60 @@
+"""QBE control flow instructions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .values import Label, Value
+
+
+@dataclass
+class Terminator:
+    """Base class for block terminators."""
+
+    def emit(self) -> str:
+        """Emit this terminator as QBE IL."""
+        raise NotImplementedError
+
+
+@dataclass
+class Jump(Terminator):
+    """Unconditional jump."""
+
+    target: Label
+
+    def emit(self) -> str:
+        return f"jmp {self.target}"
+
+
+@dataclass
+class Branch(Terminator):
+    """Conditional branch (jump if non-zero)."""
+
+    condition: Value
+    if_true: Label
+    if_false: Label
+
+    def emit(self) -> str:
+        return f"jnz {self.condition}, {self.if_true}, {self.if_false}"
+
+
+@dataclass
+class Return(Terminator):
+    """Function return."""
+
+    value: Value | None = None
+
+    def emit(self) -> str:
+        if self.value is not None:
+            return f"ret {self.value}"
+        return "ret"
+
+
+@dataclass
+class Halt(Terminator):
+    """Program halt (unreachable code marker)."""
+
+    def emit(self) -> str:
+        return "hlt"

qbepy/ir/instructions.py

@@ -0,0 +1,238 @@
+"""QBE instruction definitions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from .types import BaseType
+
+if TYPE_CHECKING:
+    from .values import Label, Temporary, Value
+
+
+@dataclass
+class Instruction:
+    """Base class for all instructions."""
+
+    def emit(self) -> str:
+        """Emit this instruction as QBE IL."""
+        raise NotImplementedError
+
+
+@dataclass
+class BinaryOp(Instruction):
+    """Binary arithmetic/logic operation.
+
+    Operations: add, sub, mul, div, rem, udiv, urem,
+                and, or, xor, sar, shr, shl
+    """
+
+    op: str
+    result: Temporary
+    result_type: BaseType
+    left: Value
+    right: Value
+
+    def emit(self) -> str:
+        return f"{self.result} ={self.result_type.value} {self.op} {self.left}, {self.right}"
+
+
+@dataclass
+class UnaryOp(Instruction):
+    """Unary operation (neg)."""
+
+    op: str
+    result: Temporary
+    result_type: BaseType
+    operand: Value
+
+    def emit(self) -> str:
+        return f"{self.result} ={self.result_type.value} {self.op} {self.operand}"
+
+
+@dataclass
+class Copy(Instruction):
+    """Copy operation."""
+
+    result: Temporary
+    result_type: BaseType
+    value: Value
+
+    def emit(self) -> str:
+        return f"{self.result} ={self.result_type.value} copy {self.value}"
+
+
+@dataclass
+class Load(Instruction):
+    """Memory load operation.
+
+    Load types: load, loadsb, loadub, loadsh, loaduh, loadsw, loaduw
+    """
+
+    result: Temporary
+    result_type: BaseType
+    address: Value
+    load_type: str = "load"
+
+    def emit(self) -> str:
+        return (
+            f"{self.result} ={self.result_type.value} {self.load_type} {self.address}"
+        )
+
+
+@dataclass
+class Store(Instruction):
+    """Memory store operation.
+
+    Store types: storeb, storeh, storew, storel, stores, stored
+    """
+
+    store_type: str
+    value: Value
+    address: Value
+
+    def emit(self) -> str:
+        return f"{self.store_type} {self.value}, {self.address}"
+
+
+@dataclass
+class Blit(Instruction):
+    """Memory copy (blit) operation."""
+
+    src: Value
+    dst: Value
+    size: int
+
+    def emit(self) -> str:
+        return f"blit {self.src}, {self.dst}, {self.size}"
+
+
+@dataclass
+class Alloc(Instruction):
+    """Stack allocation.
+
+    Alignment can be 4, 8, or 16 bytes.
+    """
+
+    result: Temporary
+    size: Value
+    align: int = 8
+
+    def emit(self) -> str:
+        alloc_op = f"alloc{self.align}"
+        return f"{self.result} =l {alloc_op} {self.size}"
+
+
+@dataclass
+class Comparison(Instruction):
+    """Comparison operation.
+
+    Integer comparisons: ceqw, cnew, csltw, csgtw, cslew, csgew,
+                        cultw, cugtw, culew, cugew
+                        (and 'l' variants for 64-bit)
+    Float comparisons: ceqs, cges, cgts, cles, clts, cnes, cos, cuos
+                      (and 'd' variants for double)
+    """
+
+    op: str
+    result: Temporary
+    result_type: BaseType
+    left: Value
+    right: Value
+
+    def emit(self) -> str:
+        return f"{self.result} ={self.result_type.value} {self.op} {self.left}, {self.right}"
+
+
+@dataclass
+class Conversion(Instruction):
+    """Type conversion operation.
+
+    Operations: extsb, extub, extsh, extuh, extsw, extuw,
+               exts, truncd, stosi, stoui, dtosi, dtoui,
+               swtof, uwtof, sltof, ultof, cast
+    """
+
+    op: str
+    result: Temporary
+    result_type: BaseType
+    operand: Value
+
+    def emit(self) -> str:
+        return f"{self.result} ={self.result_type.value} {self.op} {self.operand}"
+
+
+@dataclass
+class Call(Instruction):
+    """Function call.
+
+    Args are tuples of (type, value).
+    """
+
+    target: Value
+    args: list[tuple[BaseType | str, Value]]
+    result: Temporary | None = None
+    result_type: BaseType | str | None = None
+    is_variadic: bool = False
+
+    def emit(self) -> str:
+        # Format arguments
+        arg_strs = []
+        for arg_type, arg_val in self.args:
+            if isinstance(arg_type, BaseType):
+                type_str = arg_type.value
+            else:
+                type_str = f":{arg_type}"
+            arg_strs.append(f"{type_str} {arg_val}")
+
+        if self.is_variadic:
+            arg_strs.append("...")
+
+        args_str = ", ".join(arg_strs)
+
+        if self.result:
+            if isinstance(self.result_type, BaseType):
+                type_str = self.result_type.value
+            else:
+                type_str = f":{self.result_type}"
+            return f"{self.result} ={type_str} call {self.target}({args_str})"
+        return f"call {self.target}({args_str})"
+
+
+@dataclass
+class Phi(Instruction):
+    """Phi instruction for SSA form.
+
+    Incoming is a list of (Label, Value) pairs.
+    """
+
+    result: Temporary
+    result_type: BaseType
+    incoming: list[tuple[Label, Value]]
+
+    def emit(self) -> str:
+        pairs = ", ".join(f"{label} {value}" for label, value in self.incoming)
+        return f"{self.result} ={self.result_type.value} phi {pairs}"
+
+
+@dataclass
+class VaStart(Instruction):
+    """Initialize variadic argument list."""
+
+    va_list: Value
+
+    def emit(self) -> str:
+        return f"vastart {self.va_list}"
+
+
+@dataclass
+class VaArg(Instruction):
+    """Fetch next variadic argument."""
+
+    result: Temporary
+    result_type: BaseType
+    va_list: Value
+
+    def emit(self) -> str:
+        return f"{self.result} ={self.result_type.value} vaarg {self.va_list}"

qbepy/ir/types.py

@@ -0,0 +1,84 @@
+"""QBE type definitions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class BaseType(Enum):
+    """Base types for temporaries and function returns."""
+
+    WORD = "w"  # 32-bit integer
+    LONG = "l"  # 64-bit integer
+    SINGLE = "s"  # 32-bit float
+    DOUBLE = "d"  # 64-bit float
+
+
+class ExtType(Enum):
+    """Extended types for data and aggregate fields."""
+
+    BYTE = "b"  # 8-bit
+    HALF = "h"  # 16-bit halfword
+    WORD = "w"  # 32-bit word
+    LONG = "l"  # 64-bit long
+    SINGLE = "s"  # 32-bit float
+    DOUBLE = "d"  # 64-bit float
+
+
+class SubWordType(Enum):
+    """Sub-word types for ABI compatibility."""
+
+    SIGNED_BYTE = "sb"
+    UNSIGNED_BYTE = "ub"
+    SIGNED_HALF = "sh"
+    UNSIGNED_HALF = "uh"
+
+
+# Convenience aliases
+W = BaseType.WORD
+L = BaseType.LONG
+S = BaseType.SINGLE
+D = BaseType.DOUBLE
+
+
+@dataclass
+class AggregateType:
+    """User-defined aggregate type (struct/union).
+
+    Example:
+        # type :point = { w, w }
+        point = AggregateType("point", [(ExtType.WORD, 1), (ExtType.WORD, 1)])
+
+        # type :vec = align 16 { d 4 }
+        vec = AggregateType("vec", [(ExtType.DOUBLE, 4)], align=16)
+    """
+
+    name: str
+    fields: list[tuple[ExtType | str, int]] = field(default_factory=list)
+    align: int | None = None
+    is_opaque: bool = False
+    opaque_size: int | None = None
+
+    def emit(self) -> str:
+        """Emit this type definition as QBE IL."""
+        align_str = f"align {self.align} " if self.align else ""
+
+        if self.is_opaque:
+            return f"type :{self.name} = {align_str}{{ {self.opaque_size} }}"
+
+        parts = []
+        for field_type, count in self.fields:
+            if isinstance(field_type, ExtType):
+                type_str = field_type.value
+            else:
+                # Nested aggregate type reference
+                type_str = f":{field_type}"
+
+            if count > 1:
+                parts.append(f"{type_str} {count}")
+            else:
+                parts.append(type_str)
+
+        fields_str = ", ".join(parts)
+        return f"type :{self.name} = {align_str}{{ {fields_str} }}"

qbepy/ir/values.py

@@ -0,0 +1,76 @@
+"""QBE value types."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Temporary:
+    """Function-scope temporary variable (%name)."""
+
+    name: str
+
+    def __str__(self) -> str:
+        return f"%{self.name}"
+
+
+@dataclass(frozen=True)
+class Global:
+    """Global symbol ($name)."""
+
+    name: str
+
+    def __str__(self) -> str:
+        return f"${self.name}"
+
+
+@dataclass(frozen=True)
+class Label:
+    """Block label (@name)."""
+
+    name: str
+
+    def __str__(self) -> str:
+        return f"@{self.name}"
+
+
+@dataclass(frozen=True)
+class IntConst:
+    """Integer constant."""
+
+    value: int
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+
+@dataclass(frozen=True)
+class FloatConst:
+    """Floating-point constant.
+
+    QBE uses special syntax for floats:
+      s_<float> for single precision
+      d_<double> for double precision
+    """
+
+    value: float
+    is_single: bool = False
+
+    def __str__(self) -> str:
+        prefix = "s_" if self.is_single else "d_"
+        return f"{prefix}{self.value}"
+
+
+@dataclass(frozen=True)
+class TypeRef:
+    """Reference to an aggregate type (:typename)."""
+
+    name: str
+
+    def __str__(self) -> str:
+        return f":{self.name}"
+
+
+# Type alias for any value that can be used as an operand
+Value = Temporary | Global | IntConst | FloatConst | TypeRef