//! Label tracking and branch resolution.

//!

//! Provides target-independent block/label tracking for branch resolution.

use std::collections::dict;

/// Maximum number of blocks per function.

export constant MAX_BLOCKS_PER_FN: u32 = 4096;

/// Maximum number of functions.

export constant MAX_FUNCS: u32 = 8192;

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

export constant FUNC_TABLE_SIZE: u32 = MAX_FUNCS * 2;

/// Label tracking for code emission.

export record Labels {

    /// Block offsets indexed by block index.

    /// Per-function, reset each function.

    blockOffsets: *mut [i32],

    /// Number of blocks recorded in current function.

    blockCount: u32,

    /// Function name to byte offset mapping.

    funcs: dict::Dict,

}

/// Create a new labels tracker with caller-provided storage.

export fn init(blockOffsets: *mut [i32], funcEntries: *mut [dict::Entry]) -> Labels {

    return Labels {

        blockOffsets,

        blockCount: 0,

        funcs: dict::init(funcEntries),

    };

}

/// Reset block count for a new function.

export fn resetBlocks(l: &mut Labels) {

    set l.blockCount = 0;

}

/// Record a block's code offset by its index. O(1).

export fn recordBlock(l: &mut Labels, blockIdx: u32, offset: i32) {

    assert blockIdx < l.blockOffsets.len, "recordBlock: block index out of range";

    set l.blockOffsets[blockIdx] = offset;

    set l.blockCount += 1;

}

/// Look up a block's byte offset by index. O(1).

export fn blockOffset(l: &Labels, blockIdx: u32) -> i32 {

    assert blockIdx < l.blockCount, "blockOffset: block not recorded";

    return l.blockOffsets[blockIdx];

}

/// Look up a function's byte offset by name.

export fn funcOffset(l: &Labels, name: *[u8]) -> i32 {

    if let offset = dict::get(&l.funcs, name) {

        return offset;

    }

    panic "funcOffset: unknown function";

}

/// Compute branch offset to a block given source instruction index.

export fn branchToBlock(l: &Labels, srcIndex: u32, blockIdx: u32, instrSize: i32) -> i32 {

    let targetOffset = blockOffset(l, blockIdx);

    let srcOffset = srcIndex as i32 * instrSize;

    return targetOffset - srcOffset;

}

/// Compute branch offset to a function given source instruction index.

export fn branchToFunc(l: &Labels, srcIndex: u32, name: *[u8], instrSize: i32) -> i32 {

    let targetOffset = funcOffset(l, name);

    let srcOffset = srcIndex as i32 * instrSize;

    return targetOffset - srcOffset;

}