constant MAX_LOADED_MODULES: u32 = module::MAX_MODULES;

/// AST arena size (64 MB) - retains parsed nodes throughout compilation.

constant TEMP_ARENA_SIZE: u32 = 67108864;

export mod reader;

export mod program;

use std::lang::il;

@test export mod decodeTests;

/// The kind of an exported package symbol.

export union ExportKind: Copy {

    /// A callable function entry.

    Function,

    /// A global data definition.

    Data,

}

/// A public symbol supplied by a package.

export record Export: Copy {

    /// Qualified symbol name.

    name: *[u8],

    /// Definition kind.

    kind: ExportKind,

}

/// A binary package and its IL definitions.

/// Referenced storage must remain valid and immutable while the package is read.

export record Package: Copy {

    /// Unique symbol names in wire-index order.

    symbols: *unsafe [*[u8]],

    /// Immutable package name.

    name: *[u8],

    /// Names of required packages.

    dependencies: *unsafe [*[u8]],

    /// Public definitions.

    exports: *unsafe [Export],

    /// Default exported entry, if the package has one.

    entry: ?*[u8],

    /// Package-local functions and global data.

    program: il::Program,

}

/// Structural limits supplied by the consumer of decoded IL.

export record Limits: Copy {

    /// Exclusive upper bound for SSA register numbers.

    registers: u32,

    /// Maximum number of blocks in one function.

    blocks: u32,

}

//! Package reconstruction, malformed input, and arena rollback tests.

use std::testing;

use std::lang::alloc;

use std::lang::il;

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

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

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

/// Decode arena backing storage. Tests reset it before each use.

static MEMORY: [u8; 2048] = [0; 2048];

/// Structural limits for small test programs.

constant LIMITS: binary::Limits = binary::Limits { registers: 16, blocks: 4 };

/// Check a package round trip and failure at every truncated byte length.

unsafe fn roundTrip(package: &binary::Package) throws (testing::TestError) {

    let mut buffer: [u8; 2048] = [0; 2048];

    let length = try program::encode(&mut buffer[..], package) catch {

        throw testing::TestError::Failed;

    };

    let memory = &mut MEMORY[..2048];

    let mut arena = alloc::new(&mut memory[..]);

    set arena.offset = 8;

    let decoded = try program::decode(&buffer[..length], &mut arena, LIMITS) catch {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(decoded.name, package.name);

    try testing::expect(decoded.dependencies.len == package.dependencies.len);

    try testing::expect(decoded.exports.len == package.exports.len);

    try testing::expect(decoded.program.fns.len == package.program.fns.len);

    let mut encoded: [u8; 2048] = [0; 2048];

    let repeated = try program::encode(&mut encoded[..], &decoded) catch {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(&buffer[..length], &encoded[..repeated]);

    // Decoded names and string initializers retain arena ownership.

    for i in 0..length {

        set buffer[i] = 0;

    }

    let copied = try program::encode(&mut buffer[..], &decoded) catch {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(&buffer[..copied], &encoded[..repeated]);

    for end in 0..length {

        set arena.offset = 8;

        let mut failed = false;

        try program::decode(&buffer[..end], &mut arena, LIMITS) catch err {

            try testing::expect(err == binary::Error::Truncated);

            set failed = true;

        };

        try testing::expect(failed);

        try testing::expect(arena.offset == 8);

    }

    set arena.offset = 8;

    let mut input = reader::new(&[], &mut arena, &[]);

    let mut exhausted = false;

    try reader::storage(&mut input, 0xffffffff, 8, 0xffffffff) catch err {

        try testing::expect(err == binary::Error::Storage);

        set exhausted = true;

    };

    try testing::expect(exhausted);

    try testing::expect(arena.offset == 8);

    // Exercise every smaller arena extent, including alignment boundaries.

    let mut usedArena = alloc::new(&mut memory[..]);

    let _ = try program::decode(&buffer[..length], &mut usedArena, LIMITS) catch {

        throw testing::TestError::Failed;

    };

    let required = usedArena.offset;

    for capacity in 0..required {

        let mut short = alloc::new(&mut MEMORY[..capacity]);

        let mut failed = false;

        try program::decode(&buffer[..length], &mut short, LIMITS) catch err {

            try testing::expect(err == binary::Error::Storage);

            set failed = true;

        };

        try testing::expect(failed);

        try testing::expect(short.offset == 0);

    }

}

/// Check an empty program with a package identity.

@test unsafe fn emptyPackage() throws (testing::TestError) {

    let package = binary::Package {

        symbols: &["p"], name: "p", dependencies: &[], exports: &[], entry: nil,

        program: il::Program { data: &[], fns: &[] },

    };

    try roundTrip(&package);

    let mut buffer: [u8; 64] = [0; 64];

    let length = try program::encode(&mut buffer[..], &package) catch {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(&buffer[..length], &[

        82, 73, 76, 0, 1, 0, 0, 0, 1, 0, 0, 0,

        1, 0, 0, 0, 112, 0, 0, 0, 0,

        0, 0, 0, 0, 0, 0, 0, 0, 0,

        0, 0, 0, 0, 0, 0, 0, 0,

    ]);

}

/// Check functions, dependencies, exports, initializers, and block metadata.

@test unsafe fn fullPackage() throws (testing::TestError) {

    let params: *unsafe [il::Param] = &[il::Param { value: il::Reg { n: 1 }, type: il::Type::W64 }];

    let mut instrs = [

        il::Instr::Call {

            retTy: il::Type::W64, dst: il::Reg { n: 2 }, func: il::Val::FnAddr("dep::fn"),

            args: &[il::Val::Reg(il::Reg { n: 1 })],

        },

        il::Instr::Ret { val: il::Val::Reg(il::Reg { n: 2 }) },

    ];

    let func = il::Fn {

        name: "p::main", params, returnType: il::Type::W64, isExtern: false, isLeaf: false,

        blocks: &[il::Block {

            label: "entry", params: &[], instrs: &mut instrs[..], locs: &[], preds: &[0], loopDepth: 2,

        }],

    };

    let external = il::Fn {

        name: "dep::fn", params, returnType: il::Type::W64, isExtern: true, isLeaf: true, blocks: &[],

    };

    let data = il::Data {

        name: "p::data", size: 64, alignment: 8, readOnly: false, isZeroInit: false,

        values: &[

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W8, val: -1 }, count: 2 },

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W16, val: -2 }, count: 1 },

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W32, val: -3 }, count: 1 },

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W64, val: -4 }, count: 1 },

            il::DataValue { item: il::DataItem::Sym("p::data"), count: 1 },

            il::DataValue { item: il::DataItem::Fn("dep::fn"), count: 1 },

            il::DataValue { item: il::DataItem::Str("bytes"), count: 2 },

            il::DataValue { item: il::DataItem::Str(""), count: 0 },

            il::DataValue { item: il::DataItem::Undef, count: 1 },

        ],

    };

    let zero = il::Data {

        name: "p::zero", size: 4096, alignment: 4096, readOnly: false, isZeroInit: true, values: &[],

    };

    let package = binary::Package {

        symbols: &["p", "dep", "p::main", "dep::fn", "p::data", "p::zero"], name: "p",

        dependencies: &["dep"],

        exports: &[

            binary::Export { name: "p::main", kind: binary::ExportKind::Function },

            binary::Export { name: "p::data", kind: binary::ExportKind::Data },

        ],

        entry: "p::main", program: il::Program { data: retainData(&[data, zero]), fns: &[&func, &external] },

    };

    try roundTrip(&package);

}

/// Reject an invalid encoded instruction without a panic.

unsafe fn badInstruction(bytes: *[u8], expected: binary::Error) throws (testing::TestError) {

    let memory = &mut MEMORY[..64];

    let mut arena = alloc::new(&mut memory[..]);

    let mut input = reader::new(bytes, &mut arena, &["p"]);

    set input.registers = 2;

    set input.blocks = 1;

    let mut failed = false;

    try reader::instr(&mut input) catch err {

        try testing::expect(err == expected);

        set failed = true;

    };

    try testing::expect(failed);

}

/// Check instruction tags, operand tags, types, optional flags, and indices.

@test unsafe fn malformedInstructions() throws (testing::TestError) {

    try badInstruction(&[255], binary::Error::Invalid);

    try badInstruction(&[5, 0, 0, 0, 0, 255], binary::Error::Invalid);

    try badInstruction(&[1, 3], binary::Error::Invalid);

    try badInstruction(&[6, 255], binary::Error::Invalid);

    try badInstruction(&[7, 255], binary::Error::Invalid);

    try badInstruction(&[13, 255], binary::Error::Invalid);

    try badInstruction(&[11, 2], binary::Error::Invalid);

    try badInstruction(&[10, 8, 2], binary::Error::Invalid);

    try badInstruction(&[5, 2, 0, 0, 0], binary::Error::Invalid);

    try badInstruction(&[5, 0, 0, 0, 0, 0, 2, 0, 0, 0], binary::Error::Invalid);

    try badInstruction(&[12, 1, 0, 0, 0], binary::Error::Invalid);

    try badInstruction(&[5, 0, 0, 0, 0, 2, 1, 0, 0, 0], binary::Error::Symbol);

    try badInstruction(&[12, 0, 0, 0, 0, 255, 255, 255, 255], binary::Error::Truncated);

}

/// Check header validation and package symbol indices with arena rollback.

@test unsafe fn malformedPackages() throws (testing::TestError) {

    let package = binary::Package {

        symbols: &["p"], name: "p", dependencies: &[], exports: &[], entry: nil,

        program: il::Program { data: &[], fns: &[] },

    };

    let mut buffer: [u8; 64] = [0; 64];

    let length = try program::encode(&mut buffer[..], &package) catch {

        throw testing::TestError::Failed;

    };

    let memory = &mut MEMORY[..64];

    let mut arena = alloc::new(&mut memory[..]);

    for offset in &[0, 4, 17, 29] {

        let original = buffer[offset];

        set buffer[offset] = 255;

        set arena.offset = 8;

        let mut failed = false;

        try program::decode(&buffer[..length], &mut arena, LIMITS) catch {

            set failed = true;

        };

        try testing::expect(failed);

        try testing::expect(arena.offset == 8);

        set buffer[offset] = original;

    }

    let mut trailing = false;

    try program::decode(&buffer[..length + 1], &mut arena, LIMITS) catch err {

        try testing::expect(err == binary::Error::Invalid);

        set trailing = true;

    };

    try testing::expect(trailing);

    try testing::expect(arena.offset == 8);

}

/// Encode a malformed package and check rejection with arena rollback.

unsafe fn rejected(package: &binary::Package, limits: binary::Limits) throws (testing::TestError) {

    let mut buffer: [u8; 512] = [0; 512];

    let length = try program::encode(&mut buffer[..], package) catch {

        throw testing::TestError::Failed;

    };

    let memory = &mut MEMORY[..256];

    let mut arena = alloc::new(&mut memory[..]);

    set arena.offset = 8;

    let mut failed = false;

    try program::decode(&buffer[..length], &mut arena, limits) catch err {

        try testing::expect(err == binary::Error::Invalid);

        set failed = true;

    };

    try testing::expect(failed);

    try testing::expect(arena.offset == 8);

}

/// Check initializer extent arithmetic, alignments, and duplicate symbols.

@test unsafe fn invalidData() throws (testing::TestError) {

    let mut item = il::Data {

        name: "p", size: 0xffffffff, alignment: 8, readOnly: false, isZeroInit: false,

        values: &[

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W64, val: 0 }, count: 0xffffffff },

        ],

    };

    let mut package = binary::Package {

        symbols: &["p"], name: "p", dependencies: &[], exports: &[], entry: nil,

        program: il::Program { data: retainData(&[item]), fns: &[] },

    };

    try rejected(&package, LIMITS);

    set item.size = 1;

    set item.values = &[

        il::DataValue { item: il::DataItem::Undef, count: 1 },

        il::DataValue { item: il::DataItem::Undef, count: 1 },

    ];

    set package.program = il::Program { data: retainData(&[item]), fns: &[] };

    try rejected(&package, LIMITS);

    set item.values = &[];

    for alignment in &[0, 3] {

        set item.alignment = alignment;

        set package.program = il::Program { data: retainData(&[item]), fns: &[] };

        try rejected(&package, LIMITS);

    }

    set package.program = il::Program { data: &[], fns: &[] };

    set package.symbols = &["p", "p"];

    try rejected(&package, LIMITS);

    set package.symbols = &["p", ""];

    try rejected(&package, LIMITS);

}

/// Check function block limits, parameter indices, and predecessor indices.

@test unsafe fn invalidFunctions() throws (testing::TestError) {

    let mut instrs = [il::Instr::Ret { val: nil }];

    let mut block = il::Block {

        label: "entry", params: &[], instrs: &mut instrs[..], locs: &[], preds: &[], loopDepth: 0,

    };

    let mut func = il::Fn {

        name: "p", params: &[], returnType: il::Type::W64,

        isExtern: false, isLeaf: true, blocks: &[block],

    };

    let package = binary::Package {

        symbols: &["p"], name: "p", dependencies: &[], exports: &[], entry: nil,

        program: il::Program { data: &[], fns: &[&func] },

    };

    try rejected(&package, binary::Limits { registers: 16, blocks: 0 });

    set func.isExtern = true;

    try rejected(&package, LIMITS);

    set func.isExtern = false;

    set func.params = &[il::Param { value: il::Reg { n: 16 }, type: il::Type::W64 }];

    try rejected(&package, LIMITS);

    set func.params = &[];

    set block.preds = &[1];

    set func.blocks = &[block];

    try rejected(&package, LIMITS);

}

/// Reject unknown initializer tags and widths before reading their payloads.

@test unsafe fn malformedInitializers() throws (testing::TestError) {

    let memory = &mut MEMORY[..8];

    let mut arena = alloc::new(&mut memory[..]);

    let fixtures: [*[u8]; 2] = [&[255], &[0, 3]];

    for bytes in &fixtures[..] {

        let mut input = reader::new(bytes, &mut arena, &[]);

        let mut failed = false;

        try reader::dataValue(&mut input) catch err {

            try testing::expect(err == binary::Error::Invalid);

            set failed = true;

        };

        try testing::expect(failed);

    }

}

/// Copy data fixtures into stable storage for the package descriptor.

unsafe fn retainData(items: &[il::Data]) -> *[il::Data] {

    unsafe static DATA: [il::Data; 2] = undefined;

    assert items.len <= DATA.len;

    for item, i in items { set DATA[i] = item; }

    return &DATA[..items.len];

}

//! Binary package envelopes and IL program reconstruction.

//! Tables occur in this order: symbols, dependencies, exports, data, functions.

//! Block records carry labels, parameters, loop depth, predecessors, instructions.

use std::lang::il;

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

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

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

use std::lang::alloc;

use std::mem;

/// Write a counted sequence of typed SSA parameters.

unsafe fn writeParams(out: &mut writer::Writer, params: &[il::Param]) throws (binary::Error) {

    try writer::integer(out, params.len as u64, 4);

    for param in params {

        try writer::integer(out, param.value.n as u64, 4);

        try writer::typ(out, param.type);

    }

}

/// Write a package. Return the number of encoded bytes.

/// All package tables and IL storage must remain valid during encoding.

export unsafe fn encode(bytes: &mut [u8], package: &binary::Package) -> u32 throws (binary::Error) {

    let mut out = writer::new(bytes, package.symbols);

    try writer::integer(&mut out, binary::MAGIC as u64, 4);

    try writer::integer(&mut out, binary::VERSION as u64, 4);

    try writer::integer(&mut out, package.symbols.len as u64, 4);

    for name in package.symbols {

        try writer::bytes(&mut out, name);

    }

    try writer::symbol(&mut out, package.name);

    try writer::integer(&mut out, package.dependencies.len as u64, 4);

    for name in package.dependencies {

        try writer::symbol(&mut out, name);

    }

    try writer::integer(&mut out, package.exports.len as u64, 4);

    for item in package.exports {

        try writer::symbol(&mut out, item.name);

        match item.kind {

            case binary::ExportKind::Function => try writer::integer(&mut out, 0, 1),

            case binary::ExportKind::Data => try writer::integer(&mut out, 1, 1),

        }

    }

    if let entry = package.entry {

        try writer::integer(&mut out, 1, 1);

        try writer::symbol(&mut out, entry);

    } else {

        try writer::integer(&mut out, 0, 1);

    }

    try writer::integer(&mut out, package.program.data.len as u64, 4);

    for item in package.program.data {

        try writer::symbol(&mut out, item.name);

        try writer::integer(&mut out, item.size as u64, 4);

        try writer::integer(&mut out, item.alignment as u64, 4);

        try writer::integer(&mut out, 1 if item.readOnly else 0, 1);

        try writer::integer(&mut out, 1 if item.isZeroInit else 0, 1);

        try writer::integer(&mut out, item.values.len as u64, 4);

        for value in item.values {

            try writer::dataValue(&mut out, value);

        }

    }

    try writer::integer(&mut out, package.program.fns.len as u64, 4);

    for func in package.program.fns {

        try writer::symbol(&mut out, func.name);

        try writer::typ(&mut out, func.returnType);

        try writer::integer(&mut out, 1 if func.isExtern else 0, 1);

        try writeParams(&mut out, func.params);

        try writer::integer(&mut out, func.blocks.len as u64, 4);

        for block in func.blocks {

            try writer::bytes(&mut out, block.label);

            try writeParams(&mut out, block.params);

            try writer::integer(&mut out, block.loopDepth as u64, 4);

            try writer::integer(&mut out, block.preds.len as u64, 4);

            for pred in block.preds {

                try writer::integer(&mut out, pred as u64, 4);

            }

            try writer::integer(&mut out, block.instrs.len as u64, 4);

            for instr in block.instrs {

                try writer::instr(&mut out, instr);

            }

        }

    }

    return out.offset;

}

/// Read typed SSA parameters with checked register indices.

unsafe fn readParams(input: &mut reader::Reader) -> *unsafe [il::Param] throws (binary::Error) {

    let n = try reader::count(input, 5);

    let params = try reader::storage(input, @sizeOf(il::Param), @alignOf(il::Param), n)

        as *mut [il::Param];

    for i in 0..n {

        let value = try reader::reg(input);

        let t = try reader::typ(input);

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

    }

    return (&params[..]) as *unsafe [il::Param];

}

/// Read global data and check initializer extents against declared storage.

unsafe fn readData(input: &mut reader::Reader) -> *[il::Data] throws (binary::Error) {

    let n = try reader::count(input, 18);

    let items = try reader::storage(input, @sizeOf(il::Data), @alignOf(il::Data), n)

        as *mut [il::Data];

    for i in 0..n {

        let name = try reader::symbol(input);

        let size = try reader::integer(input, 4) as u32;

        let alignment = try reader::integer(input, 4) as u32;

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

            throw binary::Error::Invalid;

        }

        let readOnly = try reader::flag(input);

        let isZeroInit = try reader::flag(input);

        let count = try reader::count(input, 5);

        let values = try reader::storage(input, @sizeOf(il::DataValue), @alignOf(il::DataValue), count)

            as *mut [il::DataValue];

        let mut extent: u64 = 0;

        for j in 0..count {

            let value = try reader::dataValue(input);

            let mut width: u32 = 0;

            match value.item {

                case il::DataItem::Val { typ, .. } => { set width = il::typeSize(typ); },

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

                case il::DataItem::Str(text) => { set width = text.len; },

                case il::DataItem::Undef => { set width = 1; },

            }

            set extent += width as u64 * value.count as u64;

            if extent > size as u64 {

                throw binary::Error::Invalid;

            }

            set values[j] = value;

        }

        set items[i] = il::Data { name, size, alignment, readOnly, isZeroInit, values };

    }

    return items;

}

/// Read functions with checked block and register indices.

unsafe fn readFunctions(input: &mut reader::Reader, limits: binary::Limits)

    -> *unsafe [*unsafe il::Fn] throws (binary::Error)

{

    let n = try reader::count(input, 14);

    let fns = try reader::storage(input, @sizeOf(*il::Fn), @alignOf(*il::Fn), n) as *mut [*unsafe il::Fn];

    set input.registers = limits.registers;

    for i in 0..n {

        let name = try reader::symbol(input);

        let returnType = try reader::typ(input);

        let isExtern = try reader::flag(input);

        let params = try readParams(input);

        let count = try reader::count(input, 20);

        if count > limits.blocks or (isExtern and count <> 0) {

            throw binary::Error::Invalid;

        }

        set input.blocks = count;

        let blocks = try reader::storage(input, @sizeOf(il::Block), @alignOf(il::Block), count)

            as *mut [il::Block];

        let mut isLeaf = true;

        for j in 0..count {

            let label = try reader::bytes(input);

            let blockParams = try readParams(input);

            let loopDepth = try reader::integer(input, 4) as u32;

            let predCount = try reader::count(input, 4);

            let preds = try reader::storage(input, @sizeOf(u32), @alignOf(u32), predCount) as *mut [u32];

            for k in 0..predCount {

                set preds[k] = try reader::target(input);

            }

            let instrCount = try reader::count(input, 1);

            let instrs = try reader::storage(input, @sizeOf(il::Instr), @alignOf(il::Instr), instrCount)

                as *mut [il::Instr];

            for k in 0..instrCount {

                let instr = try reader::instr(input);

                if il::isCall(instr) {

                    set isLeaf = false;

                }

                set instrs[k] = instr;

            }

            set blocks[j] = il::Block {

                label, params: blockParams, instrs: (&mut instrs[..]) as *unsafe mut [il::Instr], locs: &[], preds: (&preds[..]) as *unsafe [u32], loopDepth,

            };

        }

        let func = try reader::storage(input, @sizeOf(il::Fn), @alignOf(il::Fn), 1) as *mut [il::Fn];

        set func[0] = il::Fn { name, params, returnType, isExtern, isLeaf, blocks: (&blocks[..]) as *unsafe [il::Block] };

        set fns[i] = &func[0];

    }

    return (&fns[..]) as *unsafe [*unsafe il::Fn];

}

/// Read the package tables. The input must contain exactly one package.

unsafe fn readPackage(input: &mut reader::Reader, limits: binary::Limits)

    -> binary::Package throws (binary::Error)

{

    let magic = try reader::integer(input, 4) as u32;

    let version = try reader::integer(input, 4) as u32;

    if magic <> binary::MAGIC or version <> binary::VERSION {

        throw binary::Error::Invalid;

    }

    let symbolCount = try reader::count(input, 4);

    let symbols = try reader::storage(input, @sizeOf(*[u8]), @alignOf(*[u8]), symbolCount)

        as *mut [*[u8]];

    for i in 0..symbolCount {

        let name = try reader::bytes(input);

        if name.len == 0 {

            throw binary::Error::Invalid;

        }

        for j in 0..i {

            if mem::eq(name, symbols[j]) {

                throw binary::Error::Invalid;

            }

        }

        set symbols[i] = name;

    }

    set input.symbols = (&symbols[..]) as *unsafe [*[u8]];

    let name = try reader::symbol(input);

    let depCount = try reader::count(input, 4);

    let dependencies = try reader::storage(input, @sizeOf(*[u8]), @alignOf(*[u8]), depCount)

        as *mut [*[u8]];

    for i in 0..depCount {

        set dependencies[i] = try reader::symbol(input);

    }

    let exportCount = try reader::count(input, 5);

    let exports = try reader::storage(input, @sizeOf(binary::Export), @alignOf(binary::Export), exportCount)

        as *mut [binary::Export];

    for i in 0..exportCount {

        let symbol = try reader::symbol(input);

        let kind = binary::ExportKind::Data if try reader::flag(input) else binary::ExportKind::Function;

        set exports[i] = binary::Export { name: symbol, kind };

    }

    let mut entry: ?*[u8] = nil;

    if try reader::flag(input) {

        set entry = try reader::symbol(input);

    }

    let data = try readData(input);

    let fns = try readFunctions(input, limits);

    if input.offset <> input.bytes.len {

        throw binary::Error::Invalid;

    }

    return binary::Package { symbols: (&symbols[..]) as *unsafe [*[u8]], name, dependencies: (&dependencies[..]) as *unsafe [*[u8]], exports: (&exports[..]) as *unsafe [binary::Export], entry, program: il::Program { data, fns } };

}

/// Decode one package. Restore the arena offset on every failure.

/// The caller must retain the decoded allocations until the last package use.

export unsafe fn decode(bytes: &[u8], arena: &mut alloc::Arena, limits: binary::Limits)

    -> binary::Package throws (binary::Error)

{

    let saved = alloc::save(arena);

    let mut input = reader::new(bytes, arena, &[]);

    return try readPackage(&mut input, limits) catch err {

        alloc::restore(arena, saved);

        throw err;

    };

}

//! 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 cursor and reconstruction storage.

/// Input bytes, symbols, and the arena must remain valid during each read.

export record Reader: Copy {

    /// Encoded bytes.

    bytes: *unsafe [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: *unsafe [*[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 unsafe fn new(bytes: &[u8], arena: &mut alloc::Arena, symbols: *unsafe [*[u8]]) -> Reader {

    return Reader { bytes: bytes as *unsafe [u8], offset: 0, arena: arena as *unsafe mut alloc::Arena, symbols, registers: 0, blocks: 0 };

}

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

export unsafe fn integer(input: &mut Reader, 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;

}