//! 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 section layout or emission failure.

export union Error: Copy {

    /// A required symbol is missing or duplicated.

    Symbol,

    /// A symbol table or output buffer is full.

    Capacity,

    /// A size or address exceeds the supported range.

    Overflow,

    /// Alignment is zero or is not a power of two.

    Alignment,

}

/// 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 {

    /// 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 throws (Error) {

    return try 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 throws (Error) {

    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 {

            if data.alignment == 0 or (data.alignment & (data.alignment - 1)) <> 0 {

                throw Error::Alignment;

            }

            let aligned = (offset as u64 + data.alignment as u64 - 1) & ~(data.alignment as u64 - 1);

            if aligned + data.size as u64 > 0xffffffff or base as u64 + aligned + data.size as u64 > 0xffffffff {

                throw Error::Overflow;

            }

            if *count >= syms.len {

                throw Error::Capacity;

            }

            set offset = aligned as u32;

            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 {

            if data.alignment == 0 or (data.alignment & (data.alignment - 1)) <> 0 {

                throw Error::Alignment;

            }

            let aligned = (offset as u64 + data.alignment as u64 - 1) & ~(data.alignment as u64 - 1);

            if aligned + data.size as u64 > 0xffffffff or base as u64 + aligned + data.size as u64 > 0xffffffff {

                throw Error::Overflow;

            }

            if *count >= syms.len {

                throw Error::Capacity;

            }

            set offset = aligned as u32;

            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 unsafe fn emitSection(

    items: &[il::Data],

    dataSymMap: &DataSymMap,

    fnLabels: &labels::Labels,

    codeBase: u32,

    buf: &mut [u8],

    readOnly: bool

) -> u32 throws (Error) {

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

}

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

export unsafe fn emitSectionAtOffset(

    items: &[il::Data],

    dataSymMap: &DataSymMap,

    fnLabels: &labels::Labels,

    codeBase: u32,

    buf: &mut [u8],

    readOnly: bool,

    startOffset: u32

) -> u32 throws (Error) {

    if startOffset > buf.len {

        throw Error::Capacity;

    }

    let mut offset: u32 = startOffset;

    for i in 0..items.len {

        let data = items[i];

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

            if data.alignment == 0 or (data.alignment & (data.alignment - 1)) <> 0 {

                throw Error::Alignment;

            }

            let aligned = (offset as u64 + data.alignment as u64 - 1) & ~(data.alignment as u64 - 1);

            if aligned > buf.len as u64 or data.size as u64 > buf.len as u64 - aligned {

                throw Error::Capacity;

            }

            set offset = aligned as u32;

            let end = offset + data.size;

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

                let v = &data.values[j];

                let mut width: u32 = 1;

                match v.item {

                    case il::DataItem::Val { typ, .. } => set width = il::typeSize(typ),

                    case il::DataItem::Sym(_), il::DataItem::Fn(_) => set width = 8,

                    case il::DataItem::Str(text) => set width = text.len,

                    case il::DataItem::Undef => {}

                }

                if width as u64 * v.count as u64 > (end - offset) as u64 {

                    throw Error::Capacity;

                }

                for _ in 0..v.count {

                    match v.item {

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

                            let size = il::typeSize(typ);

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

                            set offset += size;

                        },

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

                            let addr = lookupAddr(dataSymMap, name) else {

                                throw Error::Symbol;

                            };

                            let addr64: u64 = addr as u64;

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

                            set offset += @sizeOf(u64);

                        },

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

                            let functionOffset = dict::get(&fnLabels.funcs, name) else {

                                throw Error::Symbol;

                            };

                            if functionOffset < 0 or codeBase as u64 + functionOffset as u64 > 0xffffffff {

                                throw Error::Overflow;

                            }

                            let addr64 = codeBase as u64 + functionOffset as u64;

                            try! mem::copy(&mut buf[offset..], @sliceOf(&addr64 as &u8, 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 table length must be a power of two and at least twice the symbol count.

/// The minimum table length is two.

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

    if entries.len < 2 or (entries.len & (entries.len - 1)) <> 0 or syms.len > entries.len / 2 {

        throw Error::Capacity;

    }

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

    for i in 0..syms.len {

        if syms[i].name.len == 0 or dict::get(&d, syms[i].name) <> nil {

            throw Error::Symbol;

        }

        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;

}