//! Binary data, function and block records built directly from shared RIL.

//!

//! Data: symbol:u32, size:u32, alignment:u32, flags:u8 (readonly bit 0,

//! zero-init bit 1), values:list. Each value is count:u32 then item tag:u8:

//! Val=0 (type:u8, bits:u64), Sym=1 (symbol:u32), Fn=2 (symbol:u32),

//! Str=3 (bytes:string), Undef=4 (one zero/padding byte per repetition).

//! Function: symbol:u32, return type:u8, extern:bool, params:list, blocks:list.

//! Parameter: register:u32, type:u8. Block: label:string, loopDepth:u32,

//! params:list, instructions:list. Debug locations are deliberately omitted.

use std::lang::il;

use super::instructions;

use super::structure;

/// Serialize typed parameters with their original register identifiers.

fn putParams(w: *mut super::Writer, params: *[il::Param]) throws (super::Error) {

    try super::put32(w, params.len);

    for param in params {

        try super::put32(w, param.value.n);

        try instructions::putType(w, param.type);

    }

}

/// Decode parameters into caller-owned storage.

fn getParams(r: *mut super::Reader) -> *[il::Param] throws (super::Error) {

    let count = try super::count(r, 5);

    let params = try super::storage(r.arena, @sizeOf(il::Param), @alignOf(il::Param), count, r.offset) as *mut [il::Param];

    for i in 0..count {

        let value = try instructions::getReg(r);

        let typ = try instructions::getType(r);

        set params[i] = il::Param { value, type: typ };

    }

    return params;

}

/// Serialize one data declaration including zero repetition counts and flags.

export fn putData(w: *mut super::Writer, data: *il::Data) throws (super::Error) {

    try checkData(data, w.offset);

    try super::putSymbol(w, data.name, 1);

    try super::put32(w, data.size);

    try super::put32(w, data.alignment);

    let mut flags: u8 = 0;

    if data.readOnly { set flags |= 1; }

    if data.isZeroInit { set flags |= 2; }

    try super::put8(w, flags);

    try super::put32(w, data.values.len);

    for value in data.values {

        try super::put32(w, value.count);

        match value.item {

            case il::DataItem::Val { typ, val } => {

                try super::put8(w, 0); try instructions::putType(w, typ); try super::put64(w, val as u64);

            }

            case il::DataItem::Sym(name) => { try super::put8(w, 1); try super::putSymbol(w, name, 1); }

            case il::DataItem::Fn(name) => { try super::put8(w, 2); try super::putSymbol(w, name, 2); }

            case il::DataItem::Str(bytes) => { try super::put8(w, 3); try super::putString(w, bytes); }

            case il::DataItem::Undef => try super::put8(w, 4),

        }

    }

}

/// Decode one initializer item with its exact explicit discriminant.

fn getItem(r: *mut super::Reader) -> il::DataItem throws (super::Error) {

    let offset = r.offset;

    match try super::get8(r) {

        case 0 => {

            let typ = try instructions::getType(r);

            let val = (try super::get64(r)) as i64;

            return il::DataItem::Val { typ, val };

        }

        case 1 => return il::DataItem::Sym(try super::getSymbol(r, 1)),

        case 2 => return il::DataItem::Fn(try super::getSymbol(r, 2)),

        case 3 => return il::DataItem::Str(try super::getString(r)),

        case 4 => return il::DataItem::Undef,

        else => throw super::error(offset, "invalid RIL data item tag"),

    }

}

/// Decode and structurally validate a data record before native emission.

export fn getData(r: *mut super::Reader) -> il::Data throws (super::Error) {

    let offset = r.offset;

    let name = try super::declaration(r, 1);

    let size = try super::get32(r);

    let alignment = try instructions::getAlignment(r);

    let flagOffset = r.offset;

    let flags = try super::get8(r);

    if flags > 3 { throw super::error(flagOffset, "unknown RIL data flags"); }

    let count = try super::count(r, 5);

    let values = try super::storage(r.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), count, r.offset) as *mut [il::DataValue];

    for i in 0..count {

        let repeat = try super::get32(r);

        let item = try getItem(r);

        set values[i] = il::DataValue { item, count: repeat };

    }

    let data = il::Data { name, size, alignment, readOnly: (flags & 1) <> 0, isZeroInit: (flags & 2) <> 0, values };

    try checkData(&data, offset);

    return data;

}

/// Bound initializer byte arithmetic against the declared extent. A zero-init

/// flag may not discard nonzero bytes or relocations during image placement.

fn checkData(data: *il::Data, offset: u32) throws (super::Error) {

    if data.alignment == 0 or (data.alignment & (data.alignment - 1)) <> 0 {

        throw super::error(offset, "RIL alignment must be a nonzero power of two");

    }

    if data.readOnly and data.isZeroInit {

        throw super::error(offset, "RIL read-only data requires an initializer");

    }

    let mut size: u64 = 0;

    for value in data.values {

        let mut width: u32 = 0;

        let mut zero = true;

        match value.item {

            case il::DataItem::Val { typ, val } => {

                set width = il::typeSize(typ);

                // Only the stored low bytes contribute to narrow initializers.

                if width == 8 { set zero = val == 0; }

                else { set zero = ((val as u64) & ((1 as u64 << (width as u64 * 8)) - 1)) == 0; }

            }

            case il::DataItem::Sym(_), il::DataItem::Fn(_) => { set width = 8; set zero = false; }

            case il::DataItem::Str(bytes) => {

                set width = bytes.len;

                for byte in bytes { if byte <> 0 { set zero = false; } }

            }

            case il::DataItem::Undef => set width = 1,

        }

        let bytes = width as u64 * value.count as u64;

        if bytes > data.size as u64 - size { throw super::error(offset, "RIL initializer exceeds data size"); }

        set size += bytes;

        if data.isZeroInit and value.count <> 0 and not zero {

            throw super::error(offset, "RIL zero-init data contains a nonzero initializer");

        }

    }

    if not data.isZeroInit and size <> data.size as u64 {

        throw super::error(offset, "RIL initializer size differs from data size");

    }

}

/// Serialize all blocks, including unreferenced empty blocks retained by lowering.

export fn putFn(w: *mut super::Writer, func: *il::Fn) throws (super::Error) {

    try super::putSymbol(w, func.name, 2);

    try instructions::putType(w, func.returnType);

    try super::put8(w, 1 if func.isExtern else 0);

    try putParams(w, func.params);

    try super::put32(w, func.blocks.len);

    for block in func.blocks {

        try super::putString(w, block.label);

        try super::put32(w, block.loopDepth);

        try putParams(w, block.params);

        try super::put32(w, block.instrs.len);

        for instr in block.instrs { try instructions::put(w, instr); }

    }

}

/// Decode a function and reconstruct allocator metadata only after all block

/// indices are available. Temporary locations identify malformed instructions.

export fn getFn(r: *mut super::Reader) -> il::Fn throws (super::Error) {

    let offset = r.offset;

    let name = try super::declaration(r, 2);

    let returnType = try instructions::getType(r);

    let isExtern = try super::getBool(r);

    let params = try getParams(r);

    let count = try super::count(r, 16);

    let blocks = try super::storage(r.arena, @sizeOf(il::Block), @alignOf(il::Block), count, r.offset) as *mut [il::Block];

    for i in 0..count {

        let labelOffset = r.offset;

        let bytes = try super::getString(r);

        let label = try super::intern(r, bytes, labelOffset);

        let loopDepth = try super::get32(r);

        let blockParams = try getParams(r);

        let instrCount = try super::count(r, 1);

        let instrs = try super::storage(r.arena, @sizeOf(il::Instr), @alignOf(il::Instr), instrCount, r.offset) as *mut [il::Instr];

        let locs = try super::storage(r.arena, @sizeOf(il::SrcLoc), @alignOf(il::SrcLoc), instrCount, r.offset) as *mut [il::SrcLoc];

        for j in 0..instrCount {

            set locs[j] = il::SrcLoc { moduleId: 0, offset: r.offset };

            set instrs[j] = try instructions::get(r);

        }

        set blocks[i] = il::Block { label, params: blockParams, instrs, locs, preds: &[], loopDepth };

    }

    let mut func = il::Fn { name, params, returnType, isExtern, isLeaf: true, blocks };

    try structure::reconstruct(r, &mut func, blocks, offset);

    return func;

}