Method link

crates/asm-to-binary/src/object_linker.rs:35–291

(modules: &[(&str, &AssembledOutput)])

        // Each module is walked in ELF load order: non-BSS first, BSS last.
        struct Contrib<'a> {
            module_idx: usize,
            sec: &'a SectionData,
        }

        // The canonical output order: Text -> RoData -> Data -> Custom(...) -> Bss.
        let all_kinds = collect_ordered_kinds(modules);
        let mut kind_contribs: Vec<(&SectionKind, Vec<Contrib<'_>>)> =
            all_kinds.iter().map(|k| (k, Vec::new())).collect();

        for (mi, (_name, module)) in modules.iter().enumerate() {
            let ordered = ordered_sections(module);
            for sec in ordered {
                let Some(kind) = &sec.kind else {
                    continue;
                };
                let contrib = Contrib {
                    module_idx: mi,
                    sec,
                };
                for (k, contribs) in &mut kind_contribs {
                    if *k == kind {
                        contribs.push(contrib);
                        break;
                    }
                }
            }
        }

        // --- Merge bytes and compute output bases ---
        // Contributions concatenate in module order; `mod_starts[mi]` is module `mi`'s offset.
        struct MergedSec {
            kind: SectionKind,
            bytes: Vec<u8>,
            mod_starts: HashMap<usize, u64>,
        }

        let mut merged_secs: Vec<MergedSec> = Vec::new();
        // Map: (kind_name, module_idx) -> absolute output base
        let mut contrib_base: HashMap<(String, usize), u64> = HashMap::new();
        let mut output_bases_by_kind: HashMap<String, u64> = HashMap::new();
        let mut running_abs: u64 = 0;

        for (kind, contribs) in &kind_contribs {
            if contribs.is_empty() {
                continue;
            }
            let mut merged_bytes: Vec<u8> = Vec::new();
            let mut mod_starts: HashMap<usize, u64> = HashMap::new();
            let kind_name = kind.name().to_owned();

            output_bases_by_kind.insert(kind_name.clone(), running_abs);

            for c in contribs {
                let start_in_merged = merged_bytes.len() as u64;
                mod_starts.insert(c.module_idx, start_in_merged);
                contrib_base.insert(
                    (kind_name.clone(), c.module_idx),
                    running_abs + start_in_merged,