//! Build a native kernel image with shared packages and a persistent boot catalog.

use std::sys;

use std::io;

use std::mem;

use std::sys::unix;

use std::lang::alloc;

use std::lang::strings;

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

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

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

use std::arch::rv64;

use std::arch::rv64::asm;

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

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

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

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

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

/// Native entry page, above the platform firmware data.

constant CODE_ADDRESS: u64 = 0x81000000;

/// Maximum shared packages in the boot image.

constant PACKAGES: u32 = 4;

/// Package code arenas retained until image output completes.

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

/// Reusable function workspace.

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

/// Persistent decoded RIL storage.

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

/// Exact package bytes retained in the native catalog.

unsafe static INPUT: [[u8; 8388608]; PACKAGES] = undefined;

/// Combined startup and boundary assembly source.

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

/// Assembler workspace.

static ASSEMBLY: [u8; 4194304] = [0; 4194304];

/// Assembled startup words.

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

/// Assembly identifiers retained through package linking.

unsafe static STRINGS: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Per-package data layout workspaces.

unsafe static DATA: [[data::DataSym; 4096]; PACKAGES] = undefined;

/// Local function and data definitions.

unsafe static SYMBOLS: [[shared::Symbol; 4096]; PACKAGES] = undefined;

/// Public package symbols.

unsafe static EXPORTS: [[shared::Symbol; 4096]; PACKAGES] = undefined;

/// Exports from dependencies compiled before the current package.

unsafe static IMPORTS: [shared::Symbol; 16384] = undefined;

/// Private-state relocation records.

unsafe static RELOCS: [[shared::Relocation; 4096]; PACKAGES] = undefined;

/// Initialized package templates.

unsafe static TEMPLATES: [[u8; 1048576]; PACKAGES] = undefined;

/// Read-only catalog and retained package payloads.

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

/// Kernel state table and initialized private package graph.

static RW: [u8; 33554432] = [0; 33554432];

/// Contiguous native code segment, including entry trampoline and alignment padding.

static NATIVE: [u32; 4194304] = [0; 4194304];

/// Round an extent up to a power-of-two alignment.

fn aligned(value: u64, alignment: u32) -> u64 {

    assert alignment > 0 and (alignment & (alignment - 1)) == 0;

    assert value <= 0xffffffffffffffff - alignment as u64 + 1;

    return (value + alignment as u64 - 1) & ~(alignment as u64 - 1);

}

/// Print a bounded shared-backend failure class.

fn report(error: shared::Error) {

    match error {

        case shared::Error::Codegen(_) => io::printLn("native build: code generation failed"),

        case shared::Error::Capacity => io::printLn("native build: output capacity exhausted"),

        case shared::Error::Symbol => io::printLn("native build: unresolved or duplicate symbol"),

        case shared::Error::Range => io::printLn("native build: address out of range"),

        case shared::Error::Alignment => io::printLn("native build: invalid alignment"),

        case shared::Error::Instance => io::printLn("native build: missing package instance"),

    }

}

/// Compile one boot package into resident code and private-state metadata.

unsafe fn compile(input: &binary::Package, slot: u32, address: u64, imports: &[shared::Symbol], assembly: asm::Program)

    -> shared::Package throws (shared::Error)

{

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

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

    return try shared::compileAssembly(shared::AssemblyInput { package: input as *unsafe binary::Package, assembly }, slot, address, imports,

        shared::Storage {

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

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

        }, &mut arena, &mut scratch);

}

/// Emit a trampoline that preserves firmware arguments and supplies the native catalog.

unsafe fn trampoline(kernel: u64, ro: u64, rw: u64, count: u32) {

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

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

    emit::loadImm(&mut e, rv64::GP, rw as i64);

    emit::loadImm(&mut e, rv64::A3, ro as i64);

    emit::loadImm(&mut e, rv64::A4, count as i64);

    emit::loadImm(&mut e, rv64::T0, kernel as i64);

    emit::emit(&mut e, encode::jalr(rv64::ZERO, rv64::T0, 0));

    assert e.codeLen <= 1024;

    for word, i in emit::getCode(&e) { set NATIVE[i] = word; }

}

/// Link shared boot packages, retain their catalog, and instantiate the kernel graph.

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

    assert env.args.len >= 5 and env.args.len <= PACKAGES + 3;

    let count = env.args.len - 3;

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

    let libraryBytesLength = unix::readFile(env.args[1], &mut INPUT[0][..]) else panic "std RIL";

    let libraryBytes = &INPUT[0][..libraryBytesLength];

    let libraryInput = try! program::decode(libraryBytes, &mut decoder, binary::Limits { registers: 8192, blocks: 4096 });

    let kernelBytesLength = unix::readFile(env.args[2], &mut INPUT[1][..]) else panic "kernel RIL";

    let kernelBytes = &INPUT[1][..kernelBytesLength];

    let kernelInput = try! program::decode(kernelBytes, &mut decoder, binary::Limits { registers: 8192, blocks: 4096 });

    assert mem::eq(libraryInput.name, "std") and mem::eq(kernelInput.name, "kernel");

    assert libraryInput.dependencies.len == 0;

    for dependency in kernelInput.dependencies { assert mem::eq(dependency, "std"); }

    let sourceLength = unix::readFile(env.args[3], &mut SOURCE[..]) else panic "kernel assembly";

    let source = &SOURCE[..sourceLength];

    let mut assemblyArena = alloc::new(&mut ASSEMBLY[..]);

    let empty: *mut [u8] = &mut [];

    let assembly = try! asm::assemble(asm::scanner::SourceKind::String, source,

        &mut TEXT[..], &mut empty[..], &mut assemblyArena, &mut STRINGS, 0);

    let library = try compile(&libraryInput, 0, CODE_ADDRESS + 4096, &[],

        asm::Program { text: &[], data: &[], symbols: &[], externalFixups: &[] }) catch error { report(error); return 1; };

    let kernelAddress = aligned(library.codeAddress + library.code.len as u64 * 4, 4096);

    let kernel = try compile(&kernelInput, 1, kernelAddress, library.exports, assembly) catch error { report(error); return 1; };

    let mut catalogEntries: [catalog::Entry; PACKAGES] = undefined;

    set catalogEntries[0] = catalog::Entry { source: libraryBytes, package: library };

    set catalogEntries[1] = catalog::Entry { source: kernelBytes, package: kernel };

    let mut codeEnd = kernel.codeAddress + kernel.code.len as u64 * 4;

    for slot in 2..count {

        let bytesLength = unix::readFile(env.args[slot + 3], &mut INPUT[slot][..]) else panic "boot package RIL";

        let bytes = &INPUT[slot][..bytesLength];

        let input = try! program::decode(bytes, &mut decoder, binary::Limits { registers: 8192, blocks: 4096 });

        let mut imported: u32 = 0;

        for previous in 0..slot {

            for symbol in catalogEntries[previous].package.exports {

                assert imported < IMPORTS.len;

                set IMPORTS[imported] = symbol;

                set imported += 1;

            }

        }

        let package = try compile(&input, slot, aligned(codeEnd, 4096), &IMPORTS[..imported],

            asm::Program { text: &[], data: &[], symbols: &[], externalFixups: &[] }) catch error { report(error); return 1; };

        set catalogEntries[slot] = catalog::Entry { source: bytes, package };

        set codeEnd = package.codeAddress + package.code.len as u64 * 4;

    }

    let codeSize = (codeEnd - CODE_ADDRESS) as u32;

    assert codeEnd - CODE_ADDRESS <= @sizeOf([u32; 4194304]) as u64;

    let roAddress = aligned(codeEnd, 4096);

    let roSize = try catalog::pack(&catalogEntries[..count], roAddress, &mut RO[..]) catch error { report(error); return 1; };

    let rwAddress = aligned(roAddress + roSize as u64, 4096);

    let mut bases: [u64; shared::MAX_PACKAGES] = [0; shared::MAX_PACKAGES];

    let mut rwSize: u32 = @sizeOf([u64; shared::MAX_PACKAGES]);

    for entry in &catalogEntries[..2] {

        let at = aligned(rwAddress + rwSize as u64, entry.package.alignment);

        assert at - rwAddress <= RW.len as u64 and entry.package.memory <= RW.len - (at - rwAddress) as u32;

        set bases[entry.package.slot] = at;

        set rwSize = (at - rwAddress) as u32 + entry.package.memory;

    }

    try! mem::copy(&mut RW[..@sizeOf([u64; shared::MAX_PACKAGES])],

        @sliceOf(&bases[0] as *unsafe u8, @sizeOf([u64; shared::MAX_PACKAGES])));

    for entry in &catalogEntries[..2] {

        let at = (bases[entry.package.slot] - rwAddress) as u32;

        try shared::instantiate(&entry.package, &bases[..], &mut RW[at..at + entry.package.memory])

            catch error { report(error); return 1; };

    }

    for i in 0..codeSize / 4 { set NATIVE[i] = encode::nop(); }

    for entry in &catalogEntries[..count] {

        let at = ((entry.package.codeAddress - CODE_ADDRESS) / 4) as u32;

        for word, i in entry.package.code { set NATIVE[at + i] = word; }

    }

    trampoline(kernelAddress, roAddress, rwAddress, count);

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

        entry: CODE_ADDRESS,

        code: image::Segment { address: CODE_ADDRESS, initialized: codeSize, memory: codeSize },

        roData: image::Segment { address: roAddress, initialized: roSize, memory: roSize },

        rwData: image::Segment { address: rwAddress, initialized: rwSize, memory: rwSize },

    });

    let fd = unix::openOpts(env.args[4], 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(&NATIVE[0] as *u8, codeSize)) and unix::writeAll(fd, &RO[..roSize]) and unix::writeAll(fd, &RW[..rwSize]);

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

    assert written and closed;

    return 0;

}