//! 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;

/// Reusable emitter allocation storage.

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

/// Function and liveness test storage.

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

/// 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;

        try regalloc::spill::analyze(&func, &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);

}

/// Name the failed invariant before returning to the test runner.

fn check(condition: bool, name: *[u8]) throws (testing::TestError) {

    if not condition {

        io::printLn(name);

        throw testing::TestError::Failed;

    }

}