//! Build a machine fixture from separately decoded and linked packages.

use std::sys;

use std::sys::unix;

use std::mem;

use std::lang::alloc;

use std::lang::il::binary;

use std::lang::il::binary::program;

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

use std::arch::rv64;

use std::arch::rv64::shared;

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

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

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

/// Separate code arenas preserve the boot catalog's package records.

unsafe static CODE: [[u8; 16777216]; 3] = undefined;

/// Reusable function workspace.

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

/// Decoder arena shared by the two input packages.

static DECODE: [u8; 1048576] = [0; 1048576];

/// Input file buffer.

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

/// Persistent private templates.

unsafe static TEMPLATES: [[u8; 16384]; 2] = undefined;

/// Local symbol workspaces.

unsafe static SYMBOLS: [[shared::Symbol; 128]; 2] = undefined;

/// Package exports.

unsafe static EXPORTS: [[shared::Symbol; 128]; 2] = undefined;

/// Private pointer fixups.

unsafe static RELOCS: [[shared::Relocation; 128]; 2] = undefined;

/// Data layout workspaces.

unsafe static DATA: [[data::DataSym; 128]; 2] = undefined;

/// Native instruction image, with fixed package placements.

static TEXT: [u32; 4096] = [0; 4096];

/// Two private graphs followed by their package-state tables.

static STATE: [u8; 69632] = [0; 69632];

/// Decode trusted package IL into persistent storage.

unsafe fn load(path: *[u8], arena: &mut alloc::Arena) -> binary::Package {

    let length = unix::readFile(path, &mut INPUT[..]) else panic "missing package";

    return try! program::decode(&INPUT[..length], arena, binary::Limits { registers: 8192, blocks: 4096 });

}

/// Compile through the same entry used for boot catalogs and runtime loading.

unsafe fn compile(input: &binary::Package, index: u32, imports: &[shared::Symbol]) -> shared::Package throws (shared::Error) {

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

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

    return try shared::compile(input, index, 0x80011000 + index as u64 * 4096, imports,

        shared::Storage {

            data: &mut DATA[index][..], symbols: &mut SYMBOLS[index][..], exports: &mut EXPORTS[index][..],

            template: &mut TEMPLATES[index][..], relocations: &mut RELOCS[index][..],

        }, &mut arena, &mut scratch);

}

/// Append a call result check and return its branch patch location.

fn check(e: &mut emit::Emitter, entry: u64, expected: i64) -> u32 {

    let delta = entry - (0x80010000 + e.codeLen as u64 * 4);

    emit::emit(e, encode::jal(rv64::RA, delta as i32));

    emit::loadImm(e, rv64::T0, expected);

    let index = e.codeLen;

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

    return index;

}

/// Emit an explicit platform completion status.

fn finish(e: &mut emit::Emitter, status: i64) {

    emit::loadImm(e, rv64::T0, 0x10001000);

    emit::loadImm(e, rv64::T1, status);

    emit::emit(e, encode::sw(rv64::T1, rv64::T0, 0));

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

}

/// Verify catalog linking, then execute one code copy against two private graphs.

@default unsafe fn main(env: *sys::Env) -> i32 {

    assert env.args.len == 4;

    let mut decoder = alloc::new(&mut DECODE[..]);

    let supportInput = load(env.args[1], &mut decoder);

    let appInput = load(env.args[2], &mut decoder);

    let support = try! compile(&supportInput, 0, &[]);

    let mut far: [shared::Symbol; 128] = undefined;

    for symbol, i in support.exports {

        set far[i] = symbol;

        match symbol.target {

            case shared::Target::Function(_) => {

                set far[i].target = shared::Target::Function(0x180000000);

            },

            else => {

            },

        }

    }

    let mut rejected = false;

    try compile(&appInput, 1, &far[..support.exports.len]) catch err {

        assert err == shared::Error::Range;

        set rejected = true;

    };

    assert rejected;

    let app = try! compile(&appInput, 1, support.exports);

    let catalog = [support, app];

    assert app.relocations.len > 0;

    let entry = app.entry else panic "missing entry";

    for i in 0..STATE.len {

        set STATE[i] = 0;

    }

    for domain in 0..2 {

        let mut bases: [u64; 256] = [0; 256];

        for package, i in &catalog[..] {

            let offset = domain * 32768 + i * 16384;

            set bases[i] = 0x80020000 + offset as u64;

        }

        for package, i in &catalog[..] {

            let offset = domain * 32768 + i * 16384;

            try! shared::instantiate(&package, &bases[..], &mut STATE[offset..offset + 16384]);

        }

        let table = @sliceOf(&bases[0] as *unsafe u8, @sizeOf([u64; 256]));

        let tableOffset: u32 = 65536 + domain * 2048;

        try! mem::copy(&mut STATE[tableOffset..], table);

    }

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

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

    emit::loadImm(&mut e, rv64::GP, 0x80030000);

    let first = check(&mut e, entry, 142);

    let second = check(&mut e, entry, 143);

    emit::loadImm(&mut e, rv64::GP, 0x80030800);

    let other = check(&mut e, entry, 142);

    emit::loadImm(&mut e, rv64::GP, 0x80030000);

    let resumed = check(&mut e, entry, 144);

    finish(&mut e, 0x5555);

    let failure = e.codeLen;

    finish(&mut e, 0x13333);

    for index in &[first, second, other, resumed] {

        emit::patch(&mut e, index, encode::bne(rv64::A0, rv64::T0, (failure - index) as i32 * 4));

    }

    for i in 0..TEXT.len {

        set TEXT[i] = encode::nop();

    }

    assert e.codeLen <= 1024;

    let codeEmitter: 'code = &e in {

        for word, i in emit::getCode 'code (codeEmitter) {

            set TEXT[i] = word;

        }

    }

    for package, i in &catalog[..] {

        assert package.code.len <= 1024;

        for word, j in package.code {

            set TEXT[1024 + i * 1024 + j] = word;

        }

    }

    let header = try! image::header(image::Layout {

        entry: 0x80010000,

        code: image::Segment { address: 0x80010000, initialized: 16384, memory: 16384 },

        roData: image::Segment { address: 0, initialized: 0, memory: 0 },

        rwData: image::Segment { address: 0x80020000, initialized: STATE.len, memory: STATE.len },

    });

    let fd = unix::openOpts(env.args[3], unix::OpenFlags(*unix::O_WRONLY | *unix::O_CREAT | *unix::O_TRUNC), 420);

    assert fd >= 0;

    let written = unix::writeAll(fd, &header[..]) and unix::writeAll(fd, @sliceOf(&TEXT[0] as *u8, 16384)) and unix::writeAll(fd, &STATE[..]);

    let closed = unix::close(fd) == 0;

    assert written and closed;

    return 0;

}