//! Structural reconstruction for binary RIL using existing allocator indexes.

//!

//! Register definitions use the existing byte-keyed dictionary. Numeric keys

//! have stable arena storage. Branch edges rebuild unique predecessors.

//! These checks establish structure, not dominance, provenance, or type safety.

use std::collections::dict;

use std::lang::il;

use std::lang::gen::regalloc::liveness;

/// State for counting and then materializing unique predecessor lists.

record Edges: Copy {

    /// Decoder-owned blocks.

    blocks: *mut [il::Block],

    /// Incoming counts, or absolute insertion cursors during the second pass.

    counts: *mut [u32],

    /// Last source block seen for each target; duplicate edges are ignored.

    last: *mut [u32],

    /// Contiguous mutable storage backing all published predecessor slices.

    predecessors: *mut [u32],

    /// Whether predecessor storage has been allocated and should be filled.

    fill: bool,

}

/// Defined-register index and the result of inspecting an instruction's operands.

record Registers: Copy {

    /// Dictionary whose keys are the binary u32 register indexes.

    definitions: dict::Dict,

    /// Every operand seen so far has a corresponding definition.

    valid: bool,

}

/// Insert a unique definition within the shared allocator's register capacity.

fn define(map: *mut dict::Dict, numbers: *mut [u32], index: u32, reg: il::Reg, offset: u32) throws (super::Error) {

    if reg.n >= liveness::MAX_SSA_REGS { throw super::error(offset, "RIL register exceeds allocator capacity"); }

    set numbers[index] = reg.n;

    let key = @sliceOf(&numbers[index] as *u8, @sizeOf(u32));

    if dict::get(map, key) <> nil { throw super::error(offset, "duplicate RIL register definition"); }

    dict::insert(map, key, index as i32);

}

/// Check one operand through the shared IL register visitor.

fn operand(reg: il::Reg, context: *mut opaque) {

    let state = context as *mut Registers;

    let number = reg.n;

    let key = @sliceOf(&number as *u8, @sizeOf(u32));

    if dict::get(&state.definitions, key) == nil { set state.valid = false; }

}

/// Identify the terminators used by existing lowering and instruction selection.

fn terminator(value: il::Instr) -> bool {

    match value {

        case il::Instr::Ret { .. }, il::Instr::Jmp { .. }, il::Instr::Br { .. },

             il::Instr::Switch { .. }, il::Instr::Unreachable => return true,

        else => return false,

    }

}

/// Check a target and its arity, then count or emit one unique predecessor.

fn edge(e: *mut Edges, source: u32, target: u32, count: u32, offset: u32) throws (super::Error) {

    if target >= e.blocks.len { throw super::error(offset, "RIL block target out of range"); }

    let block = &e.blocks[target];

    if count <> block.params.len { throw super::error(offset, "RIL branch argument count mismatch"); }

    if block.instrs.len == 0 { throw super::error(offset, "RIL branch targets an empty block"); }

    if e.last[target] == source { return; }

    set e.last[target] = source;

    if e.fill { set e.predecessors[e.counts[target]] = source; }

    set e.counts[target] += 1;

}

/// Traverse explicit branch fields, including switch default and case edges.

fn edges(e: *mut Edges, source: u32, value: il::Instr, offset: u32) throws (super::Error) {

    match value {

        case il::Instr::Jmp { target, args } => try edge(e, source, target, args.len, offset),

        case il::Instr::Br { thenTarget, thenArgs, elseTarget, elseArgs, .. } => {

            try edge(e, source, thenTarget, thenArgs.len, offset);

            try edge(e, source, elseTarget, elseArgs.len, offset);

        }

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

            try edge(e, source, defaultTarget, defaultArgs.len, offset);

            for item in cases { try edge(e, source, item.target, item.args.len, offset); }

        }

        else => {},

    }

}

/// Reconstruct allocator metadata while retaining decoder ownership of blocks.

/// Existing register indexes and immutable argument slices are preserved.

export fn reconstruct(r: *mut super::Reader, func: *mut il::Fn, blocks: *mut [il::Block], offset: u32) throws (super::Error) {

    if func.isExtern {

        if blocks.len <> 0 { throw super::error(offset, "extern RIL function has a body"); }

    } else if blocks.len == 0 or blocks[0].instrs.len == 0 {

        throw super::error(offset, "RIL function has no entry block instructions");

    }

    let mut names = try super::dictionary(r.arena, blocks.len, offset);

    let mut definitions = func.params.len as u64;

    for block, i in blocks {

        if dict::get(&names, block.label) <> nil { throw super::error(offset, "duplicate RIL block label"); }

        dict::insert(&mut names, block.label, i as i32);

        set definitions += block.params.len as u64;

        for item in block.instrs { if il::instrDst(item) <> nil { set definitions += 1; } }

    }

    if definitions > liveness::MAX_SSA_REGS as u64 {

        throw super::error(offset, "RIL function exceeds allocator register capacity");

    }

    let numbers = try super::storage(r.arena, @sizeOf(u32), @alignOf(u32), definitions as u32, offset) as *mut [u32];

    let mut map = try super::dictionary(r.arena, definitions as u32, offset);

    let mut index: u32 = 0;

    for param in func.params {

        try define(&mut map, numbers, index, param.value, offset);

        set index += 1;

    }

    for block in blocks {

        for param in block.params {

            try define(&mut map, numbers, index, param.value, offset);

            set index += 1;

        }

        for item, i in block.instrs {

            if let dst = il::instrDst(item) {

                try define(&mut map, numbers, index, dst, block.locs[i].offset);

                set index += 1;

            }

        }

    }

    let counts = try super::storage(r.arena, @sizeOf(u32), @alignOf(u32), blocks.len, offset) as *mut [u32];

    let last = try super::storage(r.arena, @sizeOf(u32), @alignOf(u32), blocks.len, offset) as *mut [u32];

    for i in 0..blocks.len { set counts[i] = 0; set last[i] = 0xFFFFFFFF; }

    let mut e = Edges { blocks, counts, last, predecessors: &mut [], fill: false };

    let mut registers = Registers { definitions: map, valid: true };

    for block, b in blocks {

        for item, i in block.instrs {

            let pos = block.locs[i].offset;

            if terminator(item) and i + 1 <> block.instrs.len { throw super::error(pos, "RIL instruction follows a terminator"); }

            if not terminator(item) and i + 1 == block.instrs.len { throw super::error(pos, "RIL block is missing a terminator"); }

            if il::isCall(item) { set func.isLeaf = false; }

            try edges(&mut e, b, item, pos);

            il::forEachReg(item, operand, &mut registers as *mut opaque);

            if not registers.valid { throw super::error(pos, "undefined RIL register"); }

        }

    }

    let mut total: u64 = 0;

    for count in counts { set total += count as u64; }

    if total > 0xFFFFFFFF { throw super::error(offset, "too many RIL control-flow edges"); }

    set e.predecessors = try super::storage(r.arena, @sizeOf(u32), @alignOf(u32), total as u32, offset) as *mut [u32];

    let mut start: u32 = 0;

    for i in 0..blocks.len {

        let end = start + counts[i];

        set blocks[i].preds = &e.predecessors[start..end];

        set counts[i] = start;

        set last[i] = 0xFFFFFFFF;

        set start = end;

    }

    set e.fill = true;

    for block, b in blocks {

        for item, i in block.instrs { try edges(&mut e, b, item, block.locs[i].offset); }

    }

    // Binary offsets identify decoding errors, not source-language locations.

    for i in 0..blocks.len { set blocks[i].locs = &[]; }

}