//! 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.

export constant 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`].

export constant DATA_SYM_TABLE_SIZE: u32 = MAX_DATA_SYMS * 2;

/// Data symbol entry mapping name to address.

export record DataSym: Copy {

    /// Symbol name.

    name: *[u8],

    /// Absolute address, including data base address.

    addr: u32,

}

/// Hash-indexed data symbol map.

export record DataSymMap: Copy {

    /// Underlying hash table.

    dict: dict::Dict,

    /// Fallback linear array for edge cases.

    syms: *[DataSym],

}

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

/// Data with sidecar image bytes is placed first, then zero-initialized data,

/// so that only meaningful bytes need to be written to the output file.

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

export fn layoutSection(

    items: *[il::Data],

    syms: *mut [DataSym],

    count: *mut u32,

    base: u32,

    readOnly: bool

) -> u32 {

    return layoutSectionAtOffset(items, syms, count, base, 0, readOnly);

}

/// Lay out data symbols for a single section starting at [`startOffset`].

export fn layoutSectionAtOffset(

    items: *[il::Data],

    syms: *mut [DataSym],

    count: *mut u32,

    base: u32,

    startOffset: u32,

    readOnly: bool

) -> u32 {

    let mut offset: u32 = startOffset;

    // Data requiring sidecar image bytes first.

    for i in 0..items.len {

        let data = &items[i];

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

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

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

            set *count += 1;

            set offset += data.size;

        }

    }

    // Zero-initialized data after.

    for i in 0..items.len {

        let data = &items[i];

        if data.readOnly == readOnly and data.isZeroInit {

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

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

            set *count += 1;

            set offset += data.size;

        }

    }

    return offset;

}

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

/// Iterates data requiring sidecar image bytes, serializing each data item.

/// Returns the total number of bytes written.

export fn emitSection(

    items: *[il::Data],

    dataSymMap: *DataSymMap,

    fnLabels: *labels::Labels,

    codeBase: u32,

    buf: *mut [u8],

    readOnly: bool

) -> u32 {

    return emitSectionAtOffset(items, dataSymMap, fnLabels, codeBase, buf, readOnly, 0);

}

/// Emit data bytes for a single section starting at `startOffset`.

export fn emitSectionAtOffset(

    items: *[il::Data],

    dataSymMap: *DataSymMap,

    fnLabels: *labels::Labels,

    codeBase: u32,

    buf: *mut [u8],

    readOnly: bool,

    startOffset: u32

) -> u32 {

    let mut offset: u32 = startOffset;

    for i in 0..items.len {

        let data = &items[i];

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

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

            assert offset + data.size <= buf.len, "emitSectionAtOffset: 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));

                            set offset += size;

                        },

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

                            let addr = lookupAddr(dataSymMap, name) else {

                                panic "emitSectionAtOffset: data symbol not found";

                            };

                            let addr64: u64 = addr as u64;

                            let addrPtr = &addr64 as *u8;

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

                            set offset += @sizeOf(u64);

                        },

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

                            set offset += @sizeOf(*u8);

                        },

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

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

                            set offset += s.len;

                        },

                        case il::DataItem::Undef => {

                            set buf[offset] = 0;

                            set 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`.

export 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.

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

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

        return v as u32;

    }

    return nil;

}