//! Recoverable backend capacity and relocation checks.

use std::testing;

use std::io;

use std::lang::alloc;

use std::lang::il;

use std::lang::gen::data;

use std::lang::gen::labels;

use std::lang::gen::bitset;

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

use std::collections::dict;

use super::emit;

use super::encode;

use super::isel;

/// Branch forms whose taken edge supplies block parameters.

union ParameterEdge: Copy { Jump, Then, Else, Case, Default }

/// Selection owns parameter definitions, branch instructions, and edge arguments.

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

    for edge in [ParameterEdge::Jump, ParameterEdge::Then, ParameterEdge::Else,

        ParameterEdge::Case, ParameterEdge::Default]

    {

        let mut params = [il::Param { value: il::Reg { n: 0 }, type: il::Type::W64 }];

        let mut targetParams = [il::Param { value: il::Reg { n: 1 }, type: il::Type::W64 }];

        let mut args = [il::Val::Reg(il::Reg { n: 0 })];

        let mut cases = [il::SwitchCase { value: 1, target: 1, args: &mut args[..] }];

        let mut entry = [il::Instr::Jmp { target: 1, args: &mut args[..] }];

        match edge {

            case ParameterEdge::Then => set entry[0] = il::Instr::Br {

                op: il::CmpOp::Eq, typ: il::Type::W64, a: il::Val::Imm(1), b: il::Val::Imm(1),

                thenTarget: 1, thenArgs: &mut args[..], elseTarget: 2, elseArgs: &mut [],

            },

            case ParameterEdge::Else => set entry[0] = il::Instr::Br {

                op: il::CmpOp::Eq, typ: il::Type::W64, a: il::Val::Imm(1), b: il::Val::Imm(1),

                thenTarget: 2, thenArgs: &mut [], elseTarget: 1, elseArgs: &mut args[..],

            },

            case ParameterEdge::Case => set entry[0] = il::Instr::Switch {

                val: il::Val::Imm(1), defaultTarget: 2, defaultArgs: &mut [], cases: &mut cases[..],

            },

            case ParameterEdge::Default => set entry[0] = il::Instr::Switch {

                val: il::Val::Imm(0), defaultTarget: 1, defaultArgs: &mut args[..], cases: &mut [],

            },

            else => {},

        }

        let mut target = [il::Instr::Ret { val: il::Val::Reg(il::Reg { n: 1 }) }];

        let mut other = [il::Instr::Ret { val: il::Val::Imm(0) }];

        let blocks = [

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

            il::Block { label: "target", params: &targetParams[..], instrs: &mut target[..], locs: &[], preds: &[], loopDepth: 0 },

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

        ];

        let func = il::Fn { name: "p::parameters", params: &params[..], returnType: il::Type::W64,

            isExtern: false, isLeaf: true, blocks: &blocks[..] };

        let mut functionArena = alloc::new(&mut FUNCTION_STORAGE[..]);

        let mut scratchArena = alloc::new(&mut SCRATCH[..]);

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

        let mut gen = generator(&mut code);

        use functionArena as functionStorage in {

            let view = try! il::published::publish(&func, &functionStorage);

            let config = super::targetConfig();

            use scratchArena as scratchStorage in {

                let allocation = try! regalloc::allocate(&view, &config, &scratchStorage);

                isel::selectFn(&mut gen.e, &allocation, &view);

                assert gen.e.error == nil;

                let expected = try! functionStorage.copy(&gen.e.code[..gen.e.codeLen]);

                set params[0].value.n = 0xffffffff;

                set targetParams[0].value.n = 0xffffffff;

                set args[0] = il::Val::Imm(42);

                set cases[0].value = 99;

                set entry[0] = il::Instr::Unreachable;

                set target[0] = il::Instr::Ret { val: il::Val::Imm(99) };

                alloc::reset(&mut code);

                set gen = generator(&mut code);

                isel::selectFn(&mut gen.e, &allocation, &view);

                assert gen.e.error == nil and gen.e.codeLen == expected.len;

                for word, i in expected {

                    assert gen.e.code[i] == word;

                }

            }

            alloc::reset(&mut scratchArena);

            assert view.blocks.len == 3;

            assert il::published::successors(&view.blocks[0].instructions[0]).len > 0;

        }

    }

}

/// Reusable emitter allocation storage.

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

/// Published function storage for disjoint-lifetime selection.

static FUNCTION_STORAGE: [u8; 4096] = [0; 4096];

/// Checked IL construction reaches instruction selection without a raw IL import.

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

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

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

    let mut e = try! emit::emitter(&mut code, false);

    use arena as storage in {

        try! selectConstructed(&storage, &mut e);

    }

}

/// Construct a published function that returns a constant.

fn constructedFunction 'view (storage: &Session 'view)

    -> il::published::Function 'view throws (alloc::AllocError) {

    let copy = try storage.new(il::published::Code 'view::Fixed(

        il::Instr::Copy { dst: il::Reg { n: 0 }, val: il::Val::Imm(7) }));

    let ret = try storage.new(il::published::Code 'view::Fixed(

        il::Instr::Ret { val: il::Val::Reg(il::Reg { n: 0 }) }));

    let first = try il::published::buildInstruction(copy, nil, storage);

    let instructions = try storage.fill(first, 2);

    set instructions[1] = try il::published::buildInstruction(ret, nil, storage);

    let noParams: [il::Param; 0] = [];

    let params: &'view [il::Param] = try storage.copy(&noParams[..]);

    let noLocations: [il::SrcLoc; 0] = [];

    let locations = try storage.copy(&noLocations[..]);

    let blocks = try storage.fill(il::published::Block 'view { identity: nil, params,

        instructions: &instructions[..], locations, loopDepth: 0 }, 1);

    return il::published::Function 'view { name: "p::constructed", isLeaf: true,

        params, blocks: &blocks[..] };

}

/// Check the selected constant materialization and register move.

fn checkConstructedSelection 'scratch (

    e: &emit::Emitter, allocation: &regalloc::AllocResult 'scratch

) {

    assert e.error == nil;

    let assigned = allocation.assignments[0] else panic;

    let expected = encode::addi(super::SCRATCH1, super::ZERO, 7);

    let move = encode::mv(assigned, super::SCRATCH1);

    let output: 'output = &*e in {

        let mut found = false;

        let mut moved = *assigned == *super::SCRATCH1;

        for word in emit::getCode(output) {

            if word == expected {

                set found = true;

            }

            if word == move {

                set moved = true;

            }

        }

        assert found and moved;

    }

}

/// Construct, allocate, and select a function that returns a constant.

fn selectConstructed 'view (storage: &Session 'view, e: &mut emit::Emitter)

    throws (alloc::AllocError)

{

    let function = try constructedFunction(storage);

    let config = super::targetConfig();

    let allocation = try regalloc::allocate(&function, &config, storage);

    isel::selectFn(e, &allocation, &function);

    checkConstructedSelection(e, &allocation);

}

/// Published IL remains valid after disjoint register-allocation scratch is reclaimed.

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

    let mut functionArena = alloc::new(&mut FUNCTION_STORAGE[..]);

    let mut scratchArena = alloc::new(&mut SCRATCH[..]);

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

    let mut e = try! emit::emitter(&mut codeArena, false);

    use functionArena as functionStorage in {

        let function = try! constructedFunction(&functionStorage);

        use scratchArena as scratchStorage in {

            let config = super::targetConfig();

            let allocation = try! regalloc::allocate(&function, &config, &scratchStorage);

            isel::selectFn(&mut e, &allocation, &function);

            checkConstructedSelection(&e, &allocation);

        }

        alloc::reset(&mut scratchArena);

        let copyInstruction = &function.blocks[0].instructions[0];

        let case il::published::Code::Fixed(copyCode) =

            il::published::code(copyInstruction) else panic;

        let case il::Instr::Copy { dst, val } = copyCode else panic;

        assert dst.n == 0 and val == il::Val::Imm(7);

        let operands = il::published::registers(&function.blocks[0].instructions[1]);

        assert operands.len == 1 and operands[0].n == 0;

    }

}

/// Selection owns call arguments and instructions used to size the stack frame.

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

    for indirect in [false, true] {

        let params = [il::Param { value: il::Reg { n: 0 }, type: il::Type::W64 }];

        let mut args = [il::Val::Imm(7), il::Val::Reg(il::Reg { n: 1 })];

        let callee = il::Val::Reg(il::Reg { n: 0 }) if indirect else il::Val::FnAddr("callee");

        let mut instructions = [

            il::Instr::Reserve { dst: il::Reg { n: 1 }, size: il::Val::Imm(16), alignment: 8 },

            il::Instr::Call { retTy: il::Type::W64, dst: il::Reg { n: 2 }, func: callee,

                args: &args[..] },

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

        ];

        let blocks = [il::Block { label: "entry", params: &[], instrs: &mut instructions[..],

            locs: &[], preds: &[], loopDepth: 0 }];

        let mut func = il::Fn { name: "p::calls", params: &params[..], returnType: il::Type::W64,

            isExtern: false, isLeaf: false, blocks: &blocks[..] };

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

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

        let mut gen = generator(&mut code);

        use arena as storage in {

            let view = try! il::published::publish(&func, &storage);

            let config = super::targetConfig();

            let allocation = try! regalloc::allocate(&view, &config, &storage);

            isel::selectFn(&mut gen.e, &allocation, &view);

            assert gen.e.error == nil;

            let expected = try! storage.copy(&gen.e.code[..gen.e.codeLen]);

            set args[0] = il::Val::Imm(99);

            set args[1] = il::Val::Imm(100);

            set func.isLeaf = true;

            for i in 0..instructions.len {

                set instructions[i] = il::Instr::Unreachable;

            }

            alloc::reset(&mut code);

            set gen = generator(&mut code);

            isel::selectFn(&mut gen.e, &allocation, &view);

            assert gen.e.error == nil and gen.e.codeLen == expected.len;

            for word, i in expected {

                assert gen.e.code[i] == word;

            }

        }

    }

}

/// Selection retains published locations and consecutive-location deduplication.

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

    // Storage for machine instructions, fixups, and source location entries.

    static DEBUG_MEMORY: [u8; 33554432] = [0; 33554432];

    let mut locations = [il::SrcLoc { moduleId: 1, offset: 10 },

        il::SrcLoc { moduleId: 1, offset: 10 }, il::SrcLoc { moduleId: 2, offset: 20 }];

    let mut instructions = [

        il::Instr::Copy { dst: il::Reg { n: 0 }, val: il::Val::Imm(3) },

        il::Instr::Copy { dst: il::Reg { n: 1 }, val: il::Val::Reg(il::Reg { n: 0 }) },

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

    ];

    let blocks = [il::Block { label: "entry", params: &[], instrs: &mut instructions[..],

        locs: &locations[..], preds: &[], loopDepth: 0 }];

    let func = il::Fn { name: "p::locations", params: &[], returnType: il::Type::W64,

        isExtern: false, isLeaf: true, blocks: &blocks[..] };

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

    let mut debugCode = alloc::new(&mut DEBUG_MEMORY[..]);

    let mut emitter = try emit::emitter(&mut debugCode, true) catch {

        io::printLn("publishedLocations: emitter allocation");

        throw testing::TestError::Failed;

    };

    use arena as storage in {

        let view = try! il::published::publish(&func, &storage);

        let config = super::targetConfig();

        let allocation = try! regalloc::allocate(&view, &config, &storage);

        for i in 0..locations.len {

            set locations[i] = il::SrcLoc { moduleId: 9, offset: 99 };

        }

        isel::selectFn(&mut emitter, &allocation, &view);

        assert emitter.error == nil;

        let output: 'output = &emitter in {

            let entries = emit::getDebugEntries(output);

            assert entries.len == 2;

            assert entries[0].moduleId == 1 and entries[0].offset == 10;

            assert entries[1].moduleId == 2 and entries[1].offset == 20;

            assert entries[0].pc <= entries[1].pc;

        }

    }

}

/// Function and liveness test storage.

static SCRATCH: [u8; 65536] = [0; 65536];

/// Code output with guard words for instruction selection checks.

static SELECTION_WORDS: [u32; 130] = [0; 130];

/// Dictionary storage for bounded map tests.

unsafe static ENTRIES: [dict::Entry; 4] = undefined;

/// Build a non-debug generator with a fixed code address.

unsafe fn generator(arena: &mut alloc::Arena) -> super::Generator {

    return try! super::beginProgram(super::ProgramOptions {

        entryPatch: super::EntryPatch::None, debug: false,

        placement: super::image::Placement::Physical {

            code: 0x80000000, roData: 0x80001000, rwData: 0x80002000, entry: 0x80000000,

        },

    }, arena);

}

/// Exhaust each emitter storage class and ensure writes stop at the first error.

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

    for kind in 0..8 {

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

        let mut e = try! emit::emitter(&mut arena, false);

        match kind {

            case 0 => {

                set e.code = &mut e.code[..0];

                emit::emit(&mut e, encode::nop());

            },

            case 1 => {

                set e.pendingBranchesLen = e.pendingBranches.len;

                emit::recordBranch(&mut e, 0, emit::BranchKind::Jump);

            },

            case 2 => {

                set e.pendingCallsLen = e.pendingCalls.len;

                emit::recordCall(&mut e, "p::call");

            },

            case 3 => {

                set e.pendingJumpsLen = e.pendingJumps.len;

                emit::recordJumpAt(&mut e, "p::jump", super::ZERO, 0);

            },

            case 4 => {

                set e.pendingAddrLoadsLen = e.pendingAddrLoads.len;

                emit::recordDataAddrLoad(&mut e, "p::data", super::A0);

            },

            case 5 => {

                set e.funcsLen = e.funcs.len;

                emit::recordFunc(&mut e, "p::call");

            },

            case 6 => {

                let entries = &mut ENTRIES[..2];

                set e.labels.funcs = dict::init(&mut entries[..]);

                emit::recordFuncOffset(&mut e, "p::first");

                emit::recordFuncOffset(&mut e, "p::second");

            },

            else => {

                emit::recordSrcLoc(&mut e, il::SrcLoc { moduleId: 0, offset: 0 });

            },

        }

        try testing::expect(e.error == super::Error::Capacity);

        let count = e.codeLen;

        emit::emit(&mut e, encode::ebreak());

        try testing::expect(e.codeLen == count);

        let mut rejected = false;

        try emit::check(&e) catch err {

            try testing::expect(err == super::Error::Capacity); set rejected = true;

        };

        try testing::expect(rejected);

    }

}

/// Missing labels and long jumps return errors without corrupting instructions.

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

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

    let mut e = try! emit::emitter(&mut arena, false);

    emit::recordCall(&mut e, "missing");

    emit::patchCalls(&mut e);

    try check(e.error == super::Error::Symbol, "missing function");

    alloc::reset(&mut arena);

    set e = try! emit::emitter(&mut arena, false);

    emit::recordBranch(&mut e, 0, emit::BranchKind::Jump);

    labels::recordBlock(&mut e.labels, 0, 0x200000);

    emit::patchLocalBranches(&mut e);

    try check(e.error == super::Error::Relocation, "long branch");

    try check(e.code[0] == encode::nop(), "rejected branch unchanged");

    alloc::reset(&mut arena);

    set e = try! emit::emitter(&mut arena, false);

    let blockCount = e.labels.blockOffsets.len;

    emit::recordBlock(&mut e, blockCount);

    try check(e.error == super::Error::Capacity, "block capacity");

}

/// Arena setup and per-function failures restore their saved offsets for reuse.

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

    let small = &mut SCRATCH[..64];

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

    set arena.offset = 8;

    let mut failed = false;

    try super::beginProgram(super::ProgramOptions {

        entryPatch: super::EntryPatch::None, debug: false, placement: super::image::Placement::Hosted,

    }, &mut arena) catch err {

        try check(err == super::Error::Allocation, "generator allocation"); set failed = true;

    };

    try check(failed and arena.offset == 8, "generator arena restored");

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

    let mut gen = generator(&mut code);

    let mut instructions = [

        il::Instr::Copy { dst: il::Reg { n: 0 }, val: il::Val::Imm(1) },

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

    ];

    let func = il::Fn {

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

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

    };

    super::generateFunction(&mut gen, &func, &mut arena);

    try check(gen.e.error == super::Error::Allocation and arena.offset == 8, "function arena restored");

    alloc::reset(&mut code);

    set gen = generator(&mut code);

    let mut scratch = alloc::new(&mut SCRATCH[..]);

    set scratch.offset = 16;

    super::generateFunction(&mut gen, &func, &mut scratch);

    try check(gen.e.error == nil and gen.e.codeLen > 0 and scratch.offset == 16, "function retry");

    alloc::reset(&mut code);

    set gen = generator(&mut code);

    set instructions[0] = il::Instr::Copy { dst: il::Reg { n: 8192 }, val: il::Val::Imm(1) };

    super::generateFunction(&mut gen, &func, &mut scratch);

    try check(gen.e.error == super::Error::Allocation and scratch.offset == 16, "SSA capacity");

}

/// Spill candidate storage fails explicitly when too many values are live.

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

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

    use arena as bits in {

        let liveSet = try! bitset::allocate(&bits, 257);

        for i in 0..257 {

            bitset::put(liveSet, i);

        }

        let live = regalloc::liveness::LiveInfo 'bits {

            liveIn: &liveSet[..0], liveOut: &liveSet[..],

            defs: &liveSet[..0], uses: &liveSet[..0],

            words: bitset::wordsFor(257), blockCount: 1, maxReg: 257,

        };

        let func = il::Fn {

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

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

        };

        let mut failed = false;

        let view = try! il::published::publish(&func, &bits);

        try regalloc::spill::analyze(&view, &live, 23, 11, 8, &bits) catch {

            set failed = true;

        };

        try testing::expect(failed);

    }

}

/// Data output and symbol maps reject insufficient or ambiguous storage.

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

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

    let e = try! emit::emitter(&mut arena, false);

    let syms = &[data::DataSym { name: "p::data", addr: 0x80002000 }];

    let entries = &mut ENTRIES[..2];

    let map = try! data::buildMap(syms, &mut entries[..]);

    let items = &[il::Data {

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

        values: &[il::DataValue { item: il::DataItem::Val { typ: il::Type::W64, val: 1 }, count: 1 }],

    }];

    let mut bytes: [u8; 8] = [255; 8];

    let mut failed: u32 = 0;

    try data::emitSection(items, &map, &e.labels, 0x80000000, &mut bytes[..7], false) catch err {

        try testing::expect(err == data::Error::Capacity); set failed += 1;

    };

    try data::buildMap(syms, &mut entries[..1]) catch err {

        try testing::expect(err == data::Error::Capacity); set failed += 1;

    };

    let larger = &mut ENTRIES[..4];

    unsafe static duplicate: [data::DataSym; 2] = undefined;

    set duplicate = [syms[0], syms[0]];

    try data::buildMap(&duplicate[..], &mut larger[..]) catch err {

        try testing::expect(err == data::Error::Symbol); set failed += 1;

    };

    try testing::expect(failed == 3);

    let length = try data::emitSection(items, &map, &e.labels, 0x80000000, &mut bytes[..], false)

        catch {

            throw testing::TestError::Failed;

        };

    try testing::expect(length == 8 and bytes[0] == 1);

}

/// Inline instruction selection respects every shorter output capacity.

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

    let dst = il::Reg { n: 3 };

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

    let second = il::Reg { n: 1 };

    let a = il::Val::Reg(first);

    let b = il::Val::Reg(second);

    let instructions = [

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

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

        il::Instr::Load { typ: il::Type::W8, dst, src: first, offset: 4096 },

        il::Instr::Sload { typ: il::Type::W16, dst, src: first, offset: -4096 },

        il::Instr::Store { typ: il::Type::W32, src: a, dst: second, offset: 4096 },

        il::Instr::Copy { dst, val: il::Val::Imm(0x123456789abcdef) },

        il::Instr::Reserve { dst, size: il::Val::Imm(32), alignment: 16 },

        il::Instr::Reserve { dst, size: a, alignment: 16 },

        il::Instr::Blit { dst: first, src: second, size: il::Val::Imm(0) },

        il::Instr::Blit { dst: first, src: second, size: il::Val::Imm(8) },

        il::Instr::Blit { dst: first, src: second, size: il::Val::Imm(40) },

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

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

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

        il::Instr::Unreachable,

        il::Instr::Ecall { dst, num: a, a0: b, a1: a, a2: b, a3: a },

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

        il::Instr::DeviceWrite { typ: il::Type::W8, handle: a, offset: b, value: a },

        il::Instr::Ebreak,

        il::Instr::MemoryFence,

    ];

    for instr in instructions {

        try checkSelectionCapacity(instr, nil);

    }

}

/// Direct and indirect calls check argument and output capacities.

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

    let a = il::Val::Reg(il::Reg { n: 0 });

    let b = il::Val::Reg(il::Reg { n: 1 });

    let args = [b, a, b, a, il::Val::Imm(7), a, b, a, a];

    for callee in [il::Val::FnAddr("p::callee"), a] {

        for dst in [nil as ?il::Reg, il::Reg { n: 3 }] {

            for count in [0 as u32, 8, 9] {

                let instr = il::Instr::Call {

                    retTy: il::Type::W64, dst, func: callee, args: &args[..count],

                };

                let expected: ?super::Error = super::Error::Capacity if count == 9 else nil;

                try checkSelectionCapacity(instr, expected);

            }

        }

    }

}

/// Switch cases and default edges respect every shorter output capacity.

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

    for count in 0..3 {

        for argumentMask in 0..8 {

            try checkSwitchCapacity(count, argumentMask);

        }

    }

}

/// Build a switch with independently selected case and default arguments.

unsafe fn checkSwitchCapacity(count: u32, argumentMask: u32) throws (testing::TestError) {

    let params = [il::Param { value: il::Reg { n: 0 }, type: il::Type::W64 }];

    let firstParams = [il::Param { value: il::Reg { n: 1 }, type: il::Type::W64 }];

    let secondParams = [il::Param { value: il::Reg { n: 2 }, type: il::Type::W64 }];

    let defaultParams = [il::Param { value: il::Reg { n: 3 }, type: il::Type::W64 }];

    let firstCount: u32 = 1 if argumentMask & 1 <> 0 else 0;

    let secondCount: u32 = 1 if argumentMask & 2 <> 0 else 0;

    let defaultCount: u32 = 1 if argumentMask & 4 <> 0 else 0;

    let mut firstArgs = [il::Val::Imm(11)];

    let mut secondArgs = [il::Val::Imm(22)];

    let mut defaultArgs = [il::Val::Reg(il::Reg { n: 0 })];

    let mut cases = [

        il::SwitchCase { value: 0, target: 1, args: &mut firstArgs[..firstCount] },

        il::SwitchCase { value: 0x123456789abcdef, target: 2, args: &mut secondArgs[..secondCount] },

    ];

    let mut entry = [il::Instr::Switch {

        val: il::Val::Reg(il::Reg { n: 0 }), defaultTarget: 3,

        defaultArgs: &mut defaultArgs[..defaultCount], cases: &mut cases[..count],

    }];

    let mut first = [il::Instr::Ret {

        val: il::Val::Reg(il::Reg { n: 1 }) if firstCount > 0 else il::Val::Imm(11),

    }];

    let mut second = [il::Instr::Ret {

        val: il::Val::Reg(il::Reg { n: 2 }) if secondCount > 0 else il::Val::Imm(22),

    }];

    let mut fallback = [il::Instr::Ret {

        val: il::Val::Reg(il::Reg { n: 3 }) if defaultCount > 0 else il::Val::Imm(33),

    }];

    let predecessors = [0 as u32];

    let blocks = [

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

        il::Block {

            label: "first", params: &firstParams[..firstCount], instrs: &mut first[..],

            locs: &[], preds: &predecessors[..1 if count > 0 else 0], loopDepth: 0,

        },

        il::Block {

            label: "second", params: &secondParams[..secondCount], instrs: &mut second[..],

            locs: &[], preds: &predecessors[..1 if count > 1 else 0], loopDepth: 0,

        },

        il::Block {

            label: "default", params: &defaultParams[..defaultCount], instrs: &mut fallback[..],

            locs: &[], preds: &predecessors[..], loopDepth: 0,

        },

    ];

    let func = il::Fn {

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

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

    };

    try checkFunctionCapacity(&func, nil);

}

/// Jumps preserve argument moves and capacity checks in both block layouts.

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

    for target in [1 as u32, 2] {

        for count in 0..3 {

            let params = [

                il::Param { value: il::Reg { n: 0 }, type: il::Type::W64 },

                il::Param { value: il::Reg { n: 1 }, type: il::Type::W64 },

            ];

            let targetParams = [

                il::Param { value: il::Reg { n: 2 }, type: il::Type::W64 },

                il::Param { value: il::Reg { n: 3 }, type: il::Type::W64 },

            ];

            let mut args = [il::Val::Reg(il::Reg { n: 1 }), il::Val::Reg(il::Reg { n: 0 })];

            let mut entry = [il::Instr::Jmp { target, args: &mut args[..count] }];

            let mut body = [il::Instr::Ret {

                val: il::Val::Reg(il::Reg { n: count + 1 }) if count > 0 else il::Val::Imm(7),

            }];

            let mut unused = [il::Instr::Ret { val: il::Val::Imm(0) }];

            let destination = il::Block {

                label: "destination", params: &targetParams[..count], instrs: &mut body[..],

                locs: &[], preds: &[0], loopDepth: 0,

            };

            let other = il::Block {

                label: "other", params: &[], instrs: &mut unused[..],

                locs: &[], preds: &[], loopDepth: 0,

            };

            let blocks = [

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

                destination if target == 1 else other,

                other if target == 1 else destination,

            ];

            let func = il::Fn {

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

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

            };

            try checkFunctionCapacity(&func, nil);

        }

    }

}

/// Conditional edges preserve capacity checks for each comparison and layout.

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

    for op in [il::CmpOp::Eq, il::CmpOp::Ne, il::CmpOp::Slt, il::CmpOp::Ult] {

        for typ in [il::Type::W8, il::Type::W16, il::Type::W32, il::Type::W64] {

            for layout in 0..2 {

                for argumentSide in 0..3 {

                    try checkBranchCapacity(op, typ, layout, argumentSide);

                }

            }

        }

    }

}

/// Build a branch with no arguments or arguments on exactly one edge.

unsafe fn checkBranchCapacity(op: il::CmpOp, typ: il::Type, layout: u32, argumentSide: u32)

    throws (testing::TestError)

{

    let a = il::Val::Reg(il::Reg { n: 0 });

    let b = il::Val::Reg(il::Reg { n: 1 });

    let params = [

        il::Param { value: il::Reg { n: 0 }, type: il::Type::W64 },

        il::Param { value: il::Reg { n: 1 }, type: il::Type::W64 },

    ];

    let thenParams = [il::Param { value: il::Reg { n: 2 }, type: il::Type::W64 }];

    let elseParams = [il::Param { value: il::Reg { n: 3 }, type: il::Type::W64 }];

    let thenCount: u32 = 1 if argumentSide == 1 else 0;

    let elseCount: u32 = 1 if argumentSide == 2 else 0;

    let mut thenArgs = [b];

    let mut elseArgs = [a];

    let mut entry = [il::Instr::Br {

        op, typ, a, b: il::Val::Imm(0) if argumentSide == 1 else b,

        thenTarget: 1 if layout == 0 else 2, thenArgs: &mut thenArgs[..thenCount],

        elseTarget: 2 if layout == 0 else 1, elseArgs: &mut elseArgs[..elseCount],

    }];

    let mut thenBody = [il::Instr::Ret {

        val: il::Val::Reg(il::Reg { n: 2 }) if thenCount > 0 else il::Val::Imm(10),

    }];

    let mut elseBody = [il::Instr::Ret {

        val: il::Val::Reg(il::Reg { n: 3 }) if elseCount > 0 else il::Val::Imm(20),

    }];

    let thenBlock = il::Block {

        label: "then", params: &thenParams[..thenCount], instrs: &mut thenBody[..],

        locs: &[], preds: &[0], loopDepth: 0,

    };

    let elseBlock = il::Block {

        label: "else", params: &elseParams[..elseCount], instrs: &mut elseBody[..],

        locs: &[], preds: &[0], loopDepth: 0,

    };

    let blocks = [

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

        thenBlock if layout == 0 else elseBlock,

        elseBlock if layout == 0 else thenBlock,

    ];

    let func = il::Fn {

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

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

    };

    try checkFunctionCapacity(&func, nil);

}

/// Verify instruction errors, exact-fit output, and shorter-buffer canaries.

unsafe fn checkSelectionCapacity(instr: il::Instr, expectedError: ?super::Error) throws (testing::TestError) {

    let mut body = [instr, il::Instr::Ret { val: il::Val::Imm(0) }];

    let mut count: u32 = 2;

    if let case il::Instr::Ret { .. } = instr {

        set count = 1;

    }

    let params = [

        il::Param { value: il::Reg { n: 0 }, type: il::Type::W64 },

        il::Param { value: il::Reg { n: 1 }, type: il::Type::W64 },

    ];

    let func = il::Fn {

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

        isExtern: false, isLeaf: not il::isCall(instr),

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

    };

    try checkFunctionCapacity(&func, expectedError);

}

/// Verify function output capacity and failure propagation with guard words.

unsafe fn checkFunctionCapacity(func: &il::Fn, expectedError: ?super::Error) throws (testing::TestError) {

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

    let mut gen = generator(&mut arena);

    let mut scratch = alloc::new(&mut SCRATCH[..]);

    super::generateFunction(&mut gen, func, &mut scratch);