Function encode

crates/asm-to-binary/src/assembler/encode.rs:13–241

Encode all tokens into an `AssembledOutput` using the layout symbol table.

(tokens: &[AsmToken], layout: &Layout)

use crate::traits::Instruction as _;

// Record a pc-to-source entry for the instruction about to be emitted at `addr`.
fn record_line(out: &mut AssembledOutput, addr: u64, loc: Option<(u32, u32)>) {
    if let Some((file_id, line)) = loc {
        out.line_table.push(LineEntry {
            addr,
            file_id,
            line,
        });
    }
}

/// Encode all tokens into an `AssembledOutput` using the layout symbol table.
pub fn encode(tokens: &[AsmToken], layout: &Layout) -> Result<AssembledOutput, AssemblerError> {
    let mut out = AssembledOutput::new();
    let mut sections: std::collections::HashMap<SectionKind, SectionData> = layout
        .section_order
        .iter()
        .map(|k| (k.clone(), SectionData::new(k.clone())))
        .collect();

    // Non-BSS sections first, BSS last to keep ELF virtual addresses contiguous.
    let mut section_bases: std::collections::HashMap<SectionKind, u64> =
        std::collections::HashMap::new();
    let mut running_base: u64 = 0;
    for kind in layout
        .section_order
        .iter()
        .filter(|k| !matches!(k, SectionKind::Bss))
    {
        section_bases.insert(kind.clone(), running_base);
        running_base += layout.section_sizes.get(kind).copied().unwrap_or(0);
    }
    for kind in layout
        .section_order
        .iter()
        .filter(|k| matches!(k, SectionKind::Bss))
    {
        section_bases.insert(kind.clone(), running_base);
        running_base += layout.section_sizes.get(kind).copied().unwrap_or(0);
    }

    let mut current_kind = SectionKind::Text;
    let mut current_addr: u64 = section_bases.get(&current_kind).copied().unwrap_or(0);
    // Source location attributed to the instructions that follow, until reset.
    let mut current_loc: Option<(u32, u32)> = None;

    for token in tokens {
        match token {
            AsmToken::Loc { file, line } => {
                let file_id = out.intern_file(file);
                current_loc = Some((file_id, *line));
            }
            AsmToken::Section(kind) => {
                current_kind = kind.clone();
                let base = section_bases.get(kind).copied().unwrap_or(0);
                let sec = sections
                    .entry(current_kind.clone())
                    .or_insert_with(|| SectionData::new(current_kind.clone()));