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

/// A data section cannot fit its address or symbol storage.

export union Error: Copy {

    /// A required data or function symbol is missing or duplicated.

    Symbol,

    /// The symbol array is full.

    Capacity,

    /// A section size or address would overflow.

    Overflow,

    /// A data 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: u64,

}

/// 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: u64,

    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: u64,

    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 {

            try place(&data, syms, count, base, &mut offset);

        }

    }

    // Zero-initialized data after.

    for i in 0..items.len {

        let data = items[i];

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

            try place(&data, syms, count, base, &mut offset);

        }

    }

    return offset;

}

/// Place a data symbol with checked offset and address arithmetic.

fn place(item: &il::Data, syms: &mut [DataSym], count: &mut u32, base: u64, offset: &mut u32)

    throws (Error)

{

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

        throw Error::Alignment;

    }

    if (base & (item.alignment as u64 - 1)) <> 0 {

        throw Error::Alignment;

    }

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

    let end = aligned + item.size as u64;

    if end > 0xffffffff or base > 0xffffffffffffffff - end {

        throw Error::Overflow;

    }

    if *count >= syms.len {

        throw Error::Capacity;

    }

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

    set *count += 1;

    set *offset = end as u32;

}

/// 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: u64,

    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 fn emitSectionAtOffset(

    items: &[il::Data],

    dataSymMap: &DataSymMap,

    fnLabels: &labels::Labels,

    codeBase: u64,

    buf: &mut [u8],

    readOnly: bool,

    startOffset: u32

) -> u32 throws (Error) {

    let mut offset: u32 = startOffset;

    if offset > buf.len {

        throw Error::Capacity;

    }

    for i in 0..items.len {

        let data = items[i];

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

            let start = offset;

            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 {

                throw Error::Capacity;

            }

            set offset = aligned as u32;

            if data.size > buf.len - offset {

                throw Error::Capacity;

            }

            let end = offset + data.size;

            for j in start..end {

                set buf[j] = 0;

            }

            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(bytes) => {

                        set width = bytes.len;

                    },

                    else => {

                    },

                }

                if width > 0 and v.count > (end - offset) / width {

                    throw Error::Overflow;

                }

                if width == 0 {

                    continue;

                }

                for _ in 0..v.count {

                    match v.item {

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

                            let size = il::typeSize(typ);

                            writeInteger(&mut buf[offset..offset + size], val as u64);

                            set offset += size;

                        },

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

                            let addr = lookupAddr(dataSymMap, name) else {

                                throw Error::Symbol;

                            };

                            writeInteger(&mut buf[offset..offset + 8], addr);

                            set offset += @sizeOf(u64);

                        },

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

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

                                throw Error::Symbol;

                            };

                            if fnOffset < 0 or codeBase > 0xffffffffffffffff - fnOffset as u64 {

                                throw Error::Overflow;

                            }

                            let addr = codeBase + fnOffset as u64;

                            writeInteger(&mut buf[offset..offset + 8], addr);

                            set offset += @sizeOf(u64);

                        },

                        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;

                        },

                    }

                }

            }

            set offset = end;

        }

    }

    return offset;

}

/// Write the low bytes of an integer in little-endian order.

fn writeInteger(buf: &mut [u8], value: u64) {

    assert buf.len <= 8;

    for i in 0..buf.len {

        set buf[i] = (value >> (i * 8) as u64) as u8;

    }

}

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

/// The entry count must be a power of two, at least twice the symbol count.

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

    if entries.len == 0 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, i 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]) -> ?u64 {

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

        return m.syms[v as u32].addr;

    }

    return nil;

}