//! Immutable, region-bound IL for analysis and instruction selection.

//!

//! Publication owns instruction and analysis tables. Original node pointers

//! identify source nodes. Symbol names use immutable IL symbol storage.

use std::lang::alloc;

use std::lang::il;

/// Largest element count represented by an analysis slice.

constant MAX_ELEMENTS: u32 = 0xffffffff;

/// Published function tables within one analysis lifetime.

export record Function: 'view + Copy {

    /// Immutable symbol name.

    name: *[u8],

    /// Whether the function makes no calls.

    isLeaf: bool,

    /// Function parameter definitions.

    params: &'view [il::Param],

    /// Blocks in source order.

    blocks: &'view [Block 'view],

}

/// Read-only block tables and their original identity.

export record Block: 'view + Copy {

    /// Original block pointer for imported code, used only for identity comparisons.

    identity: ?*unsafe il::Block,

    /// Block parameter definitions.

    params: &'view [il::Param],

    /// Published instruction descriptors.

    instructions: &'view [Instruction 'view],

    /// Source locations in instruction order, or an empty slice without debug data.

    locations: &'view [il::SrcLoc],

    /// Loop nesting depth for cost weighting.

    loopDepth: u32,

}

/// An instruction and its immutable register-allocation inputs.

export opaque record Instruction: 'view + Copy {

    /// Original instruction pointer for imported code, used only for identity comparisons.

    identity: ?*unsafe il::Instr,

    /// Instruction operands with owned variable-length tables.

    code: &'view Code 'view,

    /// Destination register, when the instruction defines a value.

    destination: ?il::Reg,

    /// Whether the instruction has call-clobber semantics.

    isCall: bool,

    /// Source registers in operand order, including repeated uses.

    operands: &'view [il::Reg],

    /// Successor block positions in branch order.

    targets: &'view [u32],

}

/// Instruction data with region-bound call and branch tables.

export union Code: 'view + Copy {

    /// An instruction whose operands are all inline.

    Fixed(il::Instr),

    /// An unconditional branch and its argument values.

    Jmp {

        /// Destination block position.

        target: u32,

        /// Values supplied to the destination parameters.

        args: &'view [il::Val],

    },

    /// A comparison and its two outgoing edges.

    Br {

        /// Comparison operation.

        op: il::CmpOp,

        /// Comparison width.

        typ: il::Type,

        /// Left comparison operand.

        a: il::Val,

        /// Right comparison operand.

        b: il::Val,

        /// Destination when the comparison succeeds.

        thenTarget: u32,

        /// Values for the successful edge.

        thenArgs: &'view [il::Val],

        /// Destination when the comparison fails.

        elseTarget: u32,

        /// Values for the failed edge.

        elseArgs: &'view [il::Val],

    },

    /// A value-based branch table.

    Switch {

        /// Value to compare with the cases.

        val: il::Val,

        /// Destination when no case matches.

        defaultTarget: u32,

        /// Values supplied to the default destination.

        defaultArgs: &'view [il::Val],

        /// Cases in comparison order.

        cases: &'view [SwitchCase 'view],

    },

    /// A function call and its argument values.

    Call {

        /// Return value width.

        retTy: il::Type,

        /// Register for the return value, if used.

        dst: ?il::Reg,

        /// Function symbol or address.

        func: il::Val,

        /// Values supplied to the function.

        args: &'view [il::Val],

    },

}

/// One switch comparison and its outgoing edge.

export record SwitchCase: 'view + Copy {

    /// Value that selects this case.

    value: i64,

    /// Destination block position.

    target: u32,

    /// Values supplied to the destination parameters.

    args: &'view [il::Val],

}

/// Copy IL tables from valid IL into session-owned immutable storage.

/// All source tables and nested arrays must remain valid during this call.

/// Original node pointers are identity values, not published storage borrows.

export unsafe fn publish 'view (function: &il::Fn, storage: &Session 'view)

    -> Function 'view throws (alloc::AllocError)

{

    let params = try storage.copy(function.params);

    let blocks: &[il::Block] = function.blocks;

    if blocks.len == 0 {

        let none: [Block 'view; 0] = [];

        return Function 'view { name: function.name, isLeaf: function.isLeaf,

            params, blocks: try storage.copy(&none[..]) };

    }

    let first = try publishBlock(&blocks[0], storage);

    let views = try storage.fill(first, blocks.len);

    for i in 1..blocks.len {

        set views[i] = try publishBlock(&blocks[i], storage);

    }

    return Function 'view { name: function.name, isLeaf: function.isLeaf,

        params, blocks: &views[..] };

}

/// Copy block definitions and each instruction's analysis tables.

unsafe fn publishBlock 'view (block: &il::Block, storage: &Session 'view)

    -> Block 'view throws (alloc::AllocError)

{

    let params = try storage.copy(block.params);

    let locations = try storage.copy(block.locs);

    let instructions: &[il::Instr] = block.instrs;

    if instructions.len == 0 {

        let none: [Instruction 'view; 0] = [];

        return Block 'view { identity: block as *unsafe il::Block, params,

            instructions: try storage.copy(&none[..]), locations, loopDepth: block.loopDepth };

    }

    let first = try publishInstruction(&instructions[0], storage);

    let views = try storage.fill(first, instructions.len);

    for i in 1..instructions.len {

        set views[i] = try publishInstruction(&instructions[i], storage);

    }

    return Block 'view { identity: block as *unsafe il::Block, params,

        instructions: &views[..], locations, loopDepth: block.loopDepth };

}

/// Import an instruction and construct its checked analysis tables.

unsafe fn publishInstruction 'view (source: &il::Instr, storage: &Session 'view)

    -> Instruction 'view throws (alloc::AllocError)

{

    let code = try storage.new(try publishCode(source, storage));

    return try buildInstruction(code, source as *unsafe il::Instr, storage);

}

/// Construct instruction metadata from immutable, region-owned operands.

/// The source identity is retained as a value and is never dereferenced.

export fn buildInstruction 'view (

    code: &'view Code 'view,

    identity: ?*unsafe il::Instr,

    storage: &Session 'view

) -> Instruction 'view throws (alloc::AllocError) {

    let noTargets: [u32; 0] = [];

    let mut targets: &'view [u32] = try storage.copy(&noTargets[..]);

    let mut count: u64 = 0;

    let mut destination: ?il::Reg = nil;

    let mut isCall = false;

    match code {

        case Code::Fixed(fixed) => {

            let cursor = il::registers(fixed);

            assert not cursor.arguments, "buildInstruction: expected inline operands";

            set count = cursor.count as u64;

            set destination = il::instrDst(*fixed);

            set isCall = il::isCall(*fixed);

        },

        case Code::Call { dst, func, args, .. } => {

            let prefix = [*func];

            set count = registerCount(&prefix[..]) + registerCount(*args);

            set destination = *dst;

            set isCall = true;

        },

        case Code::Jmp { target, args } => {

            set count = registerCount(*args);

            set targets = try storage.fill(*target, 1);

        },

        case Code::Br { a, b, thenTarget, thenArgs, elseTarget, elseArgs, .. } => {

            let prefix = [*a, *b];

            set count = registerCount(&prefix[..]) + registerCount(*thenArgs) + registerCount(*elseArgs);

            let edges = try storage.fill(*thenTarget, 2);

            set edges[1] = *elseTarget;

            set targets = &edges[..];

        },

        case Code::Switch { val, defaultTarget, defaultArgs, cases } => {

            let prefix = [*val];

            set count = registerCount(&prefix[..]) + registerCount(*defaultArgs);

            if cases.len == MAX_ELEMENTS {

                throw alloc::AllocError::OutOfMemory;

            }

            let edges = try storage.fill(*defaultTarget, cases.len + 1);

            for item, i in *cases {

                set edges[i + 1] = item.target;

                set count += registerCount(item.args);

            }

            set targets = &edges[..];

        },

    }

    if count > MAX_ELEMENTS as u64 {

        throw alloc::AllocError::OutOfMemory;

    }

    let operands = try storage.fill(il::Reg { n: 0 }, count as u32);

    let mut written: u32 = 0;

    match code {

        case Code::Fixed(fixed) => {

            let cursor = il::registers(fixed);

            for i in 0..cursor.count {

                set operands[i] = cursor.fixed[i];

            }

            set written = cursor.count;

        },

        case Code::Call { func, args, .. } => {

            let prefix = [*func];

            set written = copyRegisters(&prefix[..], operands, 0);

            set written = copyRegisters(*args, operands, written);

        },

        case Code::Jmp { args, .. } => set written = copyRegisters(*args, operands, 0),

        case Code::Br { a, b, thenArgs, elseArgs, .. } => {

            let prefix = [*a, *b];

            set written = copyRegisters(&prefix[..], operands, 0);

            set written = copyRegisters(*thenArgs, operands, written);

            set written = copyRegisters(*elseArgs, operands, written);

        },

        case Code::Switch { val, defaultArgs, cases, .. } => {

            let prefix = [*val];

            set written = copyRegisters(&prefix[..], operands, 0);

            set written = copyRegisters(*defaultArgs, operands, written);

            for item in *cases {

                set written = copyRegisters(item.args, operands, written);

            }

        },

    }

    assert written == operands.len, "buildInstruction: operand count changed";

    return Instruction 'view { identity, code, destination, isCall,

        operands: &operands[..], targets };

}

/// Count source registers in one operand group, including repeated uses.

fn registerCount(values: &[il::Val]) -> u64 {

    let mut count: u64 = 0;

    for value in values {

        if let case il::Val::Reg(_) = value {

            set count += 1;

        }

    }

    return count;

}

/// Write source registers at an offset and return the next free position.

fn copyRegisters(values: &[il::Val], output: &mut [il::Reg], offset: u32) -> u32 {

    let mut next = offset;

    for value in values {

        if let case il::Val::Reg(reg) = value {

            set output[next] = reg;

            set next += 1;

        }

    }

    return next;

}

/// Copy the variable-length operands of an instruction into the session.

unsafe fn publishCode 'view (source: &il::Instr, storage: &Session 'view)

    -> Code 'view throws (alloc::AllocError)

{

    match *source {

        case il::Instr::Jmp { target, args } => {

            return Code 'view::Jmp { target, args: try storage.copy(args) };

        },

        case il::Instr::Br { op, typ, a, b, thenTarget, thenArgs, elseTarget, elseArgs } => {

            return Code 'view::Br { op, typ, a, b, thenTarget,

                thenArgs: try storage.copy(thenArgs), elseTarget,

                elseArgs: try storage.copy(elseArgs) };

        },

        case il::Instr::Call { retTy, dst, func, args } => {

            return Code 'view::Call { retTy, dst, func, args: try storage.copy(args) };

        },

        case il::Instr::Switch { val, defaultTarget, defaultArgs, cases } => {

            let defaultArgs = try storage.copy(defaultArgs);

            let cases: &[il::SwitchCase] = cases;

            if cases.len == 0 {

                let none: [SwitchCase 'view; 0] = [];

                return Code 'view::Switch { val, defaultTarget, defaultArgs,

                    cases: try storage.copy(&none[..]) };

            }

            let first = SwitchCase 'view { value: cases[0].value, target: cases[0].target,

                args: try storage.copy(cases[0].args) };

            let views = try storage.fill(first, cases.len);

            for i in 1..cases.len {

                set views[i] = SwitchCase 'view { value: cases[i].value, target: cases[i].target,

                    args: try storage.copy(cases[i].args) };

            }

            return Code 'view::Switch { val, defaultTarget, defaultArgs, cases: &views[..] };

        },

        else => return Code 'view::Fixed(*source),

    }

}

/// Return the instruction data with session-owned operand tables.

export fn code 'view (instruction: &Instruction 'view) -> &'view Code 'view {

    return instruction.code;

}

/// Return the original instruction pointer when the instruction was imported.

export fn identity 'view (instruction: &Instruction 'view) -> ?*unsafe il::Instr {

    return instruction.identity;

}

/// Return an instruction's destination register.

export fn destination 'view (instruction: &Instruction 'view) -> ?il::Reg {

    return instruction.destination;

}

/// Check whether an instruction has call-clobber semantics.

export fn isCall 'view (instruction: &Instruction 'view) -> bool {

    return instruction.isCall;

}

/// Borrow successor positions in branch order, including repeated targets.

export fn successors 'view (instruction: &Instruction 'view) -> &'view [u32] {

    return instruction.targets;

}

/// Borrow source registers in operand order, including repeated uses.

export fn registers 'view (instruction: &Instruction 'view) -> &'view [il::Reg] {

    return instruction.operands;

}