//! Data section layout and emission.

//!

//! Target-independent routines for laying out data symbols and

//! serializing initialized data into binary sections.

use std::mem;

use std::collections::dict;

use std::lang::il;

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

/// Maximum number of data symbols.

pub const MAX_DATA_SYMS: u32 = 8192;

/// Size of the data symbol hash table. Must be a power of two

/// and at least twice the size of [`MAX_DATA_SYMS`].

pub const DATA_SYM_TABLE_SIZE: u32 = MAX_DATA_SYMS * 2;

/// Data symbol entry mapping name to address.

pub record DataSym {

    /// Symbol name.

    name: *[u8],

    /// Absolute address, including data base address.

    addr: u32,

}

/// Hash-indexed data symbol map.

pub record DataSymMap {

    /// Underlying hash table.

    dict: dict::Dict,

    /// Fallback linear array for edge cases.

    syms: *[DataSym],

}

/// Lay out data symbols for a single section.

/// Initialized data is placed first, then uninitialized, so that only

/// initialized data needs to be written to the output file.

/// Returns the updated offset past all placed symbols.

pub fn layoutSection(

    program: *il::Program,

    syms: *mut [DataSym],

    count: *mut u32,

    base: u32,

    readOnly: bool

) -> u32 {

    let mut offset: u32 = 0;

    // Initialized data first.

    for i in 0..program.data.len {

        let data = &program.data[i];

        if data.readOnly == readOnly and not data.isUndefined {

            offset = mem::alignUp(offset, data.alignment);

            syms[*count] = DataSym { name: data.name, addr: base + offset };

            *count += 1;

            offset += data.size;

        }

    }

    // Uninitialized data after.

    for i in 0..program.data.len {

        let data = &program.data[i];

        if data.readOnly == readOnly and data.isUndefined {

            offset = mem::alignUp(offset, data.alignment);

            syms[*count] = DataSym { name: data.name, addr: base + offset };

            *count += 1;

            offset += data.size;

        }

    }

    return offset;

}

/// Emit data bytes for a single section (read-only or read-write) into `buf`.

/// Iterates initialized data in the IL program, serializing each data item.

/// Returns the total number of bytes written.

pub fn emitSection(

    program: *il::Program,

    dataSymMap: *DataSymMap,

    fnLabels: *labels::Labels,

    codeBase: u32,

    buf: *mut [u8],

    readOnly: bool

) -> u32 {

    let mut offset: u32 = 0;

    for i in 0..program.data.len {

        let data = &program.data[i];

        if data.readOnly == readOnly and not data.isUndefined {

            offset = mem::alignUp(offset, data.alignment);

            assert offset + data.size <= buf.len, "emitSection: buffer overflow";

            for j in 0..data.values.len {

                let v = &data.values[j];

                for _ in 0..v.count {

                    match v.item {

                        case il::DataItem::Val { typ, val } => {

                            let size = il::typeSize(typ);

                            let valPtr = &val as *u8;

                            try! mem::copy(&mut buf[offset..], @sliceOf(valPtr, size));

                            offset += size;

                        },

                        case il::DataItem::Sym(name) => {

                            let addr = lookupAddr(dataSymMap, name) else {

                                panic "emitSection: data symbol not found";

                            };

                            let addr64: u64 = addr as u64;

                            let addrPtr = &addr64 as *u8;

                            try! mem::copy(&mut buf[offset..], @sliceOf(addrPtr, 8));

                            offset += 8;

                        },

                        case il::DataItem::Fn(name) => {

                            let addr = codeBase + labels::funcOffset(fnLabels, name) as u32;

                            let addr64: u64 = addr as u64;

                            let addrPtr = &addr64 as *u8;

                            try! mem::copy(&mut buf[offset..], @sliceOf(addrPtr, 8));

                            offset += 8;

                        },

                        case il::DataItem::Str(s) => {

                            try! mem::copy(&mut buf[offset..], s);

                            offset += s.len;

                        },

                        case il::DataItem::Undef => {

                            buf[offset] = 0;

                            offset += 1;

                        },

                    }

                }

            }

        }

    }

    return offset;

}

/// Build a hash-indexed data symbol map from the laid-out symbols.

/// The `entries` slice must have length `DATA_SYM_TABLE_SIZE`.

pub fn buildMap(syms: *[DataSym], entries: *mut [dict::Entry]) -> DataSymMap {

    let mut d = dict::init(entries);

    for i in 0..syms.len {

        dict::insert(&mut d, syms[i].name, syms[i].addr as i32);

    }

    return DataSymMap { dict: d, syms };

}

/// Resolve a data symbol to its final absolute address using the hash map.

pub fn lookupAddr(m: *DataSymMap, name: *[u8]) -> ?u32 {

    if let v = dict::get(&m.dict, name) {

        return v as u32;

    }

    return nil;

}