//! Checked binary RIL decoding into caller-owned arena storage.

//! Callers discard partial results and restore the arena after a failed decode.

use std::lang::il;

use std::lang::il::binary;

use std::lang::alloc;

/// Input bytes and the symbol table are borrowed for the reader's region.

/// Allocation requires valid raw storage.

export record Reader: 'input + Copy {

    /// Encoded bytes.

    bytes: &'input [u8],

    /// Number of bytes consumed.

    offset: u32,

    /// Storage for decoded sequences and byte strings.

    arena: *unsafe mut alloc::Arena,

    /// Symbol names in wire-index order.

    symbols: &'input [*[u8]],

    /// Exclusive bound for SSA register numbers.

    registers: u32,

    /// Number of blocks in the current function.

    blocks: u32,

}

/// Create a cursor. Set function bounds before reading instructions.

export fn new 'input (bytes: &'input [u8], arena: *unsafe mut alloc::Arena, symbols: &'input [*[u8]]) -> Reader 'input {

    return Reader 'input { bytes, offset: 0, arena, symbols, registers: 0, blocks: 0 };

}

/// Read an unsigned integer with width 1, 2, 4, or 8.

export fn integer 'input (input: &mut Reader 'input, width: u32) -> u64 throws (binary::Error) {

    if width <> 1 and width <> 2 and width <> 4 and width <> 8 {

        throw binary::Error::Invalid;

    }

    if input.offset > input.bytes.len or width > input.bytes.len - input.offset {

        throw binary::Error::Truncated;

    }

    let mut result: u64 = 0;

    for i in 0..width {

        set result |= (input.bytes[input.offset + i] as u64) << (i * 8) as u64;

    }

    set input.offset += width;

    return result;

}

/// Read a zero-or-one optional-field or boolean marker.

export fn flag 'input (input: &mut Reader 'input) -> bool throws (binary::Error) {

    let n = try integer(input, 1);

    if n > 1 {

        throw binary::Error::Invalid;

    }

    return n == 1;

}

/// Read a count and check the minimum required input bytes before allocation.

export fn count 'input (input: &mut Reader 'input, minimum: u32) -> u32 throws (binary::Error) {

    assert minimum > 0;

    let n = try integer(input, 4) as u32;

    if n > (input.bytes.len - input.offset) / minimum {

        throw binary::Error::Truncated;

    }

    return n;

}

/// Allocate a typed sequence after checking size and alignment arithmetic.

export unsafe fn storage 'input (input: &mut Reader 'input, size: u32, alignment: u32, count: u32)

    -> *mut [opaque] throws (binary::Error)

{

    assert size > 0 and alignment > 0 and (alignment & (alignment - 1)) == 0;

    return try alloc::allocSlice(input.arena, size, alignment, count) catch {

        throw binary::Error::Storage;

    };

}

/// Read a length-prefixed byte string and copy it into the arena.

export unsafe fn bytes 'input (input: &mut Reader 'input) -> *[u8] throws (binary::Error) {

    let n = try count(input, 1);

    let result = try storage(input, @sizeOf(u8), @alignOf(u8), n) as *mut [u8];

    return fillBytes(input, result);

}

/// Fill an owned byte buffer from input and advance past the copied bytes.

fn fillBytes 'input (input: &mut Reader 'input, result: *mut [u8]) -> *[u8] {

    let n = result.len;

    for i in 0..n {

        set result[i] = input.bytes[input.offset + i];

    }

    set input.offset += n;

    return result;

}

/// Resolve a checked symbol-table index.

export fn symbol 'input (input: &mut Reader 'input) -> *[u8] throws (binary::Error) {

    let index = try integer(input, 4) as u32;

    if index >= input.symbols.len {

        throw binary::Error::Symbol;

    }

    return input.symbols[index];

}

/// Read an IL type from its byte width.

export fn typ 'input (input: &mut Reader 'input) -> il::Type throws (binary::Error) {

    let width = try integer(input, 1);

    match width {

        case 1 => return il::Type::W8,

        case 2 => return il::Type::W16,

        case 4 => return il::Type::W32,

        case 8 => return il::Type::W64,

        else => throw binary::Error::Invalid,

    }

}

/// Read a register index within the current function's bound.

export fn reg 'input (input: &mut Reader 'input) -> il::Reg throws (binary::Error) {

    let n = try integer(input, 4) as u32;

    if n >= input.registers {

        throw binary::Error::Invalid;

    }

    return il::Reg { n };

}

/// Read a target block index within the current function.

export fn target 'input (input: &mut Reader 'input) -> u32 throws (binary::Error) {

    let n = try integer(input, 4) as u32;

    if n >= input.blocks {

        throw binary::Error::Invalid;

    }

    return n;

}

/// Read a tagged value with checked register and symbol indices.

export fn val 'input (input: &mut Reader 'input) -> il::Val throws (binary::Error) {

    let tag = try integer(input, 1) as u8;

    match tag {

        case super::VALUE_REG => return il::Val::Reg(try reg(input)),

        case super::VALUE_IMM => return il::Val::Imm(try integer(input, 8) as i64),

        case super::VALUE_DATASYM => return il::Val::DataSym(try symbol(input)),

        case super::VALUE_FNADDR => return il::Val::FnAddr(try symbol(input)),

        case super::VALUE_UNDEF => return il::Val::Undef,

        else => throw binary::Error::Invalid,

    }

}

/// Read a counted sequence of values.

export unsafe fn values 'input (input: &mut Reader 'input) -> *unsafe mut [il::Val] throws (binary::Error) {

    let n = try count(input, 1);

    let result = try newValues(input, n);

    let initialized = try fillValues(input, result);

    return (&mut initialized[..]) as *unsafe mut [il::Val];

}

/// Exact-capacity storage with a fully initialized operand prefix.

record ValueBuilder {

    /// Opaque storage reserved for the full operand count.

    storage: *mut [opaque],

    /// Number of initialized operands in the prefix.

    initialized: u32,

}

/// Reserve operand storage without exposing uninitialized typed elements.

unsafe fn newValues 'input (input: &mut Reader 'input, count: u32) -> ValueBuilder throws (binary::Error) {

    let buffer = try storage(input, @sizeOf(il::Val), @alignOf(il::Val), count);

    return ValueBuilder { storage: buffer, initialized: 0 };

}

/// Initialize the next operand. Return false when the storage is full.

fn pushValue(builder: &mut ValueBuilder, value: il::Val) -> bool {

    if builder.initialized == builder.storage.len {

        return false;

    }

    unsafe {

        let values = (&mut builder.storage[..]) as *unsafe mut [il::Val];

        set values[builder.initialized] = value;

    }

    set builder.initialized += 1;

    return true;

}

/// Consume a builder and publish its owned table only when it is complete.

/// Incomplete Copy operands need no element cleanup; the arena retains storage.

fn finishValues(builder: ValueBuilder) -> ValueCompletion {

    let case ValueBuilder { storage, initialized } = builder

        else panic "finishValues: invalid builder";

    if initialized <> storage.len {

        return ValueCompletion::Incomplete;

    }

    unsafe {

        return ValueCompletion::Complete(storage as *mut [il::Val]);

    }

}

/// Completion distinguishes an empty initialized table from incomplete storage.

union ValueCompletion {

    /// Fully initialized table, including zero operands.

    Complete(*mut [il::Val]),

    /// Storage discarded before all operands were initialized.

    Incomplete,

}

/// Fill an owned operand table with checked tagged values in input order.

fn fillValues 'input (input: &mut Reader 'input, builder: ValueBuilder) -> *mut [il::Val] throws (binary::Error) {

    let mut pending = builder;

    while pending.initialized < pending.storage.len {

        assert pushValue(&mut pending, try val(input));

    }

    let case ValueCompletion::Complete(result) = finishValues(pending)

        else panic "fillValues: incomplete operand table";

    return result;

}

/// Read a checked bin operation tag.

fn binOp 'input (input: &mut Reader 'input) -> il::BinOp throws (binary::Error) {

    let tag = try integer(input, 1) as u8;

    match tag {

        case super::BIN_ADD => return il::BinOp::Add,

        case super::BIN_SUB => return il::BinOp::Sub,

        case super::BIN_MUL => return il::BinOp::Mul,

        case super::BIN_SDIV => return il::BinOp::Sdiv,

        case super::BIN_UDIV => return il::BinOp::Udiv,

        case super::BIN_SREM => return il::BinOp::Srem,

        case super::BIN_UREM => return il::BinOp::Urem,

        case super::BIN_EQ => return il::BinOp::Eq,

        case super::BIN_NE => return il::BinOp::Ne,

        case super::BIN_SLT => return il::BinOp::Slt,

        case super::BIN_SGE => return il::BinOp::Sge,

        case super::BIN_ULT => return il::BinOp::Ult,

        case super::BIN_UGE => return il::BinOp::Uge,

        case super::BIN_AND => return il::BinOp::And,

        case super::BIN_OR => return il::BinOp::Or,

        case super::BIN_XOR => return il::BinOp::Xor,

        case super::BIN_SHL => return il::BinOp::Shl,

        case super::BIN_SSHR => return il::BinOp::Sshr,

        case super::BIN_USHR => return il::BinOp::Ushr,

        else => throw binary::Error::Invalid,

    }

}

/// Read a checked un operation tag.

fn unOp 'input (input: &mut Reader 'input) -> il::UnOp throws (binary::Error) {

    let tag = try integer(input, 1) as u8;

    match tag {

        case super::UN_NEG => return il::UnOp::Neg,

        case super::UN_NOT => return il::UnOp::Not,

        else => throw binary::Error::Invalid,

    }

}

/// Read a checked cmp operation tag.

fn cmpOp 'input (input: &mut Reader 'input) -> il::CmpOp throws (binary::Error) {

    let tag = try integer(input, 1) as u8;

    match tag {

        case super::CMP_EQ => return il::CmpOp::Eq,

        case super::CMP_NE => return il::CmpOp::Ne,

        case super::CMP_SLT => return il::CmpOp::Slt,

        case super::CMP_ULT => return il::CmpOp::Ult,

        else => throw binary::Error::Invalid,

    }

}

/// Read an instruction with inline operands.

fn fixedInstr 'input (input: &mut Reader 'input, tag: u8) -> il::Instr throws (binary::Error) {

    match tag {

        case super::INSTR_RESERVE => {

            let vdst = try reg(input);

            let vsize = try val(input);

            let valignment = try integer(input, 4) as u32;

            return il::Instr::Reserve { dst: vdst, size: vsize, alignment: valignment };

        },

        case super::INSTR_LOAD, super::INSTR_SLOAD => {

            let vtyp = try typ(input);

            let vdst = try reg(input);

            let vsrc = try reg(input);

            let voffset = try integer(input, 4) as i32;

            if tag == super::INSTR_SLOAD {

                return il::Instr::Sload { typ: vtyp, dst: vdst, src: vsrc, offset: voffset };

            }

            return il::Instr::Load { typ: vtyp, dst: vdst, src: vsrc, offset: voffset };

        },

        case super::INSTR_STORE => {

            let vtyp = try typ(input);

            let vsrc = try val(input);

            let vdst = try reg(input);

            let voffset = try integer(input, 4) as i32;

            return il::Instr::Store { typ: vtyp, src: vsrc, dst: vdst, offset: voffset };

        },

        case super::INSTR_BLIT => {

            let vdst = try reg(input);

            let vsrc = try reg(input);

            let vsize = try val(input);

            return il::Instr::Blit { dst: vdst, src: vsrc, size: vsize };

        },

        case super::INSTR_COPY => {

            let vdst = try reg(input);

            let vval = try val(input);

            return il::Instr::Copy { dst: vdst, val: vval };

        },

        case super::INSTR_BINOP => {

            let vop = try binOp(input);

            let vtyp = try typ(input);

            let vdst = try reg(input);

            let va = try val(input);

            let vb = try val(input);

            return il::Instr::BinOp { op: vop, typ: vtyp, dst: vdst, a: va, b: vb };

        },

        case super::INSTR_UNOP => {

            let vop = try unOp(input);

            let vtyp = try typ(input);

            let vdst = try reg(input);

            let va = try val(input);

            return il::Instr::UnOp { op: vop, typ: vtyp, dst: vdst, a: va };

        },

        case super::INSTR_ZEXT, super::INSTR_SEXT => {

            let vtyp = try typ(input);

            let vdst = try reg(input);

            let vval = try val(input);

            if tag == super::INSTR_SEXT {

                return il::Instr::Sext { typ: vtyp, dst: vdst, val: vval };

            }

            return il::Instr::Zext { typ: vtyp, dst: vdst, val: vval };

        },

        case super::INSTR_RET => {

            let mut vval: ?il::Val = nil;

            if try flag(input) {

                set vval = try val(input);

            }

            return il::Instr::Ret { val: vval };

        },

        case super::INSTR_UNREACHABLE => {

            return il::Instr::Unreachable;

        },

        case super::INSTR_ECALL => {

            let vdst = try reg(input);

            let vnum = try val(input);

            let va0 = try val(input);

            let va1 = try val(input);

            let va2 = try val(input);

            let va3 = try val(input);

            return il::Instr::Ecall { dst: vdst, num: vnum, a0: va0, a1: va1, a2: va2, a3: va3 };

        },

        case super::INSTR_DEVICE_READ => {

            let t = try typ(input);

            let dst = try reg(input);

            let handle = try val(input); let offset = try val(input);

            return il::Instr::DeviceRead { typ: t, dst, handle, offset };

        },

        case super::INSTR_DEVICE_WRITE => {

            let t = try typ(input);

            let handle = try val(input); let offset = try val(input); let value = try val(input);

            return il::Instr::DeviceWrite { typ: t, handle, offset, value };

        },

        case super::INSTR_EBREAK => {

            return il::Instr::Ebreak;

        },

        case super::INSTR_MEMORYFENCE => {

            return il::Instr::MemoryFence;

        },

        else => throw binary::Error::Invalid,

    }

}

/// Read one instruction and reconstruct its operand sequences.

export unsafe fn instr 'input (input: &mut Reader 'input) -> il::Instr throws (binary::Error) {

    let tag = try integer(input, 1) as u8;

    match tag {

        case super::INSTR_CALL => {

            let vretTy = try typ(input);

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

            if try flag(input) {

                set vdst = try reg(input);

            }

            let vfunc = try val(input);

            let vargs = try values(input);

            return il::Instr::Call { retTy: vretTy, dst: vdst, func: vfunc, args: vargs };

        },

        case super::INSTR_JMP => {

            let vtarget = try target(input);

            let vargs = try values(input);

            return il::Instr::Jmp { target: vtarget, args: vargs };

        },

        case super::INSTR_BR => {

            let vop = try cmpOp(input);

            let vtyp = try typ(input);

            let va = try val(input);

            let vb = try val(input);

            let vthenTarget = try target(input);

            let vthenArgs = try values(input);

            let velseTarget = try target(input);

            let velseArgs = try values(input);

            return il::Instr::Br { op: vop, typ: vtyp, a: va, b: vb, thenTarget: vthenTarget, thenArgs: vthenArgs, elseTarget: velseTarget, elseArgs: velseArgs };

        },

        case super::INSTR_SWITCH => {

            let vval = try val(input);

            let vdefaultTarget = try target(input);

            let vdefaultArgs = try values(input);

            let n = try count(input, 16);

            let caseStorage = try storage(input, @sizeOf(il::SwitchCase), @alignOf(il::SwitchCase), n)

                as *mut [il::SwitchCase];

            let vcases = try fillCases(input, caseStorage);

            return il::Instr::Switch { val: vval, defaultTarget: vdefaultTarget, defaultArgs: vdefaultArgs, cases: (&mut vcases[..]) as *unsafe mut [il::SwitchCase] };

        },

        else => return try fixedInstr(input, tag),

    }

}

/// Fill owned switch cases with signed values and checked block targets.

fn fillCases 'input (input: &mut Reader 'input, cases: *mut [il::SwitchCase]) -> *mut [il::SwitchCase] throws (binary::Error) {

    for i in 0..cases.len {

        let value = try integer(input, 8) as i64;

        let block = try target(input);

        unsafe {

            let args = try values(input);

            set cases[i] = il::SwitchCase { value, target: block, args };

        }

    }

    return cases;

}

/// Read an initializer with a repetition count.

export unsafe fn dataValue 'input (input: &mut Reader 'input) -> il::DataValue throws (binary::Error) {

    let tag = try integer(input, 1) as u8;

    let item = il::DataItem::Str(try bytes(input)) if tag == super::DATA_STR

        else try fixedDataItem(input, tag);

    let n = try integer(input, 4) as u32;

    return il::DataValue { item, count: n };

}

/// Decode a data item whose payload needs no allocation.

fn fixedDataItem 'input (input: &mut Reader 'input, tag: u8) -> il::DataItem throws (binary::Error) {

    match tag {

        case super::DATA_VAL => {

            let t = try typ(input);

            let n = try integer(input, il::typeSize(t));

            return il::DataItem::Val { typ: t, val: n as i64 };

        },

        case super::DATA_SYM => {

            return il::DataItem::Sym(try symbol(input));

        },

        case super::DATA_FN => {

            return il::DataItem::Fn(try symbol(input));

        },

        case super::DATA_UNDEF => {

            return il::DataItem::Undef;

        },

        else => throw binary::Error::Invalid,

    }

}