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

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

}