//! Checked traversal of published IL operand tables.

use std::testing;

use std::lang::alloc;

use std::lang::il;

use std::lang::il::published;

/// Checked instruction construction preserves argument order and repeated uses.

@test fn testCheckedInstruction() throws (testing::TestError) {

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

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

    use arena as storage in {

        let instruction = try! buildCall(&storage);

        assert published::identity(&instruction) == nil;

        assert published::isCall(&instruction);

        let destination = published::destination(&instruction) else panic;

        assert destination.n == 9;

        let regs = published::registers(&instruction);

        assert regs.len == 3 and regs[0].n == 2 and regs[1].n == 7 and regs[2].n == 7;

        assert published::successors(&instruction).len == 0;

    }

}

/// Construct a call whose argument source ends with this stack frame.

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

    -> published::Instruction 'view throws (alloc::AllocError)

{

    let values = [il::Val::Imm(4), il::Val::Reg(il::Reg { n: 7 }),

        il::Val::Reg(il::Reg { n: 7 })];

    let args = try storage.copy(&values[..]);

    let code = try storage.new(published::Code 'view::Call { retTy: il::Type::W64,

        dst: il::Reg { n: 9 }, func: il::Val::Reg(il::Reg { n: 2 }), args });

    return try published::buildInstruction(code, nil, storage);

}

/// Publish operands from source tables that end with this stack frame.

unsafe fn transientInput 'view (storage: &Session 'view) -> published::Function 'view

    throws (alloc::AllocError)

{

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

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

    let mut instructions = [

        il::Instr::BinOp { op: il::BinOp::Add, typ: il::Type::W64, dst: il::Reg { n: 9 },

            a: il::Val::Reg(il::Reg { n: 5 }), b: il::Val::Reg(il::Reg { n: 6 }) },

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

    ];

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

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

    let function = il::Fn { name: "transient", params: &params[..], returnType: il::Type::W64,

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

    return try published::publish(&function, storage);

}

/// Analysis tables remain valid after their source stack frame returns.

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

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

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

    use arena as storage in {

        let view = try! transientInput(&storage);

        assert view.params.len == 1 and view.params[0].value.n == 5;

        let block = &view.blocks[0];

        assert block.params.len == 1 and block.params[0].value.n == 6;

        assert block.loopDepth == 2;

        let registers = published::registers(&block.instructions[0]);

        assert registers.len == 2 and registers[0].n == 5 and registers[1].n == 6;

        let destination = published::destination(&block.instructions[0]) else panic;

        assert destination.n == 9;

        assert not published::isCall(&block.instructions[0]);

        let returned = published::registers(&block.instructions[1]);

        assert returned.len == 1 and returned[0].n == 9;

        assert published::destination(&block.instructions[1]) == nil;

        assert published::successors(&block.instructions[1]).len == 0;

        let case published::Code::Fixed(fixed) = published::code(&block.instructions[1])

            else panic;

        let case il::Instr::Ret { val } = fixed else panic;

        let value = val else panic;

        let case il::Val::Reg(reg) = value else panic;

        assert reg.n == 9;

    }

}

/// Empty functions require no analysis storage.

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

    let function = il::Fn { name: "empty", params: &[], returnType: il::Type::W64,

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

    static DATA: [u8; 1] = [0; 1];

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

    use arena as storage in {

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

        assert view.params.len == 0 and view.blocks.len == 0;

    }

    assert alloc::used(&arena) == 0;

}

/// Publication retains source identities and scans nested argument groups.

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

    let value = il::Val::Reg(il::Reg { n: 7 });

    let mut arguments = [il::Val::Imm(3), value, value];

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

    let mut instructions = [il::Instr::Switch { val: value, defaultTarget: 0,

        defaultArgs: &mut [], cases: &mut cases[..] }];

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

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

    let function = il::Fn { name: "published", params: &[], returnType: il::Type::W64,

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

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

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

    let input: 'input = &function in {

        use arena as storage in {

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

            assert view.blocks.len == 1;

            let blockIdentity = view.blocks[0].identity else panic;

            assert blockIdentity == &blocks[0];

            let instruction = &view.blocks[0].instructions[0];

            let identity = published::identity(instruction) else panic;

            assert identity == &instructions[0];

            set arguments[1] = il::Val::Reg(il::Reg { n: 99 });

            set cases[0].target = 42;

            set instructions[0] = il::Instr::Ret { val: nil };

            let registers = published::registers(instruction);

            assert registers.len == 3;

            for reg in registers {

                assert reg.n == 7;

            }

            let targets = published::successors(instruction);

            assert targets.len == 2 and targets[0] == 0 and targets[1] == 0;

            let case published::Code::Switch { cases, defaultArgs, .. } = published::code(instruction)

                else panic;

            assert defaultArgs.len == 0 and cases.len == 1;

            assert cases[0].value == 1 and cases[0].target == 0;

            assert cases[0].args.len == 3;

            let case il::Val::Reg(reg) = cases[0].args[1] else panic;

            assert reg.n == 7;

        }

    }

}

/// Allocation failures leave no borrowed source storage in published results.

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

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

    let locations = [il::SrcLoc { moduleId: 5, offset: 17 }, il::SrcLoc { moduleId: 5, offset: 18 }];

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

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

    let mut instructions = [il::Instr::Call { retTy: il::Type::W64, dst: nil,

        func: il::Val::FnAddr("callee"), args: &args[..] },

        il::Instr::Switch { val: il::Val::Imm(1), defaultTarget: 0,

            defaultArgs: &mut args[..], cases: &mut cases[..] }];

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

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

    let function = il::Fn { name: "allocation", params: &[], returnType: il::Type::W64,

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

    let mut succeeded = false;

    for capacity in 0..2049 {

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

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

        let input: 'input = &function in {

            use arena as storage in {

                if let view = try? published::publish(input, &storage) {

                    let registers = published::registers(&view.blocks[0].instructions[0]);

                    assert registers.len == 1 and registers[0].n == 4;

                    assert view.blocks[0].locations.len == 2;

                    assert view.blocks[0].locations[0].offset == 17;

                    let case published::Code::Switch { cases, defaultArgs, .. } =

                        *published::code(&view.blocks[0].instructions[1]) else panic;

                    assert cases.len == 2 and cases[1].value == 2;

                    assert cases[1].args.len == 1 and defaultArgs.len == 1;

                    set succeeded = true;

                } else {

                    assert not succeeded;

                }

            }

        }

        alloc::reset(&mut arena);

        assert alloc::used(&arena) == 0;

    }

    assert succeeded;

}