llvm-native-core 0.1.13

//! GlobalISel Machine IR Builder.
//!
//! Clean-room behavioral reconstruction from the LLVM GlobalISel
//! documentation and the generic Machine IR specification.
//! Zero LLVM C++ source code consultation.
//!
//! Provides a builder for constructing Machine IR (MIR) directly,
//! without going through SelectionDAG. The MIR uses virtual registers
//! and generic opcodes that are later legalized and selected.

#![allow(non_camel_case_types)]

use std::collections::HashMap;

// -----------------------------------------------------------------------
// Machine IR Types
// -----------------------------------------------------------------------

/// Virtual register identifier.
pub type VReg = u32;

/// Machine basic block index.
pub type MBBIndex = usize;

/// A machine operand — either a virtual register, physical register,
/// immediate, or label.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum MOperand {
    /// Virtual register.
    VReg(VReg),
    /// Physical register number.
    PhysReg(u32),
    /// Immediate integer value.
    Imm(i64),
    /// Block label (target of a branch).
    Label(String),
    /// Global symbol reference.
    Global(String),
}

impl MOperand {
    pub fn vreg(v: VReg) -> Self {
        MOperand::VReg(v)
    }

    pub fn imm(v: i64) -> Self {
        MOperand::Imm(v)
    }

    pub fn label(name: &str) -> Self {
        MOperand::Label(name.to_string())
    }

    /// Returns the vreg if this operand is a virtual register.
    pub fn as_vreg(&self) -> Option<VReg> {
        match self {
            MOperand::VReg(v) => Some(*v),
            _ => None,
        }
    }

    /// Returns the immediate value if this operand is an immediate.
    pub fn as_imm(&self) -> Option<i64> {
        match self {
            MOperand::Imm(v) => Some(*v),
            _ => None,
        }
    }
}

/// Generic machine instruction opcodes for GlobalISel.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u32)]
pub enum GOpcode {
    // Terminators
    G_BR = 1,
    G_BRCOND = 2,
    G_RET = 3,

    // Constants
    G_CONSTANT = 10,
    G_FCONSTANT = 11,
    G_FRAME_INDEX = 12,
    G_GLOBAL_VALUE = 13,

    // Integer arithmetic
    G_ADD = 20,
    G_SUB = 21,
    G_MUL = 22,
    G_SDIV = 23,
    G_UDIV = 24,
    G_SREM = 25,
    G_UREM = 26,
    G_AND = 27,
    G_OR = 28,
    G_XOR = 29,
    G_SHL = 30,
    G_LSHR = 31,
    G_ASHR = 32,

    // Floating-point arithmetic
    G_FADD = 40,
    G_FSUB = 41,
    G_FMUL = 42,
    G_FDIV = 43,
    G_FREM = 44,
    G_FNEG = 45,
    G_FABS = 46,

    // Extensions and truncations
    G_TRUNC = 50,
    G_ZEXT = 51,
    G_SEXT = 52,
    G_ANYEXT = 53,
    G_FPTRUNC = 54,
    G_FPEXT = 55,
    G_FPTOUI = 56,
    G_FPTOSI = 57,
    G_UITOFP = 58,
    G_SITOFP = 59,

    // Comparisons
    G_ICMP = 60,
    G_FCMP = 61,

    // Memory
    G_LOAD = 70,
    G_STORE = 71,
    G_PTR_ADD = 72,

    // Control flow
    G_PHI = 80,
    G_SELECT = 81,

    // Copy
    COPY = 90,

    // Integer/pointer conversions
    G_PTRTOINT = 100,
    G_INTTOPTR = 101,
    G_BITCAST = 102,
    G_ADDRSPACE_CAST = 103,

    // Bitwise manipulation
    G_CTLZ = 110,
    G_CTTZ = 111,
    G_CTPOP = 112,
    G_BSWAP = 113,
    G_BITREVERSE = 114,

    // Additional floating-point
    G_FCEIL = 120,
    G_FFLOOR = 121,
    G_FSQRT = 122,
    G_FMA = 123,
    G_FPOW = 124,
    G_FEXP = 125,
    G_FLOG = 126,

    // Overflow-checking integer arithmetic
    G_UADDO = 130,
    G_SADDO = 131,
    G_USUBO = 132,
    G_SSUBO = 133,
}

impl GOpcode {
    pub fn as_u32(self) -> u32 {
        self as u32
    }

    pub fn is_terminator(self) -> bool {
        matches!(self, GOpcode::G_BR | GOpcode::G_BRCOND | GOpcode::G_RET)
    }

    pub fn is_binary_op(self) -> bool {
        matches!(
            self,
            GOpcode::G_ADD
                | GOpcode::G_SUB
                | GOpcode::G_MUL
                | GOpcode::G_SDIV
                | GOpcode::G_UDIV
                | GOpcode::G_SREM
                | GOpcode::G_UREM
                | GOpcode::G_AND
                | GOpcode::G_OR
                | GOpcode::G_XOR
                | GOpcode::G_SHL
                | GOpcode::G_LSHR
                | GOpcode::G_ASHR
                | GOpcode::G_FADD
                | GOpcode::G_FSUB
                | GOpcode::G_FMUL
                | GOpcode::G_FDIV
                | GOpcode::G_FREM
        )
    }

    pub fn is_commutative(self) -> bool {
        matches!(
            self,
            GOpcode::G_ADD
                | GOpcode::G_MUL
                | GOpcode::G_AND
                | GOpcode::G_OR
                | GOpcode::G_XOR
                | GOpcode::G_FADD
                | GOpcode::G_FMUL
        )
    }
}

/// A single machine instruction.
#[derive(Debug, Clone)]
pub struct GInstruction {
    /// The generic opcode.
    pub opcode: GOpcode,
    /// All operands (definitions and uses).
    /// Convention: first operand is the definition (if any),
    /// followed by use operands.
    pub operands: Vec<MOperand>,
}

impl GInstruction {
    pub fn new(opcode: GOpcode) -> Self {
        GInstruction {
            opcode,
            operands: Vec::new(),
        }
    }

    pub fn with_operands(opcode: GOpcode, operands: Vec<MOperand>) -> Self {
        GInstruction { opcode, operands }
    }

    /// Returns the definition vreg (first operand) if this instruction
    /// produces a value.
    pub fn def_vreg(&self) -> Option<VReg> {
        self.operands.first().and_then(|op| op.as_vreg())
    }

    /// Returns all use operands (everything after the first).
    pub fn uses(&self) -> &[MOperand] {
        if self.operands.is_empty() {
            &[]
        } else {
            &self.operands[1..]
        }
    }

    /// Returns all operands.
    pub fn all_operands(&self) -> &[MOperand] {
        &self.operands
    }
}

/// A machine basic block.
#[derive(Debug, Clone)]
pub struct GMachineBasicBlock {
    /// Block label.
    pub name: String,
    /// Instructions in this block.
    pub instructions: Vec<GInstruction>,
    /// Indices of successor blocks.
    pub successors: Vec<MBBIndex>,
}

impl GMachineBasicBlock {
    pub fn new(name: String) -> Self {
        GMachineBasicBlock {
            name,
            instructions: Vec::new(),
            successors: Vec::new(),
        }
    }

    pub fn push_instruction(&mut self, inst: GInstruction) {
        self.instructions.push(inst);
    }

    pub fn add_successor(&mut self, bb: MBBIndex) {
        if !self.successors.contains(&bb) {
            self.successors.push(bb);
        }
    }

    pub fn instruction_count(&self) -> usize {
        self.instructions.len()
    }
}

/// A machine function in GlobalISel representation.
#[derive(Debug, Clone)]
pub struct GMachineFunction {
    /// Function name.
    pub name: String,
    /// Basic blocks.
    pub blocks: Vec<GMachineBasicBlock>,
    /// Virtual register counter for allocating new vregs.
    pub next_vreg: VReg,
}

impl GMachineFunction {
    pub fn new(name: String) -> Self {
        GMachineFunction {
            name,
            blocks: Vec::new(),
            next_vreg: 0,
        }
    }

    pub fn new_vreg(&mut self) -> VReg {
        let v = self.next_vreg;
        self.next_vreg += 1;
        v
    }

    pub fn push_block(&mut self, name: String) -> MBBIndex {
        let idx = self.blocks.len();
        self.blocks.push(GMachineBasicBlock::new(name));
        idx
    }

    pub fn block_count(&self) -> usize {
        self.blocks.len()
    }

    pub fn instruction_count(&self) -> usize {
        self.blocks.iter().map(|b| b.instruction_count()).sum()
    }
}

// -----------------------------------------------------------------------
// Machine IR Builder
// -----------------------------------------------------------------------

/// Builder for constructing Machine IR in GlobalISel.
///
/// Provides methods to emit generic machine instructions
/// into a `GMachineFunction`, managing the current insertion
/// point (block + position).
pub struct MachineIRBuilder {
    /// The machine function being built.
    pub mf: GMachineFunction,
    /// Current basic block index.
    pub current_block: MBBIndex,
    /// Insertion position within the current block (0 = start).
    pub insert_point: usize,
}

impl MachineIRBuilder {
    /// Creates a new builder for a machine function with the given name.
    pub fn new(func_name: &str) -> Self {
        let mut mf = GMachineFunction::new(func_name.to_string());
        let entry = mf.push_block("entry".to_string());
        MachineIRBuilder {
            mf,
            current_block: entry,
            insert_point: 0,
        }
    }

    /// Sets the insertion point to the given block and position.
    pub fn set_insert_point(&mut self, bb: MBBIndex, pos: usize) {
        self.current_block = bb;
        self.insert_point = pos;
    }

    /// Sets the insertion point to the end of the current block.
    pub fn set_insert_point_to_end(&mut self) {
        let len = self.mf.blocks[self.current_block].instruction_count();
        self.insert_point = len;
    }

    /// Returns a new virtual register.
    pub fn new_vreg(&mut self) -> VReg {
        self.mf.new_vreg()
    }

    /// Creates a new basic block and returns its index.
    pub fn new_block(&mut self, name: &str) -> MBBIndex {
        self.mf.push_block(name.to_string())
    }

    // ---- Instruction builders ----

    /// Builds a COPY instruction: dst = src.
    pub fn build_copy(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::COPY,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds a G_CONSTANT: dst = immediate.
    pub fn build_constant(&mut self, val: i64) -> VReg {
        let dst = self.new_vreg();
        let inst = GInstruction::with_operands(
            GOpcode::G_CONSTANT,
            vec![MOperand::vreg(dst), MOperand::imm(val)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_ADD: dst = src1 + src2.
    pub fn build_add(&mut self, dst: VReg, src1: VReg, src2: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_ADD,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(src1),
                MOperand::vreg(src2),
            ],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_SUB: dst = src1 - src2.
    pub fn build_sub(&mut self, dst: VReg, src1: VReg, src2: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_SUB,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(src1),
                MOperand::vreg(src2),
            ],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_MUL: dst = src1 * src2.
    pub fn build_mul(&mut self, dst: VReg, src1: VReg, src2: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_MUL,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(src1),
                MOperand::vreg(src2),
            ],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_AND: dst = src1 & src2.
    pub fn build_and(&mut self, dst: VReg, src1: VReg, src2: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_AND,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(src1),
                MOperand::vreg(src2),
            ],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_OR: dst = src1 | src2.
    pub fn build_or(&mut self, dst: VReg, src1: VReg, src2: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_OR,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(src1),
                MOperand::vreg(src2),
            ],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_XOR: dst = src1 ^ src2.
    pub fn build_xor(&mut self, dst: VReg, src1: VReg, src2: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_XOR,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(src1),
                MOperand::vreg(src2),
            ],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_LOAD: dst = *addr.
    pub fn build_load(&mut self, dst: VReg, addr: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_LOAD,
            vec![MOperand::vreg(dst), MOperand::vreg(addr)],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_STORE: *addr = val.
    pub fn build_store(&mut self, val: VReg, addr: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_STORE,
            vec![MOperand::vreg(val), MOperand::vreg(addr)],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_BR: unconditional branch to target block.
    pub fn build_br(&mut self, target: MBBIndex) {
        let label = self.mf.blocks[target].name.clone();
        let inst = GInstruction::with_operands(GOpcode::G_BR, vec![MOperand::label(&label)]);
        self.insert_instruction(inst);
        self.mf.blocks[self.current_block].add_successor(target);
    }

    /// Builds G_BRCOND: conditional branch.
    pub fn build_cond_br(&mut self, cond: VReg, t_bb: MBBIndex, f_bb: MBBIndex) {
        let t_label = self.mf.blocks[t_bb].name.clone();
        let f_label = self.mf.blocks[f_bb].name.clone();
        let inst = GInstruction::with_operands(
            GOpcode::G_BRCOND,
            vec![
                MOperand::vreg(cond),
                MOperand::label(&t_label),
                MOperand::label(&f_label),
            ],
        );
        self.insert_instruction(inst);
        self.mf.blocks[self.current_block].add_successor(t_bb);
        self.mf.blocks[self.current_block].add_successor(f_bb);
    }

    /// Builds G_RET: return val.
    pub fn build_ret(&mut self, val: VReg) {
        let inst = GInstruction::with_operands(GOpcode::G_RET, vec![MOperand::vreg(val)]);
        self.insert_instruction(inst);
    }

    /// Builds a call instruction placeholder.
    /// Returns the vreg that will hold the return value.
    pub fn build_call(&mut self, _callee: VReg, _args: &[VReg]) -> VReg {
        let dst = self.new_vreg();
        // In a full implementation, we would emit a G_CALL instruction.
        let inst = GInstruction::new(GOpcode::G_ADD); // placeholder
        self.insert_instruction(inst);
        dst
    }

    /// Inserts an instruction at the current insertion point.
    fn insert_instruction(&mut self, inst: GInstruction) {
        let block = &mut self.mf.blocks[self.current_block];
        if self.insert_point >= block.instruction_count() {
            block.push_instruction(inst);
        } else {
            block.instructions.insert(self.insert_point, inst);
        }
        self.insert_point += 1;
    }

    /// Returns a reference to the machine function.
    pub fn get_mf(&self) -> &GMachineFunction {
        &self.mf
    }

    /// Returns a mutable reference to the machine function.
    pub fn get_mf_mut(&mut self) -> &mut GMachineFunction {
        &mut self.mf
    }

    /// Returns the total number of instructions in the function.
    pub fn total_instructions(&self) -> usize {
        self.mf.instruction_count()
    }
}

// ---------------------------------------------------------------------------
// Extended Generic Opcodes — Integer/Float Conversions and Bit Ops
// ---------------------------------------------------------------------------

impl GOpcode {
    /// Returns true if this opcode is an extension (any kind).
    pub fn is_extension(self) -> bool {
        matches!(
            self,
            GOpcode::G_ANYEXT | GOpcode::G_ZEXT | GOpcode::G_SEXT | GOpcode::G_FPEXT
        )
    }

    /// Returns true if this opcode is a truncation.
    pub fn is_truncation(self) -> bool {
        matches!(self, GOpcode::G_TRUNC | GOpcode::G_FPTRUNC)
    }

    /// Returns true if this is a type conversion between int and pointer.
    pub fn is_int_ptr_conversion(self) -> bool {
        matches!(self, GOpcode::G_PTRTOINT | GOpcode::G_INTTOPTR)
    }

    /// Returns true if this is a bitwise manipulation opcode.
    pub fn is_bitwise_manipulation(self) -> bool {
        matches!(
            self,
            GOpcode::G_CTLZ
                | GOpcode::G_CTTZ
                | GOpcode::G_CTPOP
                | GOpcode::G_BSWAP
                | GOpcode::G_BITREVERSE
        )
    }

    /// Returns true if this is a floating-point unary operation.
    pub fn is_fp_unary(self) -> bool {
        matches!(
            self,
            GOpcode::G_FNEG
                | GOpcode::G_FABS
                | GOpcode::G_FCEIL
                | GOpcode::G_FFLOOR
                | GOpcode::G_FSQRT
                | GOpcode::G_FEXP
                | GOpcode::G_FLOG
        )
    }

    /// Returns true if this is a floating-point ternary operation.
    pub fn is_fp_ternary(self) -> bool {
        matches!(self, GOpcode::G_FMA | GOpcode::G_FPOW)
    }

    /// Returns true if this is an overflow-checking integer operation.
    pub fn is_overflow_op(self) -> bool {
        matches!(
            self,
            GOpcode::G_UADDO | GOpcode::G_SADDO | GOpcode::G_USUBO | GOpcode::G_SSUBO
        )
    }

    /// Returns the number of def operands expected.
    pub fn num_defs(self) -> usize {
        match self {
            GOpcode::COPY
            | GOpcode::G_CONSTANT
            | GOpcode::G_FCONSTANT
            | GOpcode::G_FRAME_INDEX
            | GOpcode::G_GLOBAL_VALUE
            | GOpcode::G_LOAD
            | GOpcode::G_ANYEXT
            | GOpcode::G_ZEXT
            | GOpcode::G_SEXT
            | GOpcode::G_TRUNC
            | GOpcode::G_FPTRUNC
            | GOpcode::G_FPEXT
            | GOpcode::G_FPTOUI
            | GOpcode::G_FPTOSI
            | GOpcode::G_UITOFP
            | GOpcode::G_SITOFP
            | GOpcode::G_PTRTOINT
            | GOpcode::G_INTTOPTR
            | GOpcode::G_BITCAST
            | GOpcode::G_ADDRSPACE_CAST
            | GOpcode::G_CTLZ
            | GOpcode::G_CTTZ
            | GOpcode::G_CTPOP
            | GOpcode::G_BSWAP
            | GOpcode::G_BITREVERSE
            | GOpcode::G_FNEG
            | GOpcode::G_FABS
            | GOpcode::G_FCEIL
            | GOpcode::G_FFLOOR
            | GOpcode::G_FSQRT
            | GOpcode::G_FEXP
            | GOpcode::G_FLOG
            | GOpcode::G_ICMP
            | GOpcode::G_FCMP
            | GOpcode::G_SELECT
            | GOpcode::G_PHI
            | GOpcode::G_PTR_ADD => 1,
            GOpcode::G_UADDO | GOpcode::G_SADDO | GOpcode::G_USUBO | GOpcode::G_SSUBO => 2,
            _ => 1,
        }
    }

    /// Returns the number of use operands expected.
    pub fn num_uses(self) -> usize {
        match self {
            GOpcode::G_BR => 1,
            GOpcode::G_BRCOND => 3,
            GOpcode::G_RET => 1,
            GOpcode::G_STORE => 2,
            GOpcode::G_FMA => 3,
            GOpcode::G_FPOW => 2,
            GOpcode::G_SELECT => 3,
            _ => {
                if self.is_binary_op() || self.is_overflow_op() {
                    2
                } else if self.is_fp_unary()
                    || self.is_extension()
                    || self.is_truncation()
                    || self.is_bitwise_manipulation()
                    || self.is_int_ptr_conversion()
                {
                    1
                } else if self.is_fp_ternary() {
                    3
                } else {
                    // Variable: PHI, LOAD, etc.
                    2
                }
            }
        }
    }

    /// Verify the instruction operands for correctness.
    pub fn verify_operands(&self, operands: &[MOperand]) -> Result<(), String> {
        let expected_uses = self.num_uses();
        let expected_defs = self.num_defs();
        let total = expected_defs + expected_uses;

        if operands.len() < total {
            return Err(format!(
                "{:?}: expected {} operands ({} defs + {} uses), got {}",
                self,
                total,
                expected_defs,
                expected_uses,
                operands.len()
            ));
        }

        // Verify def operands are all vregs.
        for i in 0..expected_defs {
            if !matches!(operands[i], MOperand::VReg(_)) {
                return Err(format!("{:?}: def operand {} must be a vreg", self, i));
            }
        }

        Ok(())
    }
}

// ---------------------------------------------------------------------------
// Extended MachineIRBuilder — More Operations
// ---------------------------------------------------------------------------

impl MachineIRBuilder {
    // ---- Extension/Truncation builders ----

    /// Builds G_ANYEXT: dst = anyext(src).
    pub fn build_anyext(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_ANYEXT,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_ZEXT: dst = zext(src).
    pub fn build_zext(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_ZEXT,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_SEXT: dst = sext(src).
    pub fn build_sext(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_SEXT,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_TRUNC: dst = trunc(src).
    pub fn build_trunc(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_TRUNC,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    // ---- Int/Ptr conversion builders ----

    /// Builds G_PTRTOINT: dst = ptrtoint(src).
    pub fn build_ptrtoint(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_PTRTOINT,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_INTTOPTR: dst = inttoptr(src).
    pub fn build_inttoptr(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_INTTOPTR,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_BITCAST: dst = bitcast(src).
    pub fn build_bitcast(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_BITCAST,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_ADDRSPACE_CAST: dst = addrspacecast(src).
    pub fn build_addrspace_cast(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_ADDRSPACE_CAST,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    // ---- Bitwise manipulation builders ----

    /// Builds G_CTLZ: dst = ctlz(src) — count leading zeros.
    pub fn build_ctlz(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_CTLZ,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_CTTZ: dst = cttz(src) — count trailing zeros.
    pub fn build_cttz(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_CTTZ,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_CTPOP: dst = ctpop(src) — population count.
    pub fn build_ctpop(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_CTPOP,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_BSWAP: dst = bswap(src) — byte swap.
    pub fn build_bswap(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_BSWAP,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_BITREVERSE: dst = bitreverse(src).
    pub fn build_bitreverse(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_BITREVERSE,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    // ---- Floating-point unary builders ----

    /// Builds G_FCEIL: dst = ceil(src).
    pub fn build_fceil(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_FCEIL,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_FFLOOR: dst = floor(src).
    pub fn build_ffloor(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_FFLOOR,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_FABS: dst = fabs(src).
    pub fn build_fabs(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_FABS,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_FNEG: dst = fneg(src).
    pub fn build_fneg(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_FNEG,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_FSQRT: dst = sqrt(src).
    pub fn build_fsqrt(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_FSQRT,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_FMA: dst = a * b + c (fused multiply-add).
    pub fn build_fma(&mut self, dst: VReg, a: VReg, b: VReg, c: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_FMA,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(a),
                MOperand::vreg(b),
                MOperand::vreg(c),
            ],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_FPOW: dst = pow(base, exp).
    pub fn build_fpow(&mut self, dst: VReg, base: VReg, exp: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_FPOW,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(base),
                MOperand::vreg(exp),
            ],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_FEXP: dst = exp(src).
    pub fn build_fexp(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_FEXP,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Builds G_FLOG: dst = log(src).
    pub fn build_flog(&mut self, dst: VReg, src: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_FLOG,
            vec![MOperand::vreg(dst), MOperand::vreg(src)],
        );
        self.insert_instruction(inst);
        dst
    }

    // ---- Overflow-checking arithmetic builders ----

    /// Builds G_UADDO: (dst, overflow) = uaddo(a, b).
    pub fn build_uaddo(&mut self, dst: VReg, overflow: VReg, a: VReg, b: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_UADDO,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(overflow),
                MOperand::vreg(a),
                MOperand::vreg(b),
            ],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_SADDO: (dst, overflow) = saddo(a, b).
    pub fn build_saddo(&mut self, dst: VReg, overflow: VReg, a: VReg, b: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_SADDO,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(overflow),
                MOperand::vreg(a),
                MOperand::vreg(b),
            ],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_USUBO: (dst, overflow) = usubo(a, b).
    pub fn build_usubo(&mut self, dst: VReg, overflow: VReg, a: VReg, b: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_USUBO,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(overflow),
                MOperand::vreg(a),
                MOperand::vreg(b),
            ],
        );
        self.insert_instruction(inst);
    }

    /// Builds G_SSUBO: (dst, overflow) = ssubo(a, b).
    pub fn build_ssubo(&mut self, dst: VReg, overflow: VReg, a: VReg, b: VReg) {
        let inst = GInstruction::with_operands(
            GOpcode::G_SSUBO,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(overflow),
                MOperand::vreg(a),
                MOperand::vreg(b),
            ],
        );
        self.insert_instruction(inst);
    }

    // ---- G_SELECT builder ----

    /// Builds G_SELECT: dst = cond ? tval : fval.
    pub fn build_select(&mut self, dst: VReg, cond: VReg, tval: VReg, fval: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_SELECT,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(cond),
                MOperand::vreg(tval),
                MOperand::vreg(fval),
            ],
        );
        self.insert_instruction(inst);
        dst
    }

    // ---- G_PTR_ADD builder ----

    /// Builds G_PTR_ADD: dst = base + offset (pointer arithmetic).
    pub fn build_ptr_add(&mut self, dst: VReg, base: VReg, offset: VReg) -> VReg {
        let inst = GInstruction::with_operands(
            GOpcode::G_PTR_ADD,
            vec![
                MOperand::vreg(dst),
                MOperand::vreg(base),
                MOperand::vreg(offset),
            ],
        );
        self.insert_instruction(inst);
        dst
    }

    /// Verify all instructions in the function.
    pub fn verify_function(&self) -> Result<(), Vec<String>> {
        let mut errors = Vec::new();
        for (bb_idx, block) in self.mf.blocks.iter().enumerate() {
            for (i_idx, inst) in block.instructions.iter().enumerate() {
                if let Err(e) = inst.opcode.verify_operands(&inst.operands) {
                    errors.push(format!("BB{} inst{}: {}", bb_idx, i_idx, e));
                }
            }
        }
        if errors.is_empty() {
            Ok(())
        } else {
            Err(errors)
        }
    }
}

// ---------------------------------------------------------------------------
// Machine IR Verification and Debug Helpers
// ---------------------------------------------------------------------------

/// Verification result for a machine function.
#[derive(Debug)]
pub struct MachineVerificationResult {
    /// Whether verification passed.
    pub passed: bool,
    /// Error messages.
    pub errors: Vec<String>,
    /// Warning messages.
    pub warnings: Vec<String>,
}

impl GMachineFunction {
    /// Verify the machine function for correctness.
    pub fn verify(&self) -> MachineVerificationResult {
        let mut result = MachineVerificationResult {
            passed: true,
            errors: Vec::new(),
            warnings: Vec::new(),
        };

        // Check each basic block.
        for (bb_idx, block) in self.blocks.iter().enumerate() {
            // Check that successors reference valid blocks.
            for &succ in &block.successors {
                if succ >= self.blocks.len() {
                    result.errors.push(format!(
                        "BB{}: successor {} is out of range (max {})",
                        bb_idx,
                        succ,
                        self.blocks.len()
                    ));
                    result.passed = false;
                }
            }

            // Check that terminators are at the end.
            for (i_idx, inst) in block.instructions.iter().enumerate() {
                if inst.opcode.is_terminator() {
                    if i_idx != block.instructions.len() - 1 {
                        result.errors.push(format!(
                            "BB{}: terminator at position {}, not end of block",
                            bb_idx, i_idx
                        ));
                        result.passed = false;
                    }
                }
            }

            // Check that the last instruction is a terminator (unless empty).
            if !block.instructions.is_empty() {
                let last = block.instructions.last().unwrap();
                if !last.opcode.is_terminator() {
                    result.warnings.push(format!(
                        "BB{}: block does not end with a terminator",
                        bb_idx
                    ));
                }
            }
        }

        result
    }

    /// Print the machine function in a human-readable format.
    pub fn dump(&self) -> String {
        let mut out = String::new();
        out.push_str(&format!("MachineFunction: {}\n", self.name));

        for (bb_idx, block) in self.blocks.iter().enumerate() {
            out.push_str(&format!("bb.{} ({})\n", bb_idx, block.name));

            if !block.successors.is_empty() {
                out.push_str("  successors: ");
                for (i, &succ) in block.successors.iter().enumerate() {
                    if i > 0 {
                        out.push_str(", ");
                    }
                    if succ < self.blocks.len() {
                        out.push_str(&format!("bb.{}", succ));
                    } else {
                        out.push_str(&format!("<invalid {}>", succ));
                    }
                }
                out.push('\n');
            }

            for inst in &block.instructions {
                out.push_str(&format!("  {:?}\n", inst.opcode));
                for (i, op) in inst.operands.iter().enumerate() {
                    match op {
                        MOperand::VReg(v) => {
                            out.push_str(&format!("    op{}: %vreg{}\n", i, v));
                        }
                        MOperand::PhysReg(r) => {
                            out.push_str(&format!("    op{}: $physreg{}\n", i, r));
                        }
                        MOperand::Imm(v) => {
                            out.push_str(&format!("    op{}: #imm {}\n", i, v));
                        }
                        MOperand::Label(name) => {
                            out.push_str(&format!("    op{}: label \"{}\"\n", i, name));
                        }
                        MOperand::Global(name) => {
                            out.push_str(&format!("    op{}: @{}\n", i, name));
                        }
                    }
                }
            }
        }

        out
    }

    /// Get a basic block by name.
    pub fn find_block(&self, name: &str) -> Option<MBBIndex> {
        self.blocks.iter().position(|b| b.name == name)
    }

    /// Remove an instruction from a block.
    pub fn remove_instruction(&mut self, bb_idx: MBBIndex, inst_idx: usize) -> bool {
        if bb_idx >= self.blocks.len() {
            return false;
        }
        let block = &mut self.blocks[bb_idx];
        if inst_idx >= block.instructions.len() {
            return false;
        }
        block.instructions.remove(inst_idx);
        true
    }

    /// Replace an instruction in a block.
    pub fn replace_instruction(
        &mut self,
        bb_idx: MBBIndex,
        inst_idx: usize,
        new_inst: GInstruction,
    ) -> bool {
        if bb_idx >= self.blocks.len() {
            return false;
        }
        let block = &mut self.blocks[bb_idx];
        if inst_idx >= block.instructions.len() {
            return false;
        }
        block.instructions[inst_idx] = new_inst;
        true
    }

    /// Count total virtual registers used.
    pub fn count_vregs(&self) -> usize {
        let mut max_vreg = 0;
        for block in &self.blocks {
            for inst in &block.instructions {
                for op in &inst.operands {
                    if let MOperand::VReg(v) = op {
                        max_vreg = max_vreg.max(*v as usize + 1);
                    }
                }
            }
        }
        max_vreg
    }
}

// ============================================================================
// Register Bank Selection
// ============================================================================

/// Represents a register bank (class of registers).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum RegBank {
    /// General-purpose register bank.
    GPR,
    /// Floating-point register bank.
    FPR,
    /// Condition code register bank.
    CCR,
    /// Vector register bank.
    VecR,
}

impl RegBank {
    /// Returns the size of a register in this bank in bits.
    pub fn default_size(self) -> u32 {
        match self {
            RegBank::GPR => 64,
            RegBank::FPR => 128,
            RegBank::CCR => 1,
            RegBank::VecR => 128,
        }
    }

    /// Returns the name of this register bank.
    pub fn name(self) -> &'static str {
        match self {
            RegBank::GPR => "GPR",
            RegBank::FPR => "FPR",
            RegBank::CCR => "CCR",
            RegBank::VecR => "VecR",
        }
    }
}

/// A mapping from virtual register to its assigned register bank.
#[derive(Debug, Clone)]
pub struct RegBankSelect {
    /// Map from vreg to assigned register bank.
    pub assignments: HashMap<VReg, RegBank>,
    /// Target-specific bank mapping rules.
    pub rules: Vec<BankRule>,
}

/// A rule for assigning a register bank based on the opcode and operand position.
#[derive(Debug, Clone)]
pub struct BankRule {
    /// Opcode this rule applies to.
    pub opcode: GOpcode,
    /// Operand index (0=def, 1+=use).
    pub operand_idx: u32,
    /// The register bank to assign.
    pub bank: RegBank,
}

impl RegBankSelect {
    /// Create a new RegBankSelect.
    pub fn new() -> Self {
        Self {
            assignments: HashMap::new(),
            rules: Vec::new(),
        }
    }

    /// Add a bank assignment rule.
    pub fn add_rule(&mut self, opcode: GOpcode, operand_idx: u32, bank: RegBank) {
        self.rules.push(BankRule {
            opcode,
            operand_idx,
            bank,
        });
    }

    /// Assign register banks to all virtual registers in a function.
    pub fn assign_banks(&mut self, mf: &GMachineFunction) {
        self.assignments.clear();

        for block in &mf.blocks {
            for inst in &block.instructions {
                // Propagate banks from rules
                for rule in &self.rules {
                    if rule.opcode == inst.opcode {
                        if rule.operand_idx == 0 {
                            // Def operand
                            if let Some(def) = inst.def_vreg() {
                                self.assignments.insert(def, rule.bank);
                            }
                        } else {
                            // Use operand
                            let use_idx = (rule.operand_idx - 1) as usize;
                            if use_idx < inst.operands.len() {
                                if let Some(vreg) = inst.operands[use_idx].as_vreg() {
                                    self.assignments.insert(vreg, rule.bank);
                                }
                            }
                        }
                    }
                }

                // Default bank assignment based on opcode class
                if inst.def_vreg().is_some() {
                    let bank = self.default_bank_for_opcode(inst.opcode);
                    if let Some(def) = inst.def_vreg() {
                        self.assignments.entry(def).or_insert(bank);
                    }
                }
            }
        }
    }

    /// Get the default bank for an opcode.
    fn default_bank_for_opcode(&self, opcode: GOpcode) -> RegBank {
        match opcode {
            GOpcode::G_FADD
            | GOpcode::G_FSUB
            | GOpcode::G_FMUL
            | GOpcode::G_FDIV
            | GOpcode::G_FREM
            | GOpcode::G_FNEG
            | GOpcode::G_FABS
            | GOpcode::G_FCEIL
            | GOpcode::G_FFLOOR
            | GOpcode::G_FSQRT
            | GOpcode::G_FMA
            | GOpcode::G_FPOW
            | GOpcode::G_FEXP
            | GOpcode::G_FLOG => RegBank::FPR,
            GOpcode::G_ICMP | GOpcode::G_FCMP => RegBank::CCR,
            _ => RegBank::GPR,
        }
    }

    /// Get the assigned bank for a virtual register.
    pub fn get_bank(&self, vreg: VReg) -> Option<RegBank> {
        self.assignments.get(&vreg).copied()
    }

    /// Create a default GPR+FPR+CCR bank selection.
    pub fn default_config() -> Self {
        let mut sel = Self::new();
        // FP ops produce FPR results
        sel.add_rule(GOpcode::G_FADD, 0, RegBank::FPR);
        sel.add_rule(GOpcode::G_FMUL, 0, RegBank::FPR);
        // FP ops consume FPR operands
        sel.add_rule(GOpcode::G_FADD, 1, RegBank::FPR);
        sel.add_rule(GOpcode::G_FADD, 2, RegBank::FPR);
        // Integer ops use GPR
        sel.add_rule(GOpcode::G_ADD, 0, RegBank::GPR);
        sel.add_rule(GOpcode::G_ADD, 1, RegBank::GPR);
        sel.add_rule(GOpcode::G_ADD, 2, RegBank::GPR);
        // Comparisons produce CCR
        sel.add_rule(GOpcode::G_ICMP, 0, RegBank::CCR);
        sel
    }
}

impl Default for RegBankSelect {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// Instruction Selection (GISel ISel)
// ============================================================================

/// Represents a target-specific machine instruction pattern.
#[derive(Debug, Clone)]
pub struct TargetInstr {
    /// Target-specific opcode.
    pub opcode: u32,
    /// Name of the target instruction.
    pub name: String,
    /// Number of operands.
    pub num_operands: u32,
    /// Whether this instruction is commutable.
    pub is_commutable: bool,
    /// Operand constraints: (is_def, reg_class_id).
    pub operand_constraints: Vec<(bool, u32)>,
}

/// InstructionSelect matches generic MIR instructions to target-specific
/// machine instructions.
#[derive(Debug, Clone)]
pub struct InstructionSelect {
    /// Map from generic opcode to target instruction.
    pub selection_table: HashMap<GOpcode, TargetInstr>,
    /// Fallback target instruction for unsupported generic ops.
    pub fallback: Option<TargetInstr>,
    /// Number of instructions selected.
    pub selected: usize,
}

impl InstructionSelect {
    /// Create a new InstructionSelect.
    pub fn new() -> Self {
        Self {
            selection_table: HashMap::new(),
            fallback: None,
            selected: 0,
        }
    }

    /// Add a selection entry.
    pub fn add_selection(&mut self, generic: GOpcode, target: TargetInstr) {
        self.selection_table.insert(generic, target);
    }

    /// Select target instructions for a function.
    pub fn select(&mut self, mf: &mut GMachineFunction) -> usize {
        self.selected = 0;

        for block in &mut mf.blocks {
            for inst in &mut block.instructions {
                if let Some(target) = self.selection_table.get(&inst.opcode) {
                    // Replace the generic opcode with the target opcode
                    // In a real implementation, this would create a new
                    // target-specific MInst. Here we simulate by counting.
                    self.selected += 1;
                }
            }
        }

        self.selected
    }

    /// Check if a generic opcode has a target selection.
    pub fn has_selection(&self, opcode: GOpcode) -> bool {
        self.selection_table.contains_key(&opcode)
    }

    /// Create a default x86_64 ISel table.
    pub fn x86_64_default() -> Self {
        let mut isel = Self::new();

        // G_ADD → ADD64rr / ADD32rr
        isel.add_selection(
            GOpcode::G_ADD,
            TargetInstr {
                opcode: 0x01,
                name: "ADD".to_string(),
                num_operands: 3,
                is_commutable: true,
                operand_constraints: vec![(true, 0), (false, 0), (false, 0)],
            },
        );

        // G_LOAD → MOVrm
        isel.add_selection(
            GOpcode::G_LOAD,
            TargetInstr {
                opcode: 0x8B,
                name: "MOVrm".to_string(),
                num_operands: 2,
                is_commutable: false,
                operand_constraints: vec![(true, 0), (false, 1)],
            },
        );

        // G_STORE → MOVmr
        isel.add_selection(
            GOpcode::G_STORE,
            TargetInstr {
                opcode: 0x89,
                name: "MOVmr".to_string(),
                num_operands: 2,
                is_commutable: false,
                operand_constraints: vec![(false, 1), (false, 0)],
            },
        );

        isel
    }
}

impl Default for InstructionSelect {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// GI Match Table (Declarative ISel)
// ============================================================================

/// A single entry in the GI match table.
#[derive(Debug, Clone)]
pub struct GIMatchEntry {
    /// Pattern opcode to match.
    pub match_opcode: GOpcode,
    /// Target instruction to emit on match.
    pub emit_opcode: u32,
    /// Predicate that must hold for the match.
    pub predicate: Option<MatchPredicate>,
    /// Operand remapping: (generic_operand_idx → target_operand_idx).
    pub operand_remap: Vec<(u32, u32)>,
}

/// A predicate for match table entries.
#[derive(Debug, Clone)]
pub enum MatchPredicate {
    /// Operand must be a constant immediate.
    IsConstant(u32),
    /// Operand must be a specific register bank.
    IsBank(u32, RegBank),
    /// Type must match a specific size.
    TypeSize(u32, u32),
    /// Always matches.
    Always,
}

/// GIMatchTable implements declarative pattern matching for GlobalISel.
#[derive(Debug, Clone)]
pub struct GIMatchTable {
    /// All match table entries.
    pub entries: Vec<GIMatchEntry>,
    /// Number of successful matches.
    pub matches: usize,
}

impl GIMatchTable {
    /// Create a new empty match table.
    pub fn new() -> Self {
        Self {
            entries: Vec::new(),
            matches: 0,
        }
    }

    /// Add a match entry.
    pub fn add_entry(&mut self, entry: GIMatchEntry) {
        self.entries.push(entry);
    }

    /// Try to match an instruction against the table.
    ///
    /// Returns Some(emit_opcode) if a match is found.
    pub fn try_match(&self, opcode: GOpcode, operands: &[MOperand]) -> Option<u32> {
        for entry in &self.entries {
            if entry.match_opcode != opcode {
                continue;
            }

            // Check predicate
            if let Some(ref pred) = entry.predicate {
                if !self.evaluate_predicate(pred, operands) {
                    continue;
                }
            }

            return Some(entry.emit_opcode);
        }

        None
    }

    /// Evaluate a match predicate against operands.
    fn evaluate_predicate(&self, pred: &MatchPredicate, operands: &[MOperand]) -> bool {
        match pred {
            MatchPredicate::IsConstant(idx) => {
                if (*idx as usize) < operands.len() {
                    operands[*idx as usize].as_imm().is_some()
                } else {
                    false
                }
            }
            MatchPredicate::IsBank(_idx, _bank) => {
                // Bank checking requires RegBankSelect context
                true
            }
            MatchPredicate::TypeSize(_idx, _size) => {
                // Size checking requires type information
                true
            }
            MatchPredicate::Always => true,
        }
    }

    /// Run the match table on all instructions in a function.
    pub fn apply(&mut self, mf: &GMachineFunction) -> usize {
        self.matches = 0;

        for block in &mf.blocks {
            for inst in &block.instructions {
                if self.try_match(inst.opcode, &inst.operands).is_some() {
                    self.matches += 1;
                }
            }
        }

        self.matches
    }

    /// Create a default match table with common patterns.
    pub fn default_table() -> Self {
        let mut table = Self::new();

        // G_ADD with constant → LEA pattern
        table.add_entry(GIMatchEntry {
            match_opcode: GOpcode::G_ADD,
            emit_opcode: 0x8D, // LEA
            predicate: Some(MatchPredicate::IsConstant(1)),
            operand_remap: vec![(0, 0), (1, 1), (2, 2)],
        });

        // G_LOAD → MOV
        table.add_entry(GIMatchEntry {
            match_opcode: GOpcode::G_LOAD,
            emit_opcode: 0x8B, // MOVrm
            predicate: None,
            operand_remap: vec![(0, 0), (1, 1)],
        });

        // G_STORE → MOV
        table.add_entry(GIMatchEntry {
            match_opcode: GOpcode::G_STORE,
            emit_opcode: 0x89, // MOVmr
            predicate: None,
            operand_remap: vec![(0, 1), (1, 0)],
        });

        // G_BR → JMP
        table.add_entry(GIMatchEntry {
            match_opcode: GOpcode::G_BR,
            emit_opcode: 0xE9, // JMP
            predicate: None,
            operand_remap: vec![(0, 0)],
        });

        table
    }
}

impl Default for GIMatchTable {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// Register Class Constraining
// ============================================================================

/// ConstrainRegClass constrains selected virtual registers to specific
/// target register classes after instruction selection.
#[derive(Debug, Clone)]
pub struct ConstrainRegClass {
    /// Map from vreg to constrained register class ID.
    pub constraints: HashMap<VReg, u32>,
    /// Target-specific register class definitions.
    pub reg_classes: Vec<RegClass>,
}

/// A target register class.
#[derive(Debug, Clone)]
pub struct RegClass {
    /// Class ID.
    pub id: u32,
    /// Class name.
    pub name: String,
    /// Available registers in this class.
    pub registers: Vec<u32>,
    /// Size of registers in this class (bits).
    pub reg_size: u32,
    /// Aligned size for spills (bits).
    pub spill_size: u32,
}

impl ConstrainRegClass {
    /// Create a new constraint tracker.
    pub fn new() -> Self {
        Self {
            constraints: HashMap::new(),
            reg_classes: Vec::new(),
        }
    }

    /// Add a register class.
    pub fn add_reg_class(&mut self, rc: RegClass) {
        self.reg_classes.push(rc);
    }

    /// Constrain a virtual register to a specific class.
    pub fn constrain(&mut self, vreg: VReg, class_id: u32) {
        self.constraints.insert(vreg, class_id);
    }

    /// Get the constrained class for a virtual register.
    pub fn get_constraint(&self, vreg: VReg) -> Option<u32> {
        self.constraints.get(&vreg).copied()
    }

    /// Get the register class by ID.
    pub fn get_reg_class(&self, id: u32) -> Option<&RegClass> {
        self.reg_classes.iter().find(|rc| rc.id == id)
    }

    /// Create default x86_64 register classes.
    pub fn x86_64_default() -> Self {
        let mut crc = Self::new();

        // GR64: 64-bit GPRs
        crc.add_reg_class(RegClass {
            id: 0,
            name: "GR64".to_string(),
            registers: vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
            reg_size: 64,
            spill_size: 64,
        });

        // GR32: 32-bit GPRs
        crc.add_reg_class(RegClass {
            id: 1,
            name: "GR32".to_string(),
            registers: vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
            reg_size: 32,
            spill_size: 32,
        });

        // FR64: 64-bit FP registers (XMM)
        crc.add_reg_class(RegClass {
            id: 2,
            name: "FR64".to_string(),
            registers: vec![
                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
            ],
            reg_size: 64,
            spill_size: 64,
        });

        crc
    }
}

impl Default for ConstrainRegClass {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// Post-ISel Combiner
// ============================================================================

/// PostISelCombiner runs target-specific peephole optimizations after
/// instruction selection.
#[derive(Debug, Clone)]
pub struct PostISelCombiner {
    /// Number of combines performed.
    pub num_combined: usize,
    /// Maximum iterations.
    pub max_iterations: usize,
}

impl PostISelCombiner {
    /// Create a new post-ISel combiner.
    pub fn new() -> Self {
        Self {
            num_combined: 0,
            max_iterations: 4,
        }
    }

    /// Run post-ISel combines on a function.
    pub fn combine(&mut self, _mf: &mut GMachineFunction) -> usize {
        self.num_combined = 0;

        // Common post-ISel combines:
        // - Fold G_ADD with zero
        // - Fold G_MUL with one
        // - Fold G_AND with all-ones
        // - Remove redundant G_COPY instructions
        // - Combine adjacent G_LOADs into wider loads

        self.num_combined
    }

    /// Try to combine two adjacent instructions.
    pub fn try_combine_adjacent(
        &self,
        first: &GInstruction,
        second: &GInstruction,
    ) -> Option<GInstruction> {
        // ADD x, 0 → COPY x
        if first.opcode == GOpcode::G_ADD {
            if let Some(MOperand::Imm(0)) = first.operands.get(1) {
                if let Some(src) = first.operands.first() {
                    let mut instr = GInstruction::new(GOpcode::COPY);
                    if let Some(def) = first.def_vreg() {
                        instr.operands.push(MOperand::vreg(def));
                    }
                    instr.operands.push(src.clone());
                    return Some(instr);
                }
            }
        }

        // MUL x, 1 → COPY x
        if first.opcode == GOpcode::G_MUL {
            if let Some(MOperand::Imm(1)) = first.operands.get(1) {
                if let Some(src) = first.operands.first() {
                    let mut instr = GInstruction::new(GOpcode::COPY);
                    if let Some(def) = first.def_vreg() {
                        instr.operands.push(MOperand::vreg(def));
                    }
                    instr.operands.push(src.clone());
                    return Some(instr);
                }
            }
        }

        None
    }
}

impl Default for PostISelCombiner {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// G_LOAD / G_STORE Legalization Helpers
// ============================================================================

/// LoadStoreLegalizer handles legalization of G_LOAD and G_STORE
/// operations for unaligned access, narrow types, and wide types.
#[derive(Debug, Clone)]
pub struct LoadStoreLegalizer {
    /// Maximum supported load width in bits.
    pub max_load_width: u32,
    /// Whether unaligned access is supported.
    pub unaligned_access: bool,
    /// Whether the target is little-endian.
    pub little_endian: bool,
}

impl LoadStoreLegalizer {
    /// Create a new load/store legalizer.
    pub fn new(max_load_width: u32, unaligned_access: bool) -> Self {
        Self {
            max_load_width,
            unaligned_access,
            little_endian: true,
        }
    }

    /// Check if a load of the given bit width needs legalization.
    pub fn needs_legalization(&self, bit_width: u32) -> bool {
        !self.is_legal_width(bit_width)
    }

    /// Check if a bit width is natively supported.
    fn is_legal_width(&self, bit_width: u32) -> bool {
        bit_width == 8
            || bit_width == 16
            || bit_width == 32
            || bit_width == 64
            || (bit_width <= self.max_load_width && bit_width.is_power_of_two())
    }

    /// Legalize a narrow load (e.g., i1 → i8 + trunc).
    pub fn legalize_narrow_load(
        &self,
        addr: VReg,
        bit_width: u32,
    ) -> Vec<(GOpcode, Vec<MOperand>)> {
        let mut seq = Vec::new();

        match bit_width {
            1 => {
                // Load i8, then AND with 1, compare to get i1
                seq.push((
                    GOpcode::G_LOAD,
                    vec![MOperand::vreg(addr), MOperand::imm(8)],
                ));
            }
            w if w < 8 => {
                // Widen to i8
                seq.push((
                    GOpcode::G_LOAD,
                    vec![MOperand::vreg(addr), MOperand::imm(8)],
                ));
            }
            _ => {
                seq.push((
                    GOpcode::G_LOAD,
                    vec![MOperand::vreg(addr), MOperand::imm(bit_width as i64)],
                ));
            }
        }

        seq
    }

    /// Legalize a wide load by splitting into multiple loads.
    /// e.g., i128 → 2 × i64 loads with pointer offset.
    pub fn legalize_wide_load(&self, addr: VReg, bit_width: u32) -> Vec<(GOpcode, Vec<MOperand>)> {
        let mut seq = Vec::new();
        let mut remaining = bit_width;
        let mut offset: i64 = 0;

        while remaining > 0 {
            let chunk = remaining.min(self.max_load_width);
            // Round down to power of two
            let chunk = chunk.next_power_of_two() / 2;
            let chunk = chunk.min(remaining);

            let mut operands = vec![MOperand::vreg(addr)];
            if offset != 0 {
                operands.push(MOperand::imm(offset));
            }
            seq.push((GOpcode::G_LOAD, operands));

            offset += (chunk / 8) as i64;
            remaining -= chunk;
        }

        seq
    }

    /// Legalize an unaligned load by splitting into aligned pieces.
    pub fn legalize_unaligned_load(
        &self,
        addr: VReg,
        bit_width: u32,
    ) -> Vec<(GOpcode, Vec<MOperand>)> {
        if self.unaligned_access {
            // Target supports unaligned: single load
            return vec![(
                GOpcode::G_LOAD,
                vec![MOperand::vreg(addr), MOperand::imm(bit_width as i64)],
            )];
        }

        // Split into byte loads and recombine
        let num_bytes = (bit_width + 7) / 8;
        let mut seq = Vec::new();
        for i in 0..num_bytes {
            let mut operands = vec![MOperand::vreg(addr)];
            if self.little_endian {
                operands.push(MOperand::imm(i as i64));
            } else {
                operands.push(MOperand::imm((num_bytes - 1 - i) as i64));
            }
            seq.push((GOpcode::G_LOAD, operands));
        }
        seq
    }
}

impl Default for LoadStoreLegalizer {
    fn default() -> Self {
        Self::new(64, true)
    }
}

// ============================================================================
// G_CONSTANT Materialization
// ============================================================================

/// ConstantMaterializer handles splitting large constants into
/// sequences that can be materialized on the target.
#[derive(Debug, Clone)]
pub struct ConstantMaterializer {
    /// Maximum immediate width in bits.
    pub max_immediate_bits: u32,
    /// Whether the target has a mov-imm64 instruction.
    pub has_imm64: bool,
}

impl ConstantMaterializer {
    /// Create a new constant materializer.
    pub fn new(max_immediate_bits: u32) -> Self {
        Self {
            max_immediate_bits,
            has_imm64: false,
        }
    }

    /// Check if a constant value can be materialized directly.
    pub fn can_materialize(&self, value: i64) -> bool {
        let abs_val = value.unsigned_abs();
        abs_val < (1u64 << self.max_immediate_bits) || (value == 0) || (self.has_imm64)
    }

    /// Decompose a large constant into materializable chunks.
    ///
    /// Returns a sequence of (opcode, value) pairs that build up
    /// the constant.
    pub fn decompose(&self, value: i64) -> Vec<(GOpcode, i64)> {
        if self.can_materialize(value) {
            return vec![(GOpcode::G_CONSTANT, value)];
        }

        let mut seq = Vec::new();
        let mut remaining = value as u64;
        let mut shift = 0u32;

        while remaining != 0 {
            let chunk = (remaining & ((1u64 << self.max_immediate_bits) - 1)) as i64;
            if chunk != 0 {
                if shift == 0 {
                    seq.push((GOpcode::G_CONSTANT, chunk));
                } else {
                    // MOVK with shift on AArch64, or use SHL+OR
                    seq.push((GOpcode::G_CONSTANT, chunk));
                    seq.push((GOpcode::G_SHL, shift as i64));
                    seq.push((GOpcode::G_OR, 0));
                }
            }
            remaining >>= self.max_immediate_bits;
            shift += self.max_immediate_bits;
        }

        if seq.is_empty() {
            seq.push((GOpcode::G_CONSTANT, 0));
        }

        seq
    }

    /// Count the number of instructions needed to materialize a constant.
    pub fn materialization_cost(&self, value: i64) -> usize {
        self.decompose(value).len()
    }
}

impl Default for ConstantMaterializer {
    fn default() -> Self {
        Self::new(16)
    }
}

// ============================================================================
// G_GEP Lowering
// ============================================================================

/// GEPLowerer decomposes G_GEP (and generic pointer arithmetic)
/// into primitive G_PTR_ADD operations.
#[derive(Debug, Clone)]
pub struct GEPLowerer {
    /// Target pointer size in bits.
    pub pointer_size: u32,
}

impl GEPLowerer {
    /// Create a new GEP lowerer.
    pub fn new(pointer_size: u32) -> Self {
        Self { pointer_size }
    }

    /// Decompose a GEP with multiple indices into a sequence of
    /// G_PTR_ADD instructions.
    ///
    /// Each index i contributes: ptr = G_PTR_ADD ptr, (index[i] * elem_size[i])
    pub fn decompose_gep(
        &self,
        base_ptr: VReg,
        indices: &[(VReg, u32)],
    ) -> Vec<(GOpcode, Vec<MOperand>)> {
        let mut seq = Vec::new();
        let mut current_ptr = base_ptr;

        for &(idx_reg, elem_size) in indices {
            // Multiply index by element size if element_size > 1
            let offset_vreg = if elem_size > 1 {
                // Need a temporary for the multiplication
                let temp = idx_reg.wrapping_add(1000); // dummy temp
                seq.push((
                    GOpcode::G_MUL,
                    vec![
                        MOperand::vreg(temp),
                        MOperand::vreg(idx_reg),
                        MOperand::imm(elem_size as i64),
                    ],
                ));
                temp
            } else {
                idx_reg
            };

            // Add offset to pointer
            let new_ptr = current_ptr.wrapping_add(1); // next ptr vreg
            seq.push((
                GOpcode::G_PTR_ADD,
                vec![
                    MOperand::vreg(new_ptr),
                    MOperand::vreg(current_ptr),
                    MOperand::vreg(offset_vreg),
                ],
            ));
            current_ptr = new_ptr;
        }

        seq
    }

    /// Lower a single GEP operation with variable element sizes.
    pub fn lower_gep(&self, base_ptr: VReg, offset_bytes: i64) -> (GOpcode, Vec<MOperand>) {
        let result = base_ptr.wrapping_add(1);
        (
            GOpcode::G_PTR_ADD,
            vec![
                MOperand::vreg(result),
                MOperand::vreg(base_ptr),
                MOperand::imm(offset_bytes),
            ],
        )
    }
}

impl Default for GEPLowerer {
    fn default() -> Self {
        Self::new(64)
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_moperand_vreg() {
        let op = MOperand::vreg(5);
        assert_eq!(op.as_vreg(), Some(5));
        assert_eq!(op.as_imm(), None);
    }

    #[test]
    fn test_moperand_imm() {
        let op = MOperand::imm(42);
        assert_eq!(op.as_imm(), Some(42));
        assert_eq!(op.as_vreg(), None);
    }

    #[test]
    fn test_moperand_label() {
        let op = MOperand::label("loop");
        assert_eq!(op.as_vreg(), None);
    }

    #[test]
    fn test_gopcode_terminator() {
        assert!(GOpcode::G_BR.is_terminator());
        assert!(GOpcode::G_BRCOND.is_terminator());
        assert!(GOpcode::G_RET.is_terminator());
        assert!(!GOpcode::G_ADD.is_terminator());
    }

    #[test]
    fn test_gopcode_binary_op() {
        assert!(GOpcode::G_ADD.is_binary_op());
        assert!(GOpcode::G_MUL.is_binary_op());
        assert!(!GOpcode::G_BR.is_binary_op());
        assert!(!GOpcode::COPY.is_binary_op());
    }

    #[test]
    fn test_gopcode_commutative() {
        assert!(GOpcode::G_ADD.is_commutative());
        assert!(GOpcode::G_MUL.is_commutative());
        assert!(GOpcode::G_AND.is_commutative());
        assert!(!GOpcode::G_SUB.is_commutative());
        assert!(!GOpcode::G_SDIV.is_commutative());
    }

    #[test]
    fn test_ginstruction_def_and_uses() {
        let inst = GInstruction::with_operands(
            GOpcode::G_ADD,
            vec![MOperand::vreg(0), MOperand::vreg(1), MOperand::vreg(2)],
        );
        assert_eq!(inst.def_vreg(), Some(0));
        assert_eq!(inst.uses().len(), 2);
        assert_eq!(inst.all_operands().len(), 3);
    }

    #[test]
    fn test_ginstruction_no_def() {
        let inst = GInstruction::with_operands(GOpcode::G_BR, vec![MOperand::label("exit")]);
        assert_eq!(inst.def_vreg(), None);
        assert_eq!(inst.uses().len(), 0);
    }

    #[test]
    fn test_gmachine_basic_block() {
        let mut bb = GMachineBasicBlock::new("test".to_string());
        assert_eq!(bb.instruction_count(), 0);
        bb.push_instruction(GInstruction::new(GOpcode::G_ADD));
        assert_eq!(bb.instruction_count(), 1);
    }

    #[test]
    fn test_gmachine_basic_block_successors() {
        let mut bb = GMachineBasicBlock::new("test".to_string());
        bb.add_successor(1);
        bb.add_successor(1); // dedup
        bb.add_successor(2);
        assert_eq!(bb.successors.len(), 2);
    }

    #[test]
    fn test_gmachine_function_new() {
        let mf = GMachineFunction::new("func".to_string());
        assert_eq!(mf.name, "func");
        assert_eq!(mf.block_count(), 0);
        assert_eq!(mf.instruction_count(), 0);
    }

    #[test]
    fn test_gmachine_function_new_vreg() {
        let mut mf = GMachineFunction::new("func".to_string());
        assert_eq!(mf.new_vreg(), 0);
        assert_eq!(mf.new_vreg(), 1);
        assert_eq!(mf.new_vreg(), 2);
    }

    #[test]
    fn test_gmachine_function_push_block() {
        let mut mf = GMachineFunction::new("func".to_string());
        let idx0 = mf.push_block("entry".to_string());
        let idx1 = mf.push_block("loop".to_string());
        assert_eq!(idx0, 0);
        assert_eq!(idx1, 1);
        assert_eq!(mf.block_count(), 2);
    }

    // ---- MachineIRBuilder tests ----

    #[test]
    fn test_builder_new() {
        let builder = MachineIRBuilder::new("test_func");
        assert_eq!(builder.mf.name, "test_func");
        assert_eq!(builder.mf.block_count(), 1); // entry block
        assert_eq!(builder.current_block, 0);
        assert_eq!(builder.insert_point, 0);
    }

    #[test]
    fn test_builder_set_insert_point() {
        let mut builder = MachineIRBuilder::new("test_func");
        let bb1 = builder.new_block("bb1");
        builder.set_insert_point(bb1, 0);
        assert_eq!(builder.current_block, 1);
    }

    #[test]
    fn test_builder_new_vreg() {
        let mut builder = MachineIRBuilder::new("test_func");
        assert_eq!(builder.new_vreg(), 0);
        assert_eq!(builder.new_vreg(), 1);
    }

    #[test]
    fn test_builder_new_block() {
        let mut builder = MachineIRBuilder::new("test_func");
        let bb1 = builder.new_block("loop");
        assert_eq!(bb1, 1);
        assert_eq!(builder.mf.block_count(), 2);
    }

    #[test]
    fn test_build_constant() {
        let mut builder = MachineIRBuilder::new("test_func");
        let dst = builder.build_constant(42);
        assert_eq!(builder.total_instructions(), 1);
        assert!(dst >= 0);
    }

    #[test]
    fn test_build_add() {
        let mut builder = MachineIRBuilder::new("test_func");
        let dst = builder.new_vreg();
        let s1 = builder.build_constant(10);
        let s2 = builder.build_constant(20);
        builder.build_add(dst, s1, s2);
        assert_eq!(builder.total_instructions(), 3);
    }

    #[test]
    fn test_build_sub() {
        let mut builder = MachineIRBuilder::new("test_func");
        let dst = builder.new_vreg();
        builder.build_sub(dst, 1, 2);
        assert_eq!(builder.total_instructions(), 1);
    }

    #[test]
    fn test_build_mul() {
        let mut builder = MachineIRBuilder::new("test_func");
        let dst = builder.new_vreg();
        builder.build_mul(dst, 1, 2);
        assert_eq!(builder.total_instructions(), 1);
    }

    #[test]
    fn test_build_and_or_xor() {
        let mut builder = MachineIRBuilder::new("test_func");
        let d1 = builder.new_vreg();
        let d2 = builder.new_vreg();
        let d3 = builder.new_vreg();
        builder.build_and(d1, 1, 2);
        builder.build_or(d2, 1, 2);
        builder.build_xor(d3, 1, 2);
        assert_eq!(builder.total_instructions(), 3);
    }

    #[test]
    fn test_build_load_store() {
        let mut builder = MachineIRBuilder::new("test_func");
        let addr = builder.build_constant(0);
        let dst = builder.new_vreg();
        builder.build_load(dst, addr);
        let val = builder.build_constant(99);
        builder.build_store(val, addr);
        assert_eq!(builder.total_instructions(), 4);
    }

    #[test]
    fn test_build_br() {
        let mut builder = MachineIRBuilder::new("test_func");
        let target = builder.new_block("target");
        builder.build_br(target);
        // Should have successor set
        assert!(builder.mf.blocks[0].successors.contains(&target));
    }

    #[test]
    fn test_build_cond_br() {
        let mut builder = MachineIRBuilder::new("test_func");
        let cond = builder.build_constant(1);
        let t_bb = builder.new_block("then");
        let f_bb = builder.new_block("else");
        builder.build_cond_br(cond, t_bb, f_bb);
        let block = &builder.mf.blocks[0];
        assert!(block.successors.contains(&t_bb));
        assert!(block.successors.contains(&f_bb));
    }

    #[test]
    fn test_build_ret() {
        let mut builder = MachineIRBuilder::new("test_func");
        let val = builder.build_constant(0);
        builder.build_ret(val);
        assert_eq!(builder.total_instructions(), 2);
    }

    #[test]
    fn test_set_insert_point_to_end() {
        let mut builder = MachineIRBuilder::new("test_func");
        let _ = builder.build_constant(1);
        let _ = builder.build_constant(2);
        // Insert point should have advanced
        assert_eq!(builder.insert_point, 2);
        builder.set_insert_point_to_end();
        assert_eq!(builder.insert_point, 2); // already at end
    }

    #[test]
    fn test_get_mf() {
        let builder = MachineIRBuilder::new("test_func");
        let mf = builder.get_mf();
        assert_eq!(mf.name, "test_func");
    }

    #[test]
    fn test_get_mf_mut() {
        let mut builder = MachineIRBuilder::new("test_func");
        builder.get_mf_mut().next_vreg = 100;
        assert_eq!(builder.new_vreg(), 100);
    }

    #[test]
    fn test_total_instructions() {
        let mut builder = MachineIRBuilder::new("test_func");
        assert_eq!(builder.total_instructions(), 0);
        let _ = builder.build_constant(1);
        let _ = builder.build_constant(2);
        let _ = builder.build_constant(3);
        assert_eq!(builder.total_instructions(), 3);
    }

    // --- RegBank Tests ---

    #[test]
    fn test_reg_bank_default_size() {
        assert_eq!(RegBank::GPR.default_size(), 64);
        assert_eq!(RegBank::FPR.default_size(), 128);
        assert_eq!(RegBank::CCR.default_size(), 1);
    }

    #[test]
    fn test_reg_bank_select_new() {
        let sel = RegBankSelect::new();
        assert!(sel.assignments.is_empty());
        assert!(sel.rules.is_empty());
    }

    #[test]
    fn test_reg_bank_select_default_config() {
        let sel = RegBankSelect::default_config();
        assert!(!sel.rules.is_empty());
    }

    // --- Instruction Select Tests ---

    #[test]
    fn test_instruction_select_new() {
        let isel = InstructionSelect::new();
        assert_eq!(isel.selected, 0);
        assert!(isel.selection_table.is_empty());
    }

    #[test]
    fn test_instruction_select_has_selection() {
        let isel = InstructionSelect::x86_64_default();
        assert!(isel.has_selection(GOpcode::G_ADD));
        assert!(!isel.has_selection(GOpcode::G_FSQRT));
    }

    // --- GI Match Table Tests ---

    #[test]
    fn test_match_table_new() {
        let table = GIMatchTable::new();
        assert!(table.entries.is_empty());
    }

    #[test]
    fn test_match_table_try_match() {
        let table = GIMatchTable::default_table();
        let result = table.try_match(GOpcode::G_ADD, &[MOperand::vreg(0), MOperand::imm(5)]);
        assert!(result.is_some());
    }

    #[test]
    fn test_match_table_no_match() {
        let table = GIMatchTable::default_table();
        let result = table.try_match(GOpcode::G_FSQRT, &[]);
        assert!(result.is_none());
    }

    // --- ConstrainRegClass Tests ---

    #[test]
    fn test_constrain_reg_class_new() {
        let crc = ConstrainRegClass::new();
        assert!(crc.reg_classes.is_empty());
    }

    #[test]
    fn test_constrain_reg_class_x86_64() {
        let crc = ConstrainRegClass::x86_64_default();
        assert_eq!(crc.reg_classes.len(), 3);
        assert_eq!(crc.reg_classes[0].name, "GR64");
        assert_eq!(crc.reg_classes[2].name, "FR64");
    }

    // --- Post-ISel Combiner Tests ---

    #[test]
    fn test_post_isel_combiner_new() {
        let combiner = PostISelCombiner::new();
        assert_eq!(combiner.num_combined, 0);
        assert_eq!(combiner.max_iterations, 4);
    }

    #[test]
    fn test_post_isel_combine_add_zero() {
        let combiner = PostISelCombiner::new();
        let first = GInstruction::new(
            GOpcode::G_ADD,
            10,
            vec![MOperand::vreg(5), MOperand::imm(0)],
        );
        let second = GInstruction::new(GOpcode::G_STORE, 0, vec![]);
        let result = combiner.try_combine_adjacent(&first, &second);
        assert!(result.is_some());
    }

    // --- LoadStoreLegalizer Tests ---

    #[test]
    fn test_ls_legalizer_new() {
        let lsl = LoadStoreLegalizer::new(64, true);
        assert_eq!(lsl.max_load_width, 64);
        assert!(lsl.unaligned_access);
    }

    #[test]
    fn test_ls_legalizer_needs_legalization() {
        let lsl = LoadStoreLegalizer::new(64, true);
        assert!(!lsl.needs_legalization(32));
        assert!(lsl.needs_legalization(1));
        assert!(lsl.needs_legalization(128));
    }

    // --- ConstantMaterializer Tests ---

    #[test]
    fn test_constant_materializer_new() {
        let cm = ConstantMaterializer::new(16);
        assert_eq!(cm.max_immediate_bits, 16);
    }

    #[test]
    fn test_constant_materializer_can_materialize() {
        let cm = ConstantMaterializer::new(16);
        assert!(cm.can_materialize(0));
        assert!(cm.can_materialize(65535));
        assert!(!cm.can_materialize(65536));
    }

    #[test]
    fn test_constant_materializer_decompose() {
        let cm = ConstantMaterializer::new(16);
        let seq = cm.decompose(0x12345678);
        // Large constant should need multiple instructions
        assert!(seq.len() >= 1);
    }

    // --- GEPLowerer Tests ---

    #[test]
    fn test_gep_lowerer_new() {
        let gl = GEPLowerer::new(64);
        assert_eq!(gl.pointer_size, 64);
    }

    #[test]
    fn test_gep_lowerer_lower_gep() {
        let gl = GEPLowerer::new(64);
        let (opcode, operands) = gl.lower_gep(100, 16);
        assert_eq!(opcode, GOpcode::G_PTR_ADD);
        assert_eq!(operands.len(), 3);
    }

    #[test]
    fn test_gep_lowerer_decompose_gep() {
        let gl = GEPLowerer::new(64);
        let indices = vec![(200, 4), (201, 8)];
        let seq = gl.decompose_gep(100, &indices);
        // Should produce instructions for each index
        assert!(!seq.is_empty());
    }
}