unsafe fn instruction 'tables (names: &mut Names 'tables, owner: *[u8], instr: &il::Instr) throws (binary::Error) {

    match *instr {

        else => try fixedInstruction(names, owner, instr),

    }

}

/// Collect symbolic operands stored directly in an instruction.

fn fixedInstruction 'tables (names: &mut Names 'tables, owner: *[u8], instr: &il::Instr) throws (binary::Error) {

    match *instr {

        case il::Instr::Reserve { size, .. } => try value(names, owner, size),

        case il::Instr::Blit { size, .. } => try value(names, owner, size),

        case il::Instr::Store { src, .. } => try value(names, owner, src),

        case il::Instr::Copy { val, .. } => try value(names, owner, val),

        case il::Instr::Zext { val, .. } => try value(names, owner, val),

        case il::Instr::Sext { val, .. } => try value(names, owner, val),

        case il::Instr::BinOp { a, b, .. } => {

            try value(names, owner, a);

            try value(names, owner, b);

        },

        case il::Instr::UnOp { a, .. } => try value(names, owner, a),

        case il::Instr::Ret { val } => {

            if let item = val {

                try value(names, owner, item);

            }

        },

        case il::Instr::Call { .. }, il::Instr::Jmp { .. }, il::Instr::Br { .. }, il::Instr::Switch { .. } =>

            panic "fixedInstruction: expected inline operands",

                try instruction(names, owner, &instr);

/// Fixed instruction operands retain symbol order and bounded table writes.

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

    let r = il::Reg { n: 0 };

    let a = il::Val::DataSym("z::data");

    let b = il::Val::FnAddr("a::fn");

    let c = il::Val::DataSym("c::data");

    let d = il::Val::FnAddr("d::fn");

    let e = il::Val::DataSym("e::data");

    let single: [*[u8]; 2] = ["z::data", "z"];

    let pair: [*[u8]; 4] = ["z::data", "z", "a::fn", "a"];

    for instr in [

        il::Instr::Reserve { dst: r, size: a, alignment: 8 },

        il::Instr::Blit { dst: r, src: r, size: a },

        il::Instr::Store { typ: il::Type::W64, src: a, dst: r, offset: 0 },

        il::Instr::Copy { dst: r, val: a },

        il::Instr::Zext { typ: il::Type::W8, dst: r, val: a },

        il::Instr::Sext { typ: il::Type::W8, dst: r, val: a },

        il::Instr::UnOp { op: il::UnOp::Neg, typ: il::Type::W64, dst: r, a },

        il::Instr::Ret { val: a },

        il::Instr::BinOp { op: il::BinOp::Add, typ: il::Type::W64, dst: r, a, b: a },

    ] { try checkInstructionNames(instr, &single[..]); }

    for instr in [

        il::Instr::BinOp { op: il::BinOp::Add, typ: il::Type::W64, dst: r, a, b },

        il::Instr::DeviceRead { typ: il::Type::W8, dst: r, handle: a, offset: b },

    ] { try checkInstructionNames(instr, &pair[..]); }

    try checkInstructionNames(il::Instr::Ecall { dst: r, num: a, a0: b, a1: c, a2: d, a3: e },

        &["z::data", "z", "a::fn", "a", "c::data", "c", "d::fn", "d", "e::data", "e"]);

    try checkInstructionNames(il::Instr::DeviceWrite { typ: il::Type::W8, handle: a, offset: b, value: c },

        &["z::data", "z", "a::fn", "a", "c::data", "c"]);

    for instr in [

        il::Instr::Load { typ: il::Type::W8, dst: r, src: r, offset: 0 },

        il::Instr::Sload { typ: il::Type::W8, dst: r, src: r, offset: 0 },

        il::Instr::Ret { val: nil },

        il::Instr::Copy { dst: r, val: il::Val::Imm(9) },

        il::Instr::Unreachable, il::Instr::Ebreak, il::Instr::MemoryFence,

    ] { try checkInstructionNames(instr, &[]); }

}

/// Collect one instruction at exact-fit and every shorter symbol capacity.

unsafe fn checkInstructionNames(instr: il::Instr, expected: &[*[u8]]) throws (testing::TestError) {

    let mut body = [instr];

    let function = il::Fn {

        name: "p::f", params: &[], returnType: il::Type::W64, isExtern: false, isLeaf: true,

        blocks: &[il::Block { label: "entry", params: &[], instrs: &mut body[..], locs: &[], preds: &[], loopDepth: 0 }],

    };

    let local = il::Program { data: &[], fns: &[&function] };

    for capacity in 0..expected.len + 3 {

        let mut symbols: [*[u8]; 16] = [""; 16];

        let mut dependencies: [*[u8]; 5] = [""; 5];

        let symbolTable: 'tables = &mut symbols[..capacity], dependencyTable = &mut dependencies[..] in {

            let mut names = collect::new(symbolTable, dependencyTable);

            let mut failed = false;

            try collect::package(&mut names, "p", local, &[], nil) catch err {

                assert err == binary::Error::Capacity;

                set failed = true;

            };

            assert failed == (capacity < expected.len + 2);

            assert names.symbolCount <= capacity;

            if not failed {

                assert names.symbolCount == expected.len + 2;

                try testing::expectBytesEq(names.symbols[0], "p");

                try testing::expectBytesEq(names.symbols[1], "p::f");

                for name, i in expected { try testing::expectBytesEq(names.symbols[i + 2], name); }

                assert names.dependencyCount == expected.len / 2;

            }

        }

        for i in capacity..symbols.len { assert symbols[i].len == 0; }

    }

}