//! Register allocator.

//!

//! Coordinates the two phases of register allocation:

//! 1. `spill`: Determine spill slots and register class constraints.

//! 2. `assign`: Map SSA values to physical registers.

//!

//! Spill pass focuses on *what* to spill and call-clobber policy.

//! Assign pass focuses on *where* to put values.

//! Neither pass can fail if the other did its job correctly.

//!

//! [`il`] -> [`liveness`] -> [`spill`] -> [`assign`] -> [`AllocResult`].

//!

//! Note that the IL is not modified. The allocator produces a mapping that

//! instruction selection uses to emit physical registers. Spilled values are

//! handled by [`isel`] inserting loads/stores.

export mod liveness;

export mod spill;

export mod assign;

use std::lang::il;

use std::lang::alloc;

/// Target configuration for register allocation.

export record TargetConfig: Copy {

    /// List of allocatable physical registers.

    /// Order determines allocation preference.

    allocatable: *[super::Reg],

    /// Function argument registers.

    argRegs: *[super::Reg],

    /// Callee-saved registers.

    calleeSaved: *[super::Reg],

    /// Size of a spill slot in bytes.

    slotSize: u32,

}

/// Complete register allocation result.

export record AllocResult: 'scratch + Copy {

    /// SSA register to physical register mapping.

    assignments: &'scratch [?super::Reg],

    /// Spill slot information.

    spill: spill::SpillInfo 'scratch,

    /// Bitmask of used callee-saved registers.

    usedCalleeSaved: u32,

}

/// Run register allocation on a function.

///

/// Returns a mapping from SSA registers to physical registers, plus

/// spill information.

export unsafe fn allocate 'scratch (

    func: &il::Fn,

    config: &TargetConfig,

    storage: &Session 'scratch

) -> AllocResult 'scratch throws (alloc::AllocError) {

    // Phase 1: Liveness analysis.

    let live = try liveness::analyze(func, storage);

    // Phase 2: Spill analysis (determine which values need stack slots).

    let spillInfo = try spill::analyze(func, &live, config.allocatable.len, config.calleeSaved.len, config.slotSize, storage);

    // Phase 3: Register assignment (map SSA registers to physical registers).

    let assignInfo = try assign::assign(func, &live, &spillInfo, config, storage);

    return AllocResult 'scratch {

        assignments: assignInfo.assignments,

        spill: spillInfo,

        usedCalleeSaved: assignInfo.usedCalleeSaved,

    };

}