//! Persistent native boot catalogs for the RV64 record ABI.

use std::mem;

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

/// Binary package identity and its resident native descriptor.

export record Entry: Copy {

    /// Complete immutable binary RIL bytes.

    source: *[u8],

    /// Shared code, exports, and private-state template.

    package: shared::Package,

}

/// Reserve aligned bytes in the native catalog output.

fn reserve(output: &mut [u8], used: &mut u32, size: u32, alignment: u32) -> u32 throws (shared::Error) {

    let padding = (alignment - (*used & (alignment - 1))) & (alignment - 1);

    if padding > output.len - *used {

        throw shared::Error::Capacity;

    }

    let offset = *used + padding;

    if size > output.len - offset {

        throw shared::Error::Capacity;

    }

    for i in *used..offset {

        set output[i] = 0;

    }

    set *used = offset + size;

    return offset;

}

/// View the native bytes of a caller-owned record or array.

unsafe fn raw(value: &opaque, size: u32) -> *unsafe [u8] { return @sliceOf((value as &u8) as *unsafe u8, size); }

/// Obtain a field's byte offset from the compiler's native record layout.

fn field(container: &opaque, value: &opaque) -> u32 {

    return (value as u64 - container as u64) as u32;

}

/// Write one little-endian integer into a reserved native field.

fn integer(output: &mut [u8], offset: u32, value: u64, width: u32) {

    for i in 0..width {

        set output[offset + i] = (value >> (i as u64 * 8)) as u8;

    }

}

/// Write the RV64 pointer, length, and capacity of a native immutable slice.

fn slice(output: &mut [u8], offset: u32, address: u64, length: u32) {

    integer(output, offset, address, 8);

    integer(output, offset + 8, length as u64, 4);

    integer(output, offset + 12, length as u64, 4);

}

/// Copy bytes into the catalog and return their target-relative offset.

fn bytes(input: *[u8], output: &mut [u8], used: &mut u32) -> u32 throws (shared::Error) {

    let offset = try reserve(output, used, input.len, 1);

    try! mem::copy(&mut output[offset..offset + input.len], input);

    return offset;

}

/// Copy a dependency list and each name into native catalog storage.

fn dependencies(input: &[*[u8]], base: u64, output: &mut [u8], used: &mut u32) -> u32 throws (shared::Error) {

    if input.len > output.len / @sizeOf(*[u8]) {

        throw shared::Error::Capacity;

    }

    let offset = try reserve(output, used, input.len * @sizeOf(*[u8]), @alignOf(*[u8]));

    for name, i in input {

        let at = try bytes(name, output, used);

        slice(output, offset + i * @sizeOf(*[u8]), base + at as u64, name.len);

    }

    return offset;

}

/// Copy public symbols and their names into native catalog storage.

unsafe fn symbols(input: *[shared::Symbol], base: u64, output: &mut [u8], used: &mut u32) -> u32 throws (shared::Error) {

    if input.len > output.len / @sizeOf(shared::Symbol) {

        throw shared::Error::Capacity;

    }

    let offset = try reserve(output, used, input.len * @sizeOf(shared::Symbol), @alignOf(shared::Symbol));

    for symbol, i in input {

        let at = offset + i * @sizeOf(shared::Symbol);

        try! mem::copy(&mut output[at..at + @sizeOf(shared::Symbol)], raw(&symbol, @sizeOf(shared::Symbol)));

        let name = try bytes(symbol.name, output, used);

        slice(output, at + field(&symbol, &symbol.name), base + name as u64, symbol.name.len);

    }

    return offset;

}

/// Copy private-state relocation records into native catalog storage.

unsafe fn relocations(input: *[shared::Relocation], output: &mut [u8], used: &mut u32) -> u32 throws (shared::Error) {

    if input.len > output.len / @sizeOf(shared::Relocation) {

        throw shared::Error::Capacity;

    }

    let size = input.len * @sizeOf(shared::Relocation);

    let offset = try reserve(output, used, size, @alignOf(shared::Relocation));

    try! mem::copy(&mut output[offset..offset + size], raw(input.ptr, size));

    return offset;

}

/// Pack native Entry records followed by all referenced metadata and source bytes.

/// Code is placed separately at each package's codeAddress. The target base must

/// have Entry alignment. Return the used extent. Failure leaves partial output.

export unsafe fn pack(entries: &[Entry], base: u64, output: &mut [u8]) -> u32 throws (shared::Error) {

    assert @sizeOf(*[u8]) == 16;

    if (base & (@alignOf(Entry) as u64 - 1)) <> 0 {

        throw shared::Error::Alignment;

    }

    if base > 0xffffffffffffffff - output.len as u64 {

        throw shared::Error::Range;

    }

    if entries.len > output.len / @sizeOf(Entry) {

        throw shared::Error::Capacity;

    }

    let mut used: u32 = 0;

    let start = try reserve(output, &mut used, entries.len * @sizeOf(Entry), @alignOf(Entry));

    for entry, i in entries {

        let at = i * @sizeOf(Entry);

        try! mem::copy(&mut output[at..at + @sizeOf(Entry)], raw(&entry, @sizeOf(Entry)));

        let source = try bytes(entry.source, output, &mut used);

        let name = try bytes(entry.package.name, output, &mut used);

        let required = try dependencies(&entry.package.dependencies[..], base, output, &mut used);

        let exports = try symbols(entry.package.exports, base, output, &mut used);

        let template = try bytes(entry.package.template, output, &mut used);

        let fixups = try relocations(entry.package.relocations, output, &mut used);

        slice(output, at + field(&entry, &entry.source), base + source as u64, entry.source.len);

        slice(output, at + field(&entry, &entry.package.name), base + name as u64, entry.package.name.len);

        slice(output, at + field(&entry, &entry.package.dependencies), base + required as u64, entry.package.dependencies.len);

        slice(output, at + field(&entry, &entry.package.code), entry.package.codeAddress, entry.package.code.len);

        slice(output, at + field(&entry, &entry.package.exports), base + exports as u64, entry.package.exports.len);

        slice(output, at + field(&entry, &entry.package.template), base + template as u64, entry.package.template.len);

        slice(output, at + field(&entry, &entry.package.relocations), base + fixups as u64, entry.package.relocations.len);

    }

    return used;

}