//! Native image placement, relocation, and wire-header checks.

use std::testing;

use std::lang::il;

use std::lang::alloc;

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

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

use std::collections::dict;

use std::arch::rv64;

use std::arch::rv64::image;

use std::arch::rv64::emit;

use std::arch::rv64::encode;

/// Arena for one emitter and its bounded relocation tables.

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

/// Data symbol lookup workspace.

unsafe static ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;

/// Scalar data emission preserves widths, signs, and little-endian order.

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

    let symbols = data::DataSymMap { dict: dict::init(&mut []), syms: &[] };

    let functions = labels::init(&mut [], &mut []);

    let item = il::Data {

        name: "scalar", size: 19, alignment: 1, readOnly: true, 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: 0x1234 }, count: 1 },

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W32, val: 0x12345678 }, count: 1 },

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

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

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

        ],

    };

    let mut buffer: [u8; 21] = [42; 21];

    let size = try data::emitSection(&[item], &symbols, &functions, 0, &mut buffer[1..20], true) catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(size == 19);

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

        42, 255, 255, 52, 18, 120, 86, 52, 18,

        254, 255, 255, 255, 255, 255, 255, 255, 111, 107, 0, 42,

    ]);

    let mut failed = false;

    try data::emitSection(&[item], &symbols, &functions, 0, &mut buffer[..18], true) catch err {

        try testing::expect(err == data::Error::Capacity);

        set failed = true;

    };

    try testing::expect(failed);

}

/// Finalization preserves hosted placement and propagates bounded failures.

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

    for scenario in 0..6 {

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

        let placement = image::Placement::Physical {

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

        } if scenario == 5 else image::Placement::Hosted;

        let entryPatch = rv64::EntryPatch::Reserved(nil) if scenario == 2 else rv64::EntryPatch::None;

        let mut generator = try! rv64::beginProgram(rv64::ProgramOptions {

            entryPatch, debug: false, placement,

        }, &mut arena);

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

        if scenario == 3 { set generator.e.error = rv64::Error::Capacity; }

        if scenario == 4 { emit::recordCall(&mut generator.e, "missing"); }

        let mut ro: [u8; 5] = [42; 5];

        let mut rw: [u8; 0] = [];

        let capacity: u32 = 2 if scenario == 1 else 3;

        let result = try rv64::finishProgram(generator, &[],

            rv64::Storage { dataSyms: &mut [], dataSymEntries: &mut ENTRIES[..] },

            &[7, 8, 9], &mut ro[1..capacity + 1], &mut rw[..]

        ) catch err {

            // Record the failure before the next independent generator is built.

            let expected = rv64::Error::Image(image::Error::Overlap) if scenario == 5

                else rv64::Error::Symbol if scenario == 2 or scenario == 4

                else rv64::Error::Capacity;

            assert err == expected;

            assert scenario <> 0;

            assert ro[0] == 42 and ro[capacity + 1] == 42;

            continue;

        };

        assert scenario == 0;

        assert result.layout.code.address == rv64::RO_DATA_BASE as u64 + 8;

        assert result.code.len == 1 and result.code[0] == encode::nop();

        assert result.roDataSize == 3 and result.rwDataSize == 0;

        assert ro[0] == 42 and ro[4] == 42;

        assert ro[1] == 7 and ro[2] == 8 and ro[3] == 9;

    }

}

/// Construct a small image with three disjoint high-address segments.

fn layout() -> image::Layout {

    return image::Layout {

        entry: 0x80000004,

        code: image::Segment { address: 0x80000000, initialized: 8, memory: 8 },

        roData: image::Segment { address: 0x80001000, initialized: 3, memory: 16 },

        rwData: image::Segment { address: 0x80002000, initialized: 4, memory: 4096 },

    };

}

/// Check the exact 64-byte little-endian header.

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

    let bytes = try image::header(layout()) catch {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(&bytes[..], &[

        82, 65, 68, 48, 2, 0, 0, 0, 4, 0, 0, 128, 0, 0, 0, 0,

        0, 0, 0, 128, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0,

        0, 16, 0, 128, 0, 0, 0, 0, 3, 0, 0, 0, 16, 0, 0, 0,

        0, 32, 0, 128, 0, 0, 0, 0, 4, 0, 0, 0, 0, 16, 0, 0,

    ]);

}

/// Check a rejected image layout.

fn invalid(item: image::Layout, expected: image::Error) throws (testing::TestError) {

    let mut failed = false;

    try image::validate(item) catch err {

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

        set failed = true;

    };

    try testing::expect(failed);

}

/// Check overlap, alignment, size, entry, and address overflow failures.

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

    let mut item = layout();

    set item.rwData.address = item.roData.address + 8;

    try invalid(item, image::Error::Overlap);

    set item = layout();

    set item.roData.address = item.code.address;

    try invalid(item, image::Error::Overlap);

    set item = layout();

    set item.rwData.address += 1;

    try invalid(item, image::Error::Alignment);

    set item = layout();

    set item.entry += 1;

    try invalid(item, image::Error::Alignment);

    set item = layout();

    set item.entry = item.code.address + item.code.initialized as u64;

    try invalid(item, image::Error::Entry);

    set item = layout();

    set item.roData.initialized = 17;

    try invalid(item, image::Error::Size);

    set item = layout();

    set item.rwData.address = 0xfffffffffffffff8;

    try invalid(item, image::Error::Overflow);

    set item = layout();

    set item.roData.address = item.code.address + 8;

    try image::validate(item) catch {

        throw testing::TestError::Failed;

    };

}

/// Check AUIPC/ADDI limits without overflowing unsigned address arithmetic.

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

    try testing::expect(image::displacement(0x180000000, 0x180002000) == 8192);

    try testing::expect(image::displacement(0x180002000, 0x180000000) == -8192);

    try testing::expect(image::displacement(0, 0x7ffff7ff) == 0x7ffff7ff);

    try testing::expect(image::displacement(0, 0x7ffff800) == nil);

    try testing::expect(image::displacement(0x80000000, 0) == -2147483648);

    try testing::expect(image::displacement(0x80000001, 0) == nil);

    try testing::expect(image::displacement(0, 0xffffffffffffffff) == nil);

    try testing::expect(image::displacement(0xffffffffffffffff, 0) == nil);

}

/// Check high physical placement, zero-fill extents, and 64-bit data relocations.

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

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

    let mut generator = try! rv64::beginProgram(rv64::ProgramOptions {

        entryPatch: rv64::EntryPatch::None, debug: false,

        placement: image::Placement::Physical {

            code: 0x180000000, roData: 0x180001000, rwData: 0x180002000, entry: 0x180000000,

        },

    }, &mut arena);

    emit::recordFunc(&mut generator.e, "p::entry");

    emit::recordFuncOffset(&mut generator.e, "p::entry");

    emit::recordDataAddrLoad(&mut generator.e, "p::pointer", rv64::A0);

    let globals = &[

        il::Data {

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

            values: &[il::DataValue { item: il::DataItem::Fn("p::entry"), count: 1 }],

        },

        il::Data {

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

        },

    ];

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

    let mut ro: [u8; 8] = [0; 8];

    let mut rw: [u8; 8] = [0; 8];

    let result = try rv64::finishProgram(generator, globals,

        rv64::Storage { dataSyms: &mut syms[..], dataSymEntries: &mut ENTRIES[..] },

        &[], &mut ro[..], &mut rw[..]

    ) catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(result.layout.code.address == 0x180000000);

    try testing::expect(result.layout.rwData.initialized == 8);

    try testing::expect(result.layout.rwData.memory == 4104);

    try testing::expect(syms[1].addr == 0x180002008);

    try testing::expectBytesEq(&rw[..], &[0, 0, 0, 128, 1, 0, 0, 0]);

    try testing::expect(result.code[0] == encode::auipc(rv64::A0, 2));

    try testing::expect(result.code[1] == encode::addi(rv64::A0, rv64::A0, 0));

}

/// Check bounded data-layout failure without wrapped addresses or symbol writes.

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

    let item = il::Data {

        name: "p::data", size: 16, alignment: 8, readOnly: false, isZeroInit: true, values: &[],

    };

    unsafe static syms: [data::DataSym; 1] = undefined;

    let mut count: u32 = 0;

    let mut failed = false;

    try data::layoutSection(&[item], &mut syms[..], &mut count, 0xfffffffffffffff8, false) catch err {

        try testing::expect(err == data::Error::Overflow);

        set failed = true;

    };

    try testing::expect(failed and count == 0);

    set failed = false;

    try data::layoutSection(&[item], &mut syms[..0], &mut count, 0x80000000, false) catch err {

        try testing::expect(err == data::Error::Capacity);

        set failed = true;

    };

    try testing::expect(failed and count == 0);

    set failed = false;

    try data::layoutSectionAtOffset(&[item], &mut syms[..], &mut count, 0, 0xfffffff8, false) catch err {

        try testing::expect(err == data::Error::Overflow);

        set failed = true;

    };

    try testing::expect(failed and count == 0);

}

/// Keep declared symbol extents and alignment gaps in initialized data.

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

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

    let mut generator = try! rv64::beginProgram(rv64::ProgramOptions {

        entryPatch: rv64::EntryPatch::None, debug: false,

        placement: image::Placement::Physical {

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

        },

    }, &mut arena);

    emit::recordDataAddrLoad(&mut generator.e, "p::second", rv64::A0);

    let globals = &[

        il::Data {

            name: "p::first", size: 5, alignment: 1, readOnly: false, isZeroInit: false,

            values: &[il::DataValue { item: il::DataItem::Str("a"), count: 1 }],

        },

        il::Data {

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

            values: &[il::DataValue { item: il::DataItem::Str("b"), count: 1 }],

        },

    ];

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

    let mut ro: [u8; 0] = [];

    let mut rw: [u8; 16] = [255; 16];

    let result = try rv64::finishProgram(generator, globals,

        rv64::Storage { dataSyms: &mut syms[..], dataSymEntries: &mut ENTRIES[..] },

        &[], &mut ro[..], &mut rw[..]

    ) catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(result.layout.rwData.initialized == 16);

    try testing::expect(syms[1].addr == 0x80002008);

    try testing::expectBytesEq(&rw[..], &[97, 0, 0, 0, 0, 0, 0, 0, 98, 0, 0, 0, 0, 0, 0, 0]);

}