//! Assembler emission and fixup helpers.

use std::arch::rv64::emit;

use std::arch::rv64::encode;

use std::arch::rv64;

use std::fmt;

use std::collections::dict;

use std::lang::gen;

/// Define a symbol at the current text or data offset.

export fn defineSymbol(a: *mut super::Assembler, name: *[u8]) {

    if a.symbols.len >= a.symbols.cap {

        panic "asm: symbol buffer full";

    }

    let idx = a.symbols.len;

    let offset: i32 = a.data.len as i32

        if a.section == super::Section::Data

        else a.text.len as i32 * rv64::INSTR_SIZE;

    set a.symbols = @sliceOf(a.symbols.ptr, idx + 1, a.symbols.cap);

    set a.symbols[idx] = super::Symbol {

        name,

        section: a.section,

        offset,

        isExported: dict::get(&a.exportMap, name) <> nil,

    };

    dict::insert(&mut a.symbolMap, name, idx as i32);

}

/// Append one encoded instruction word to the text section.

export fn emitText(a: *mut super::Assembler, word: u32) throws (super::Error) {

    if a.text.len >= a.text.cap {

        throw super::Error::TextOverflow;

    }

    let idx = a.text.len;

    set a.text = @sliceOf(a.text.ptr, idx + 1, a.text.cap);

    set a.text[idx] = word;

}

/// Append `words` no-op instructions to the text section.

export fn emitTextPadding(a: *mut super::Assembler, words: u32) throws (super::Error) {

    for _ in 0..words {

        try emitText(a, encode::nop());

    }

}

/// Append one byte to the data section.

export fn emitByte(a: *mut super::Assembler, byte: u8) throws (super::Error) {

    if a.data.len >= a.data.cap {

        throw super::Error::DataOverflow;

    }

    let idx = a.data.len;

    set a.data = @sliceOf(a.data.ptr, idx + 1, a.data.cap);

    set a.data[idx] = byte;

}

/// Emit a little-endian integer with `bytes` bytes.

fn emitDataInt(a: *mut super::Assembler, bits: u64, bytes: u32) throws (super::Error) {

    for i in 0..bytes {

        try emitByte(a, ((bits >> ((i as u64) * super::BITS_PER_BYTE)) & super::BYTE_MASK) as u8);

    }

}

/// Patch a little-endian integer with `bytes` bytes.

fn patchDataInt(a: *mut super::Assembler, offset: u32, bits: u64, bytes: u32) {

    for i in 0..bytes {

        set a.data[offset + i] = ((bits >> ((i as u64) * super::BITS_PER_BYTE)) & super::BYTE_MASK) as u8;

    }

}

/// Emit an integer data directive value.

export fn emitDataValue(a: *mut super::Assembler, value: i64, width: super::DataWidth) throws (super::Error) {

    match width {

        case super::DataWidth::Word => try emitDataInt(a, value as u64, rv64::WORD_SIZE as u32),

        case super::DataWidth::Dword => try emitDataInt(a, value as u64, rv64::DWORD_SIZE as u32),

    }

}

/// Record a data-section symbol fixup and reserve its bytes.

export fn recordDataFixup(a: *mut super::Assembler, target: *[u8], width: super::DataWidth) throws (super::Error) {

    let offset = a.data.len;

    match width {

        case super::DataWidth::Word => {

            recordFixup(a, target, super::FixupInfo::Word { offset });

            try emitDataInt(a, 0, rv64::WORD_SIZE as u32);

        }

        case super::DataWidth::Dword => {

            recordFixup(a, target, super::FixupInfo::Dword { offset });

            try emitDataInt(a, 0, rv64::DWORD_SIZE as u32);

        }

    }

}

/// Record a pending symbol fixup.

fn recordFixup(a: *mut super::Assembler, symbol: *[u8], info: super::FixupInfo) {

    if a.fixups.len >= a.fixups.cap {

        panic "asm: fixup buffer full";

    }

    let idx = a.fixups.len as u32;

    set a.fixups = @sliceOf(a.fixups.ptr, idx + 1, a.fixups.cap);

    set a.fixups[idx] = super::Fixup { symbol, info };

}

/// Record a text-section symbol fixup and reserve its instruction words.

export fn recordTextFixup(a: *mut super::Assembler, symbol: *[u8], info: super::FixupInfo, words: u32) throws (super::Error) {

    recordFixup(a, symbol, info);

    try emitTextPadding(a, words);

}

/// Find a previously defined symbol by name.

fn findSymbol(a: *super::Assembler, name: *[u8]) -> ?super::Symbol {

    let idx = dict::get(&a.symbolMap, name)

        else return nil;

    return a.symbols[idx as u32];

}

/// Return the final address for a data symbol.

fn dataSymbolAddr(a: *super::Assembler, symbol: super::Symbol) -> i32 throws (super::Error) {

    if symbol.section <> super::Section::Data {

        throw super::Error::Invalid { offset: 0, message: "data address target must be in data section" };

    }

    return symbol.offset + (a.dataBase as i32);

}

/// Resolve final symbol references and patch all delayed output.

export fn finishProgram(a: *mut super::Assembler) throws (super::Error) {

    for i in 0..a.fixups.len {

        let fixup = a.fixups[i];

        let symbol = findSymbol(a, fixup.symbol) else {

            throw super::Error::Invalid { offset: 0, message: "undefined symbol" };

        };

        match fixup.info {

            case super::FixupInfo::Branch { op, rs1, rs2, index } => {

                if symbol.section <> super::Section::Text {

                    throw super::Error::Invalid { offset: 0, message: "branch target must be in text section" };

                }

                let srcOffset = index as i32 * rv64::INSTR_SIZE;

                let rel = symbol.offset - srcOffset;

                if not encode::isBranchImm(rel) {

                    throw super::Error::Invalid { offset: 0, message: "branch target out of range" };

                }

                let word = encodeBranch(op, rs1, rs2, rel);

                set a.text[index] = word;

            }

            case super::FixupInfo::Jal { rd, index } => {

                if symbol.section <> super::Section::Text {

                    throw super::Error::Invalid { offset: 0, message: "jump target must be in text section" };

                }

                let srcOffset = index as i32 * rv64::INSTR_SIZE;

                let rel = symbol.offset - srcOffset;

                if not encode::isJumpImm(rel) {

                    throw super::Error::Invalid { offset: 0, message: "jump target out of range" };

                }

                set a.text[index] = encode::jal(rd, rel);

            }

            case super::FixupInfo::Addr { rd, index } => {

                let mut addr = symbol.offset - (index as i32 * rv64::INSTR_SIZE);

                if symbol.section == super::Section::Data {

                    set addr = symbol.offset + (a.dataBase as i32);

                }

                let split = emit::splitImm(addr);

                set a.text[index] = encode::lui(rd, split.hi)

                    if symbol.section == super::Section::Data

                    else encode::auipc(rd, split.hi);

                set a.text[index + 1] = encode::addi(rd, rd, split.lo);

            }

            case super::FixupInfo::Word { offset } => {

                let addr = try dataSymbolAddr(a, symbol);

                patchDataInt(a, offset, addr as u64, rv64::WORD_SIZE as u32);

            }

            case super::FixupInfo::Dword { offset } => {

                let addr = try dataSymbolAddr(a, symbol);

                patchDataInt(a, offset, addr as u64, rv64::DWORD_SIZE as u32);

            }

        }

    }

}

/// Encode a concrete branch operation.

export fn encodeBranch(op: super::BranchOp, rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {

    match op {

        case super::BranchOp::Beq  => return encode::beq(rs1, rs2, imm),

        case super::BranchOp::Bne  => return encode::bne(rs1, rs2, imm),

        case super::BranchOp::Blt  => return encode::blt(rs1, rs2, imm),

        case super::BranchOp::Bge  => return encode::bge(rs1, rs2, imm),

        case super::BranchOp::Bltu => return encode::bltu(rs1, rs2, imm),

        case super::BranchOp::Bgeu => return encode::bgeu(rs1, rs2, imm),

        case super::BranchOp::Ble  => return encode::ble(rs1, rs2, imm),

        case super::BranchOp::Bgt  => return encode::bgt(rs1, rs2, imm),

    }

}

/// Decode string literal escapes and emit the resulting data bytes.

export fn emitDecodedString(a: *mut super::Assembler, literal: *[u8]) throws (super::Error) {

    let raw = &literal[super::QUOTE_DELIM_LEN..literal.len - super::QUOTE_DELIM_LEN];

    let mut i: u32 = 0;

    while i < raw.len {

        if raw[i] == '\\' and i + 1 < raw.len {

            try emitByte(a, fmt::decodeAsciiEscape(raw[i + 1]));

            set i += 2;

        } else {

            try emitByte(a, raw[i]);

            set i += 1;

        }

    }

}