kit

link_resolve.c (56423B)

---

 /* link_resolve.c — archive ingest, symbol resolution, --gc-sections liveness.
  *
  * Phase 1 of the link pipeline:
  *   link_ingest_archives  — pull archive members into l->inputs
  *   link_resolve_symbols  — register every ObjSym, build img->globals
  *   link_resolve_undefs   — satisfy remaining undefs (globals/DSOs/resolver)
  *   link_gc_compute       — mark live sections (or mark all live if disabled)
  *   link_gc_drop_dead_globals — clear `defined` on syms in dropped sections
  */
 
 #include <kit/core.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "core/buf.h"
 #include "core/bytes.h"
 #include "core/heap.h"
 #include "core/pool.h"
 #include "core/slice.h"
 #include "core/util.h"
 #include "core/vec.h"
 #include "link/link.h"
 #include "link/link_arch.h"
 #include "link/link_internal.h"
 
 /* ---- per-input symbol/section maps ---- */
 
 typedef struct AtomSortRec {
   ObjAtomId id;
   ObjSecId section_id;
   u32 offset;
 } AtomSortRec;
 
 static int atom_sort_rec_cmp(const void* av, const void* bv) {
   const AtomSortRec* a = (const AtomSortRec*)av;
   const AtomSortRec* b = (const AtomSortRec*)bv;
   if (a->section_id < b->section_id) return -1;
   if (a->section_id > b->section_id) return 1;
   if (a->offset < b->offset) return -1;
   if (a->offset > b->offset) return 1;
   if (a->id < b->id) return -1;
   if (a->id > b->id) return 1;
   return 0;
 }
 
 static ObjAtomId input_map_find_atom(const InputMap* m, ObjBuilder* ob,
                                      ObjSecId sid, u32 offset) {
   u32 first, count, i;
   if (!link_input_section_has_atoms(m, sid)) return OBJ_ATOM_NONE;
   link_input_section_atoms(m, sid, &first, &count);
   for (i = 0; i < count; ++i) {
     ObjAtomId aid = m->section_atom_ids[first + i];
     const ObjAtom* a = obj_atom_get(ob, aid);
     u64 begin, end;
     if (!a || a->removed) continue;
     begin = a->offset;
     end = begin + a->size;
     if (a->size != 0 && (u64)offset >= begin && (u64)offset < end) return aid;
   }
   for (i = 0; i < count; ++i) {
     ObjAtomId aid = m->section_atom_ids[first + i];
     const ObjAtom* a = obj_atom_get(ob, aid);
     if (!a || a->removed) continue;
     if (a->size == 0 && offset == a->offset) return aid;
   }
   return OBJ_ATOM_NONE;
 }
 
 static ObjAtomId input_map_find_symbol_atom(const InputMap* m, ObjBuilder* ob,
                                             ObjSymId sym) {
   const ObjSym* s;
   ObjAtomId aid;
   u32 i;
   if (!ob || sym == OBJ_SYM_NONE) return OBJ_ATOM_NONE;
   s = obj_symbol_get(ob, sym);
   if (!s || s->section_id == OBJ_SEC_NONE) return OBJ_ATOM_NONE;
   aid = input_map_find_atom(m, ob, s->section_id, (u32)s->value);
   if (aid != OBJ_ATOM_NONE) return aid;
   for (i = 0; i < m->nsection_atom_ids; ++i) {
     const ObjAtom* a = obj_atom_get(ob, m->section_atom_ids[i]);
     if (a && !a->removed && a->signature == sym) return m->section_atom_ids[i];
   }
   return OBJ_ATOM_NONE;
 }
 
 void link_input_map_alloc(LinkImage* img, InputMap* m, ObjBuilder* ob,
                           u32 nsym) {
   Heap* h = img->heap;
   u32 nsection = obj_section_count(ob);
   u32 natom = obj_atom_count(ob);
   u32 nreloc = obj_reloc_total(ob);
   AtomSortRec* atoms = NULL;
   u32 nactive = 0;
   u32 i;
 
   memset(m, 0, sizeof(*m));
   m->nsym = nsym;
   m->sym = (LinkSymId*)h->alloc(h, sizeof(*m->sym) * nsym, _Alignof(LinkSymId));
   if (!m->sym)
     compiler_panic(img->c, SRCLOC_NONE, "link: oom on input symbol map");
   memset(m->sym, 0, sizeof(*m->sym) * nsym);
   m->nsection = nsection;
   m->section = (LinkSectionId*)h->alloc(h, sizeof(*m->section) * nsection,
                                         _Alignof(LinkSectionId));
   if (!m->section)
     compiler_panic(img->c, SRCLOC_NONE, "link: oom on input section map");
   memset(m->section, 0, sizeof(*m->section) * nsection);
   m->natom = natom;
   m->atom = (LinkSectionId*)h->alloc(h, sizeof(*m->atom) * (natom ? natom : 1u),
                                      _Alignof(LinkSectionId));
   if (!m->atom)
     compiler_panic(img->c, SRCLOC_NONE, "link: oom on input atom map");
   memset(m->atom, 0, sizeof(*m->atom) * (natom ? natom : 1u));
   m->sym_atom = (ObjAtomId*)h->alloc(
       h, sizeof(*m->sym_atom) * (nsym ? nsym : 1u), _Alignof(ObjAtomId));
   if (!m->sym_atom)
     compiler_panic(img->c, SRCLOC_NONE, "link: oom on input symbol atom map");
   memset(m->sym_atom, 0, sizeof(*m->sym_atom) * (nsym ? nsym : 1u));
   m->nreloc = nreloc;
   m->reloc_atom = (ObjAtomId*)h->alloc(
       h, sizeof(*m->reloc_atom) * (nreloc ? nreloc : 1u), _Alignof(ObjAtomId));
   if (!m->reloc_atom)
     compiler_panic(img->c, SRCLOC_NONE, "link: oom on input reloc atom map");
   memset(m->reloc_atom, 0, sizeof(*m->reloc_atom) * (nreloc ? nreloc : 1u));
   m->section_has_atoms = (u8*)h->alloc(h, nsection ? nsection : 1u, 1);
   if (!m->section_has_atoms)
     compiler_panic(img->c, SRCLOC_NONE, "link: oom on input section atom map");
   memset(m->section_has_atoms, 0, nsection ? nsection : 1u);
   m->section_atom_first = (u32*)h->alloc(
       h, sizeof(*m->section_atom_first) * (nsection ? nsection : 1u),
       _Alignof(u32));
   m->section_atom_count = (u32*)h->alloc(
       h, sizeof(*m->section_atom_count) * (nsection ? nsection : 1u),
       _Alignof(u32));
   if (!m->section_atom_first || !m->section_atom_count)
     compiler_panic(img->c, SRCLOC_NONE,
                    "link: oom on input section atom ranges");
   memset(m->section_atom_first, 0,
          sizeof(*m->section_atom_first) * (nsection ? nsection : 1u));
   memset(m->section_atom_count, 0,
          sizeof(*m->section_atom_count) * (nsection ? nsection : 1u));
   m->comdat_discarded = (u8*)h->alloc(h, nsection ? nsection : 1u, 1);
   if (!m->comdat_discarded)
     compiler_panic(img->c, SRCLOC_NONE, "link: oom on input comdat map");
   memset(m->comdat_discarded, 0, nsection ? nsection : 1u);
 
   if (natom > 1u) {
     atoms = (AtomSortRec*)h->alloc(h, sizeof(*atoms) * natom,
                                    _Alignof(AtomSortRec));
     if (!atoms)
       compiler_panic(img->c, SRCLOC_NONE, "link: oom on atom sort map");
     for (i = 1; i < natom; ++i) {
       const ObjAtom* a = obj_atom_get(ob, (ObjAtomId)i);
       if (!a || a->removed || a->section_id == OBJ_SEC_NONE ||
           a->section_id >= nsection)
         continue;
       atoms[nactive].id = (ObjAtomId)i;
       atoms[nactive].section_id = a->section_id;
       atoms[nactive].offset = a->offset;
       ++nactive;
     }
     if (nactive > 1u) qsort(atoms, nactive, sizeof(*atoms), atom_sort_rec_cmp);
   }
 
   m->nsection_atom_ids = nactive;
   if (nactive) {
     ObjSecId cur = OBJ_SEC_NONE;
     m->section_atom_ids = (ObjAtomId*)h->alloc(
         h, sizeof(*m->section_atom_ids) * nactive, _Alignof(ObjAtomId));
     if (!m->section_atom_ids)
       compiler_panic(img->c, SRCLOC_NONE, "link: oom on section atom ids");
     for (i = 0; i < nactive; ++i) {
       ObjSecId sid = atoms[i].section_id;
       m->section_atom_ids[i] = atoms[i].id;
       if (sid != cur) {
         m->section_has_atoms[sid] = 1;
         m->section_atom_first[sid] = i;
         cur = sid;
       }
       m->section_atom_count[sid]++;
     }
   }
   if (atoms) h->free(h, atoms, sizeof(*atoms) * natom);
 
   for (i = 1; i < nsym; ++i)
     m->sym_atom[i] = input_map_find_symbol_atom(m, ob, (ObjSymId)i);
   for (i = 0; i < nreloc; ++i) {
     const Reloc* r = obj_reloc_at(ob, i);
     if (!r || r->section_id == OBJ_SEC_NONE) continue;
     m->reloc_atom[i] = input_map_find_atom(m, ob, r->section_id, r->offset);
   }
 }
 
 /* ---- pass 1: collect symbols ---- */
 
 /* A symbol with no home section and no absolute/common pseudo-value: the
  * importer's view of an undefined reference (or a DSO export). Distinct
  * from link_sym_is_def — SK_FILE symbols are logical undefs here but
  * defs there. Used only by scan_presence_before to split logical undefs
  * from logical defs; the spurious-undef prune routes through the shared
  * link_sym_is_spurious_undef. */
 static int obj_sym_is_logical_undef(const ObjSym* s) {
   return s && s->section_id == OBJ_SEC_NONE && s->kind != SK_ABS &&
          s->kind != SK_COMMON;
 }
 
 /* COFF/PE SELECTANY: a duplicate strong global is acceptable iff both
  * definitions live in COMDAT (SF_GROUP-tagged) sections.  When that
  * holds, the earlier-processed definition wins and the new section is
  * marked for discard so its bytes never reach layout. */
 static int obj_sym_defined_in_comdat(ObjBuilder* ob, const ObjSym* s) {
   const Section* sec;
   if (!s || s->section_id == OBJ_SEC_NONE) return 0;
   sec = obj_section_get(ob, s->section_id);
   return sec && (sec->flags & SF_GROUP);
 }
 
 void link_resolve_symbols(Linker* l, LinkImage* img) {
   u32 ii;
   for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
     LinkInput* in = LinkInputs_at(&l->inputs, ii);
     ObjBuilder* ob = in->obj;
     InputMap* m = &img->input_maps[ii];
     u32 nsym = obj_section_count(ob);
     (void)nsym;
     ObjSymIter* it;
     ObjSymEntry e;
 
     if (in->kind == LINK_INPUT_DSO_BYTES) continue;
 
     u32 nsyms_in_input = 0;
     it = obj_symiter_new(ob);
     while (obj_symiter_next(it, &e)) ++nsyms_in_input;
     obj_symiter_free(it);
 
     link_input_map_alloc(img, m, ob,
                          nsyms_in_input + 1u /* +1 for id-0 slot */);
 
     /* Pre-size the global symbol map for this input's symbols so the bulk
      * insert below never rehashes mid-stream. Only globals/weaks actually land
      * in img->globals, so this slightly over-reserves; it kills the resize
      * cascade (256 -> N) on symbol-heavy inputs (e.g. a large linked object). */
     symhash_reserve(&img->globals, img->globals.used + nsyms_in_input);
 
     it = obj_symiter_new(ob);
     while (obj_symiter_next(it, &e)) {
       const ObjSym* s = e.sym;
       LinkSymbol rec;
       LinkSymId existing;
       /* Tombstoned symbols are deleted, not just undefined: a file-format
        * emitter (which runs obj_sweep_dead, then `if (s->removed) continue`)
        * never writes them, so a serialized-then-re-read input carries none.
        * An in-memory ObjBuilder linked directly (the one-shot compile+link
        * path) still holds them, so honor the same `removed` contract here.
        * Without this, a deferred-but-never-materialized local rodata constant
        * (`obj_symbol_defer` leaves `.Lkit_ro.N` as a removed local SK_OBJ when
        * its function is optimized away at -O1) survives as an undefined local
        * and trips the "undefined reference to '.Lkit_ro.N'" panic below.
        * Leaving such a symbol unregistered (m->sym stays LINK_SYM_NONE); a
        * reloc that still targets it is dead and is dropped in the reloc passes
        * (matching obj_sweep_dead pass 3, which retires those relocs on write). */
       if (s->removed) continue;
       if (link_sym_is_spurious_undef(s)) continue;
       int is_def = link_sym_is_def(s);
 
       memset(&rec, 0, sizeof(rec));
       rec.name = s->name;
       rec.input_id = in->id;
       rec.obj_sym = e.id;
       rec.section_id = LINK_SEC_NONE;
       rec.atom_id = is_def ? link_input_sym_atom(m, e.id) : OBJ_ATOM_NONE;
       rec.value = s->value;
       rec.size = s->size;
       rec.common_align = (s->kind == SK_COMMON) ? (u32)s->common_align : 0u;
       rec.bind = (u8)s->bind;
       rec.kind = (u8)s->kind;
       rec.vis = (u8)s->vis;
       rec.defined = (u8)is_def;
       rec.vaddr = 0;
 
       if (is_def && (s->bind == SB_GLOBAL || s->bind == SB_WEAK) &&
           s->name != 0) {
         LinkSymId fresh = (LinkSymId)(LinkSyms_count(&img->syms) + 1u);
         if (symhash_insert(&img->globals, s->name, fresh, &existing)) {
           m->sym[e.id] = link_append_symbol(img, &rec);
         } else {
           /* A second definition of an existing global/weak name: hand the
            * binding-precedence decision to the shared policy module. The
            * COMDAT lookup (does prev's section carry SF_GROUP?) is the
            * caller-side bookkeeping symresolve deliberately leaves out. */
           LinkSymbol* prev = LinkSyms_at(&img->syms, existing - 1);
           ObjBuilder* prev_ob =
               (prev->input_id != LINK_INPUT_NONE)
                   ? LinkInputs_at(&l->inputs, prev->input_id - 1)->obj
                   : NULL;
           const ObjSym* prev_os =
               prev_ob ? obj_symbol_get(prev_ob, prev->obj_sym) : NULL;
           SymAttrs ex_a = {0};
           SymAttrs inc_a = {0};
           SymMergeResult mr;
           ex_a.bind = prev->bind;
           ex_a.kind = prev->kind;
           ex_a.size = prev->size;
           ex_a.common_align = prev->common_align;
           ex_a.in_comdat = (prev_ob && prev_os)
                                ? (u8)obj_sym_defined_in_comdat(prev_ob, prev_os)
                                : 0u;
           inc_a.bind = rec.bind;
           inc_a.kind = rec.kind;
           inc_a.size = rec.size;
           inc_a.common_align = rec.common_align;
           inc_a.in_comdat = (u8)obj_sym_defined_in_comdat(ob, s);
           mr = symresolve_merge(ex_a, inc_a);
           switch (mr.kind) {
             case SYM_MERGE_REPLACE:
               rec.id = existing;
               *prev = rec;
               m->sym[e.id] = existing;
               break;
             case SYM_MERGE_COMMON:
               rec.id = existing;
               rec.common_align = mr.merged_align;
               *prev = rec;
               m->sym[e.id] = existing;
               break;
             case SYM_MERGE_COMDAT_DISCARD:
               m->sym[e.id] = existing;
               if (s->section_id < m->nsection)
                 m->comdat_discarded[s->section_id] = 1;
               break;
             case SYM_MERGE_ODR_ERROR: {
               Slice nm_s = pool_slice(l->c->global, s->name);
               compiler_panic(l->c, SRCLOC_NONE,
                              "link: duplicate definition of "
                              "global symbol '%.*s'",
                              (int)nm_s.len, nm_s.s);
               break;
             }
             case SYM_MERGE_KEEP_EXISTING:
             default:
               m->sym[e.id] = existing;
               break;
           }
         }
       } else {
         m->sym[e.id] = link_append_symbol(img, &rec);
       }
     }
     obj_symiter_free(it);
   }
 }
 
 static int obj_sym_is_dso_export(const ObjSym* s) {
   return s && s->name != 0 && s->kind != SK_UNDEF && s->bind != SB_LOCAL;
 }
 
 static void dso_exports_build(Linker* l, SymHash* exports) {
   u32 ii;
   u32 nexports = 0;
   symhash_init(exports, l->heap);
   for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
     LinkInput* in = LinkInputs_at(&l->inputs, ii);
     ObjSymIter* it;
     ObjSymEntry e;
     if (in->kind != LINK_INPUT_DSO_BYTES) continue;
     it = obj_symiter_new(in->obj);
     while (obj_symiter_next(it, &e)) {
       if (obj_sym_is_dso_export(e.sym)) ++nexports;
     }
     obj_symiter_free(it);
   }
   symhash_reserve(exports, nexports);
   for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
     LinkInput* in = LinkInputs_at(&l->inputs, ii);
     ObjSymIter* it;
     ObjSymEntry e;
     if (in->kind != LINK_INPUT_DSO_BYTES) continue;
     it = obj_symiter_new(in->obj);
     while (obj_symiter_next(it, &e)) {
       LinkSymId existing;
       if (!obj_sym_is_dso_export(e.sym)) continue;
       /* Preserve command-line order: the old lookup returned the first DSO
        * exporting a name, so duplicate exports keep the earliest provider. */
       (void)symhash_insert(exports, e.sym->name, in->id, &existing);
     }
     obj_symiter_free(it);
   }
 }
 
 static int elf_split_versioned_undef(Compiler* c, Sym full, Sym* base_out,
                                      Sym* version_out) {
   Slice nm;
   u32 i;
   if (!c || full == 0 || !base_out || !version_out) return 0;
   nm = pool_slice(c->global, full);
   if (!nm.s || nm.len < 3u) return 0;
   for (i = 1u; i + 1u < nm.len; ++i) {
     u32 j;
     if (nm.s[i] != '@') continue;
     if (nm.s[i + 1u] == '@') return 0;
     for (j = i + 1u; j < nm.len; ++j)
       if (nm.s[j] == '@') return 0;
     *base_out =
         pool_intern_slice(c->global, (Slice){.s = nm.s, .len = i});
     *version_out = pool_intern_slice(
         c->global, (Slice){.s = nm.s + i + 1u, .len = nm.len - i - 1u});
     return *base_out != 0 && *version_out != 0;
   }
   return 0;
 }
 
 static const ObjImageSym* dso_dynsym_version(LinkInput* in, Sym name,
                                              Sym version) {
   const ObjImage* im;
   u32 i, n;
   if (!in || !in->obj || name == 0 || version == 0) return NULL;
   im = obj_image(in->obj);
   n = obj_image_ndynsyms(im);
   for (i = 0; i < n; ++i) {
     const ObjImageSym* s = obj_image_dynsym(im, i);
     if (!s || s->name != name) continue;
     if (s->section == OBJ_SEC_NONE && s->kind == SK_UNDEF) continue;
     if (s->bind == SB_LOCAL) continue;
     if (s->version == version) return s;
   }
   return NULL;
 }
 
 static LinkInputId find_dso_export_version(Linker* l, Sym name, Sym version,
                                            const ObjImageSym** sym_out) {
   u32 ii;
   if (sym_out) *sym_out = NULL;
   if (name == 0 || version == 0) return LINK_INPUT_NONE;
   for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
     LinkInput* in = LinkInputs_at(&l->inputs, ii);
     const ObjImageSym* s;
     if (in->kind != LINK_INPUT_DSO_BYTES) continue;
     s = dso_dynsym_version(in, name, version);
     if (!s) continue;
     if (sym_out) *sym_out = s;
     return in->id;
   }
   return LINK_INPUT_NONE;
 }
 
 static int resolve_elf_versioned_dso_undef(Linker* l, LinkSymbol* s) {
   Sym base = 0;
   Sym version = 0;
   const ObjImageSym* ds = NULL;
   LinkInputId dso;
   if (!l || !s || s->name == 0) return 0;
   if (l->c->target.obj != KIT_OBJ_ELF) return 0;
   if (!elf_split_versioned_undef(l->c, s->name, &base, &version)) return 0;
   dso = find_dso_export_version(l, base, version, &ds);
   if (dso == LINK_INPUT_NONE) return 0;
   s->name = base;
   s->kind = ds ? (u8)ds->kind : s->kind;
   s->imported = 1;
   s->dso_input_id = dso;
   s->elf_version = version;
   return 1;
 }
 
 /* Resolve undefined symbol `s` to the symbol named `alias` (a defined image
  * global or a DSO export), copying the target's binding into `s`. Returns 1 on
  * success. Shared by the recorded-alias path and the underscore heuristic. */
 static int resolve_to_alias(LinkImage* img, const SymHash* dso_exports,
                             LinkSymbol* s, Sym alias) {
   if (alias == 0) return 0;
   LinkSymId hit = symhash_get(&img->globals, alias);
   if (hit != LINK_SYM_NONE) {
     LinkSymbol* def = LinkSyms_at(&img->syms, hit - 1);
     if (def->defined || def->imported) {
       s->name = def->name;
       s->section_id = def->section_id;
       s->value = def->value;
       s->vaddr = def->vaddr;
       s->kind = def->kind;
       s->defined = def->defined;
       s->imported = def->imported;
       s->dso_input_id = def->dso_input_id;
       s->elf_version = def->elf_version;
       if (!s->defined && !s->imported) {
         s->kind = SK_ABS;
         s->vaddr = 0;
         s->defined = 1;
       }
       return 1;
     }
   }
   LinkInputId dso = symhash_get(dso_exports, alias);
   if (dso != LINK_INPUT_NONE) {
     s->name = alias;
     s->imported = 1;
     s->dso_input_id = dso;
     s->elf_version = 0;
     return 1;
   }
   return 0;
 }
 
 static int resolve_elf_loader_owned_undef(Linker* l, LinkSymbol* s) {
   Slice nm;
   if (!l || !s || !s->name) return 0;
   if (!l->emit_pie || l->c->target.obj != KIT_OBJ_ELF) return 0;
   nm = pool_slice(l->c->global, s->name);
   if (slice_eq_cstr(nm, "__tls_get_addr")) {
     if (l->c->target.arch != KIT_ARCH_X86_64 &&
         l->c->target.arch != KIT_ARCH_RV64 &&
         l->c->target.arch != KIT_ARCH_RV32)
       return 0;
     /* Some glibc dynamic TLS helpers are provided by the ELF interpreter
      * itself (ld-linux), not by a regular DT_NEEDED DSO. GNU ld permits this
      * unresolved-looking reference in dynamic executables; model it as a
      * function import with no provider DSO so the PLT/dynsym machinery can
      * emit any needed JUMP_SLOT without adding the interpreter as DT_NEEDED.
      * RISC-V TLS-GD references that relax fully to local-exec will skip their
      * call relocations later, leaving this dynsym entry harmlessly unused. */
     s->kind = SK_FUNC;
   } else if (slice_eq_cstr(nm, "__stack_chk_guard")) {
     /* glibc's AArch64 and RISC-V ABIs expose the process canary from
      * ld-linux, while libc only carries an undefined versioned reference to
      * it. Treat the guard as an interpreter-owned object import. This keeps
      * the loader out of DT_NEEDED (it is already PT_INTERP) and lets the
      * ordinary GOT/dynsym machinery bind the address at startup. x86-64 reads
      * its guard directly from fs:0x28 and never reaches this path. */
     if (l->c->target.os != KIT_OS_LINUX ||
         (l->c->target.arch != KIT_ARCH_ARM_64 &&
          l->c->target.arch != KIT_ARCH_RV64 &&
          l->c->target.arch != KIT_ARCH_RV32))
       return 0;
     s->kind = SK_OBJ;
   } else {
     return 0;
   }
   s->imported = 1;
   s->dso_input_id = LINK_INPUT_NONE;
   s->elf_version = 0;
   return 1;
 }
 
 void link_resolve_undefs(Linker* l, LinkImage* img) {
   u32 i;
 
   /* Cross-input COFF WEAK_EXTERNAL alias map: alias-declarator name -> target
    * name (SymHash's value slot holds an interned Sym, never a real LinkSymId
    * here; 0 = absent). Populated from every input's recorded aliases so a
    * reference to the aliased name resolves to the target regardless of which
    * input the reference vs. the declarator came from. Empty for non-COFF. */
   SymHash alias_map;
   symhash_init(&alias_map, l->heap);
   if (l->c->target.obj == KIT_OBJ_COFF) {
     for (u32 ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
       LinkInput* in = LinkInputs_at(&l->inputs, ii);
       if (!in->obj || in->kind == LINK_INPUT_DSO_BYTES) continue;
       u32 na = obj_weak_alias_count(in->obj);
       for (u32 ai = 0; ai < na; ++ai) {
         ObjSymId asym = OBJ_SYM_NONE;
         Sym target = 0;
         if (!obj_weak_alias_at(in->obj, ai, &asym, &target) || target == 0)
           continue;
         const ObjSym* os = obj_symbol_get(in->obj, asym);
         if (os && os->name != 0) symhash_set(&alias_map, os->name, target);
       }
     }
   }
   SymHash dso_exports;
   dso_exports_build(l, &dso_exports);
 
   for (i = 0; i < LinkSyms_count(&img->syms); ++i) {
     LinkSymbol* s = LinkSyms_at(&img->syms, i);
     if (s->defined) continue;
     if (s->name != 0) {
       LinkSymId hit = symhash_get(&img->globals, s->name);
       if (hit != LINK_SYM_NONE && hit != s->id) {
         LinkSymbol* def = LinkSyms_at(&img->syms, hit - 1);
         if (def->defined) {
           s->section_id = def->section_id;
           s->value = def->value;
           s->vaddr = def->vaddr;
           s->kind = def->kind;
           s->bind = def->bind;
           s->vis = def->vis;
           s->defined = 1;
           continue;
         }
       }
     }
     if (s->name != 0) {
       if (resolve_elf_versioned_dso_undef(l, s)) {
         continue;
       }
       LinkInputId dso = symhash_get(&dso_exports, s->name);
       if (dso != LINK_INPUT_NONE) {
         s->imported = 1;
         s->dso_input_id = dso;
         s->elf_version = 0;
         continue;
       }
       if (resolve_elf_loader_owned_undef(l, s)) continue;
     }
     if (l->resolver && s->name != 0) {
       Slice nm_s = pool_slice(l->c->global, s->name);
       void* p = l->resolver(l->resolver_user, nm_s);
       if (p) {
         s->kind = SK_ABS;
         s->vaddr = (u64)(uintptr_t)p;
         s->defined = 1;
         continue;
       }
     }
     /* COFF WEAK_EXTERNAL alias: resolve to the recorded fall-back symbol (the
      * aux TagIndex target captured by read_coff, collected into `alias_map`
      * keyed by the alias-declarator's name). This is the precise relationship —
      * e.g. mingw x86_64's `_setjmp` aliasing `__intrinsic_setjmp`, which the
      * single-underscore heuristic below cannot derive. It applies to ANY undef
      * of the aliased name, not just the declarator symbol itself: the strong
      * reference (sj.o's `_setjmp`) and the weak declarator are distinct undefs,
      * and the reference is what needs redirecting. The declarator member is
      * pulled by member_satisfies (weak undef under PE/COMDAT semantics), which
      * brings in the target's own undef and pulls its short-import DSO, so the
      * target is resolvable by now. Follow a short chain in case the target is
      * itself an alias. */
     if (s->name != 0) {
       int resolved = 0;
       Sym cur = s->name;
       for (u32 hop = 0; hop < 8u; ++hop) {
         Sym target = symhash_get(&alias_map, cur);
         if (target == 0) break;
         if (resolve_to_alias(img, &dso_exports, s, target)) {
           resolved = 1;
           break;
         }
         cur = target;
       }
       if (resolved) continue;
     }
     /* COFF WEAK_EXTERNAL alias fallback for references that carry no recorded
      * aux TagIndex (GLOBAL undefs like crt2.o's call to `__set_app_type`, or
      * inputs read before alias capture): recover the relationship via the mingw
      * single-underscore naming convention.  e.g. `__set_app_type` aliases to
      * `_set_app_type`; `__imp___set_app_type` aliases to `__imp__set_app_type`.
      * Try the de-underscored variant first, then the re-underscored one. */
     if (obj_format_weak_extern_underscore_alias(l->c) && s->name != 0) {
       Slice nm_s = pool_slice(l->c->global, s->name);
       const char* nm = nm_s.s;
       size_t nlen = nm_s.len;
       Sym candidates[2] = {0, 0};
       u32 ncand = 0;
       if (nm && nlen >= 2 && nm[0] == '_') {
         candidates[ncand++] = pool_intern_slice(
             l->c->global, (Slice){.s = nm + 1, .len = (u32)(nlen - 1u)});
       }
       if (nm && nlen > 0) {
         char* buf = (char*)arena_array(l->c->scratch, char, nlen + 1u);
         buf[0] = '_';
         memcpy(buf + 1, nm, nlen);
         candidates[ncand++] = pool_intern_slice(
             l->c->global, (Slice){.s = buf, .len = (u32)(nlen + 1u)});
       }
       int resolved = 0;
       for (u32 ci = 0; !resolved && ci < ncand; ++ci) {
         if (resolve_to_alias(img, &dso_exports, s, candidates[ci]))
           resolved = 1;
       }
       if (resolved) continue;
     }
     if (s->bind == SB_WEAK) {
       s->kind = SK_ABS;
       s->vaddr = 0;
       s->defined = 1;
       continue;
     }
     /* JIT lane: format pseudo-symbols the JIT image satisfies internally.
      * Mach-O inputs (including clang-produced .o files) carry a non-weak undef
      * `__tlv_bootstrap` on every TLV var; kit_jit_from_image rewrites every
      * descriptor's slot[0] to our thunk, so the resolved value never gets read.
      * Windows COFF inputs carry `_tls_index` (normally supplied by the OS
      * loader via the TLS directory); the JIT relaxes every TLS access to
      * in-image addressing, so it is never read. Treat such a symbol as
      * weak-undef (vaddr = 0, SK_ABS) in JIT mode only; AOT lanes keep the
      * strict "undefined external" semantics. The obj layer is the single
      * arbiter (shared with link_jit.c), so src/link names no pseudo-symbol. */
     if (l->jit_mode && obj_format_jit_undef_internal(l->c, s->name)) {
       s->kind = SK_ABS;
       s->vaddr = 0;
       s->defined = 1;
       continue;
     }
     if (l->allow_undefined) {
       s->kind = SK_ABS;
       s->vaddr = 0;
       s->defined = 1;
       continue;
     }
     if (l->emit_shared && s->name != 0 && s->bind != SB_LOCAL) {
       s->imported = 1;
       s->dso_input_id = LINK_INPUT_NONE;
       s->elf_version = 0;
       continue;
     }
     /* --defsym NAME=EXPR: a defsym whose NAME matches this undef satisfies the
      * reference. Defsyms are applied AFTER undef resolution (link_apply_defsyms
      * runs in link_resolve, once the alias target's vaddr is settled), so we
      * cannot define it here; instead, skip the panic and leave the record
      * undefined-for-now. link_apply_defsyms then UPDATES this same record in
      * place (its `existing != LINK_SYM_NONE` branch) — leaving s->defined=0
      * avoids the duplicate-symbol artifact a synthetic definition would add. */
     if (s->name != 0 && l->ndefsyms) {
       int is_defsym = 0;
       u32 k;
       for (k = 0; k < l->ndefsyms; ++k) {
         const KitLinkDefsym* d = &l->defsyms[k];
         Sym dn;
         if (!d->name.s || d->name.len == 0) continue;
         dn = pool_intern_slice(l->c->global,
                                (Slice){.s = d->name.s, .len = d->name.len});
         if (dn == s->name) {
           is_defsym = 1;
           break;
         }
       }
       if (is_defsym) continue;
     }
     {
       Slice nm_s = s->name ? pool_slice(l->c->global, s->name) : SLICE_NULL;
       const char* nm = nm_s.s ? nm_s.s : "";
       size_t namelen = nm_s.len;
       obj_format_demangle_c(l->c, &nm, &namelen);
       compiler_panic(l->c, SRCLOC_NONE, "link: undefined reference to '%.*s'",
                      (int)namelen, nm);
     }
   }
   symhash_fini(&dso_exports);
   symhash_fini(&alias_map);
 }
 
 /* ---- pass 1b: --gc-sections liveness ---- */
 
 #define GC_ATOM_BIT 0x80000000u
 #define GC_PACK(ii, j, is_atom) \
   (((u64)(u32)(ii) << 32) | ((is_atom) ? GC_ATOM_BIT : 0u) | (u32)(j))
 #define GC_II(p) ((u32)((p) >> 32))
 #define GC_IS_ATOM(p) (((u32)(p) & GC_ATOM_BIT) != 0)
 #define GC_J(p) ((u32)((p) & ~GC_ATOM_BIT))
 
 static void gc_queue_push(GcQueue* q, Heap* h, u32 ii, u32 j, int is_atom) {
   if (VEC_GROW(h, q->items, q->cap, q->n + 1u)) return;
   q->items[q->n++] = GC_PACK(ii, j, is_atom);
 }
 
 void link_gc_live_alloc(GcLive* g, Linker* l, Heap* h) {
   u32 ii;
   g->ninputs = LinkInputs_count(&l->inputs);
   g->marks =
       LinkInputs_count(&l->inputs)
           ? (u8**)h->alloc(h, sizeof(*g->marks) * LinkInputs_count(&l->inputs),
                            _Alignof(u8*))
           : NULL;
   g->atom_marks =
       LinkInputs_count(&l->inputs)
           ? (u8**)h->alloc(
                 h, sizeof(*g->atom_marks) * LinkInputs_count(&l->inputs),
                 _Alignof(u8*))
           : NULL;
   g->nsec =
       LinkInputs_count(&l->inputs)
           ? (u32*)h->alloc(h, sizeof(*g->nsec) * LinkInputs_count(&l->inputs),
                            _Alignof(u32))
           : NULL;
   g->natom =
       LinkInputs_count(&l->inputs)
           ? (u32*)h->alloc(h, sizeof(*g->natom) * LinkInputs_count(&l->inputs),
                            _Alignof(u32))
           : NULL;
   if (LinkInputs_count(&l->inputs) &&
       (!g->marks || !g->atom_marks || !g->nsec || !g->natom))
     compiler_panic(l->c, SRCLOC_NONE, "link: oom on gc live map");
   for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
     u32 nsec = obj_section_count(LinkInputs_at(&l->inputs, ii)->obj);
     u32 natom = obj_atom_count(LinkInputs_at(&l->inputs, ii)->obj);
     g->nsec[ii] = nsec;
     g->natom[ii] = natom;
     g->marks[ii] = (u8*)h->alloc(h, nsec ? nsec : 1u, 1);
     if (!g->marks[ii])
       compiler_panic(l->c, SRCLOC_NONE, "link: oom on gc marks");
     memset(g->marks[ii], 0, nsec);
     g->atom_marks[ii] = (u8*)h->alloc(h, natom ? natom : 1u, 1);
     if (!g->atom_marks[ii])
       compiler_panic(l->c, SRCLOC_NONE, "link: oom on gc atom marks");
     memset(g->atom_marks[ii], 0, natom);
   }
 }
 
 void link_gc_live_free(GcLive* g, Heap* h) {
   u32 ii;
   if (g->marks) {
     for (ii = 0; ii < g->ninputs; ++ii)
       if (g->marks[ii])
         h->free(h, g->marks[ii], g->nsec[ii] ? g->nsec[ii] : 1u);
     h->free(h, g->marks, sizeof(*g->marks) * g->ninputs);
   }
   if (g->atom_marks) {
     for (ii = 0; ii < g->ninputs; ++ii)
       if (g->atom_marks[ii])
         h->free(h, g->atom_marks[ii], g->natom[ii] ? g->natom[ii] : 1u);
     h->free(h, g->atom_marks, sizeof(*g->atom_marks) * g->ninputs);
   }
   if (g->nsec) h->free(h, g->nsec, sizeof(*g->nsec) * g->ninputs);
   if (g->natom) h->free(h, g->natom, sizeof(*g->natom) * g->ninputs);
 }
 
 int link_gc_live_get(const GcLive* g, u32 ii, ObjSecId j) {
   if (ii >= g->ninputs || j == OBJ_SEC_NONE || j >= g->nsec[ii]) return 0;
   return g->marks[ii][j];
 }
 
 int link_gc_atom_live_get(const GcLive* g, u32 ii, ObjAtomId j) {
   if (ii >= g->ninputs || j == OBJ_ATOM_NONE || j >= g->natom[ii]) return 0;
   return g->atom_marks[ii][j];
 }
 
 static void gc_mark(GcLive* g, GcQueue* q, Heap* h, u32 ii, ObjSecId j) {
   if (ii >= g->ninputs || j == OBJ_SEC_NONE || j >= g->nsec[ii]) return;
   if (g->marks[ii][j]) return;
   g->marks[ii][j] = 1;
   if (q) gc_queue_push(q, h, ii, j, 0);
 }
 
 static void gc_mark_atom(GcLive* g, GcQueue* q, Heap* h, u32 ii, ObjAtomId j) {
   if (ii >= g->ninputs || j == OBJ_ATOM_NONE || j >= g->natom[ii]) return;
   if (g->atom_marks[ii][j]) return;
   g->atom_marks[ii][j] = 1;
   if (q) gc_queue_push(q, h, ii, j, 1);
 }
 
 static void gc_mark_section_or_atoms(GcLive* g, GcQueue* q, Heap* h,
                                      ObjBuilder* ob, const InputMap* m, u32 ii,
                                      ObjSecId sid) {
   u32 first, count, i;
   int marked = 0;
   if (!link_input_section_has_atoms(m, sid)) {
     gc_mark(g, q, h, ii, sid);
     return;
   }
   link_input_section_atoms(m, sid, &first, &count);
   for (i = 0; i < count; ++i) {
     ObjAtomId aid = m->section_atom_ids[first + i];
     const ObjAtom* a = obj_atom_get(ob, aid);
     if (!a || a->removed) continue;
     gc_mark_atom(g, q, h, ii, aid);
     marked = 1;
   }
   if (!marked) gc_mark(g, q, h, ii, sid);
 }
 
 /* From a LinkSymId, find the (input_idx, obj_sec_id) of its defining section.
  * Returns 1 on hit. */
 static int gc_def_site(LinkImage* img, Linker* l, LinkSymId id, u32* out_ii,
                        ObjSecId* out_sid, ObjAtomId* out_aid) {
   const LinkSymbol* s;
   ObjBuilder* ob;
   const ObjSym* osym;
   if (id == LINK_SYM_NONE || id > LinkSyms_count(&img->syms)) return 0;
   s = LinkSyms_at(&img->syms, id - 1);
   if (!s->defined) {
     LinkSymId hit;
     if (s->name == 0) return 0;
     hit = symhash_get(&img->globals, s->name);
     if (hit == LINK_SYM_NONE || hit == s->id) return 0;
     return gc_def_site(img, l, hit, out_ii, out_sid, out_aid);
   }
   if (s->kind == SK_ABS || s->kind == SK_COMMON) return 0;
   if (s->input_id == LINK_INPUT_NONE) return 0;
   ob = LinkInputs_at(&l->inputs, s->input_id - 1)->obj;
   osym = obj_symbol_get(ob, s->obj_sym);
   if (!osym || osym->section_id == OBJ_SEC_NONE) return 0;
   *out_ii = (u32)(s->input_id - 1u);
   *out_sid = osym->section_id;
   *out_aid = link_input_sym_atom(&img->input_maps[*out_ii], s->obj_sym);
   return 1;
 }
 
 /* Detect __start_<X> / __stop_<X> with <X> a valid C identifier. */
 int link_gc_split_start_stop(const char* s, size_t n, size_t* out_off,
                              size_t* out_len, int* out_is_start) {
   static const char START[] = "__start_";
   static const char STOP[] = "__stop_";
   size_t off, len, i;
   int is_start;
   if (n > sizeof(START) - 1u && memcmp(s, START, sizeof(START) - 1u) == 0) {
     off = sizeof(START) - 1u;
     is_start = 1;
   } else if (n > sizeof(STOP) - 1u && memcmp(s, STOP, sizeof(STOP) - 1u) == 0) {
     off = sizeof(STOP) - 1u;
     is_start = 0;
   } else {
     return 0;
   }
   len = n - off;
   if (len == 0) return 0;
   {
     char c = s[off];
     if (!(c == '_' || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
       return 0;
   }
   for (i = 1; i < len; ++i) {
     char c = s[off + i];
     if (!(c == '_' || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
           (c >= '0' && c <= '9')))
       return 0;
   }
   *out_off = off;
   *out_len = len;
   if (out_is_start) *out_is_start = is_start;
   return 1;
 }
 
 static void gc_promote_by_section_name(Linker* l, LinkImage* img, GcLive* g,
                                        GcQueue* q, Heap* h, Sym section_name) {
   u32 ii, j;
   for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
     ObjBuilder* ob = LinkInputs_at(&l->inputs, ii)->obj;
     u32 nsec = obj_section_count(ob);
     for (j = 1; j < nsec; ++j) {
       const Section* s = obj_section_get(ob, j);
       if (!s || !link_section_kept(s)) continue;
       if (s->name != section_name) continue;
       gc_mark_section_or_atoms(g, q, h, ob, &img->input_maps[ii], ii, j);
     }
   }
 }
 
 static int gc_match_glob(const char* pat, const char* name) {
   size_t plen, nlen;
   if (!pat || !name) return 0;
   plen = slice_from_cstr(pat).len;
   nlen = slice_from_cstr(name).len;
   if (plen == 1 && pat[0] == '*') return 1;
   if (plen >= 2 && pat[plen - 1] == '*') {
     if (nlen + 1 < plen) return 0;
     return memcmp(pat, name, plen - 1) == 0;
   }
   if (plen >= 2 && pat[0] == '*') {
     if (nlen + 1 < plen) return 0;
     return memcmp(pat + 1, name + (nlen - (plen - 1)), plen - 1) == 0;
   }
   return plen == nlen && memcmp(pat, name, plen) == 0;
 }
 
 static const char* gc_basename(const char* s) {
   const char* base = s;
   if (!s) return NULL;
   for (; *s; ++s)
     if (*s == '/' || *s == '\\') base = s + 1;
   return base;
 }
 
 static int gc_match_input_name(Linker* l, u32 ii,
                                const KitLinkInputMatch* m) {
   const LinkInput* in;
   Slice nm = SLICE_NULL;
   const char* full;
   const char* base;
   u32 i;
   if (!m->file_pattern.s && m->nexclude_file_patterns == 0) return 1;
   in = LinkInputs_at(&l->inputs, ii);
   if (in->name) nm = pool_slice(l->c->global, in->name);
   full = nm.s;
   base = gc_basename(full);
   if (m->file_pattern.s) {
     if (!full) return 0;
     if (!gc_match_glob(m->file_pattern.s, full) &&
         !gc_match_glob(m->file_pattern.s, base))
       return 0;
   }
   for (i = 0; i < m->nexclude_file_patterns; ++i) {
     const char* pat = m->exclude_file_patterns[i].s;
     if (!pat || !full) continue;
     if (gc_match_glob(pat, full) || gc_match_glob(pat, base)) return 0;
   }
   return 1;
 }
 
 static void gc_mark_script_keep_roots(Linker* l, LinkImage* img, GcLive* g,
                                       GcQueue* q, Heap* h) {
   u32 si, mi, ii, j;
   if (!l->script) return;
   for (si = 0; si < l->script->nsections; ++si) {
     const KitLinkOutputSection* os = &l->script->sections[si];
     for (mi = 0; mi < os->ninputs; ++mi) {
       const KitLinkInputMatch* im = &os->inputs[mi];
       if (!im->keep) continue;
       for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
         ObjBuilder* ob = LinkInputs_at(&l->inputs, ii)->obj;
         InputMap* m = &img->input_maps[ii];
         if (!gc_match_input_name(l, ii, im)) continue;
         for (j = 1; j < obj_section_count(ob); ++j) {
           const Section* s = obj_section_get(ob, j);
           Slice sn;
           if (!s || !link_section_kept(s)) continue;
           if (m->comdat_discarded[j]) continue;
           sn = pool_slice(l->c->global, s->name);
           if (!gc_match_glob(im->section_pattern.s, sn.s)) continue;
           gc_mark_section_or_atoms(g, q, h, ob, m, ii, j);
         }
       }
     }
   }
 }
 
 static void gc_mark_script_extern_roots(Linker* l, LinkImage* img, GcLive* g,
                                         GcQueue* q, Heap* h) {
   u32 i;
   if (!l->script) return;
   for (i = 0; i < l->script->nexterns; ++i) {
     Sym name = pool_intern_slice(l->c->global, l->script->externs[i]);
     LinkSymId id = symhash_get(&img->globals, name);
     u32 tii;
     ObjSecId tsid;
     ObjAtomId taid;
     if (gc_def_site(img, l, id, &tii, &tsid, &taid)) {
       if (taid != OBJ_ATOM_NONE)
         gc_mark_atom(g, q, h, tii, taid);
       else
         gc_mark(g, q, h, tii, tsid);
     }
   }
 }
 
 void link_gc_compute(Linker* l, LinkImage* img, GcLive* g) {
   u32 ii, j, k;
   GcQueue q;
   Heap* h = img->heap;
 
   if (!l->gc_sections) {
     for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
       ObjBuilder* ob = LinkInputs_at(&l->inputs, ii)->obj;
       InputMap* m = &img->input_maps[ii];
       u32 nsec = obj_section_count(ob);
       for (j = 1; j < nsec; ++j) {
         const Section* s = obj_section_get(ob, j);
         if (s && link_section_kept(s) && !m->comdat_discarded[j])
           gc_mark_section_or_atoms(g, NULL, h, ob, m, ii, j);
       }
     }
     return;
   }
 
   memset(&q, 0, sizeof(q));
 
   for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
     ObjBuilder* ob = LinkInputs_at(&l->inputs, ii)->obj;
     InputMap* m = &img->input_maps[ii];
     u32 nsec = obj_section_count(ob);
     for (j = 1; j < nsec; ++j) {
       const Section* s = obj_section_get(ob, j);
       int root;
       if (!s || !link_section_kept(s)) continue;
       if (m->comdat_discarded[j]) continue;
       root = (s->flags & SF_RETAIN) || s->sem == SSEM_INIT_ARRAY ||
              s->sem == SSEM_FINI_ARRAY || s->sem == SSEM_PREINIT_ARRAY;
       if (root) gc_mark_section_or_atoms(g, &q, h, ob, m, ii, j);
       if (link_input_section_has_atoms(m, j)) {
         u32 first, count, ai;
         link_input_section_atoms(m, j, &first, &count);
         for (ai = 0; ai < count; ++ai) {
           ObjAtomId aid = m->section_atom_ids[first + ai];
           const ObjAtom* a = obj_atom_get(ob, aid);
           if (!a || a->removed) continue;
           if (a->flags & OBJ_ATOM_RETAIN) gc_mark_atom(g, &q, h, ii, aid);
         }
       }
     }
   }
 
   if (l->entry_name != 0) {
     LinkSymId id = symhash_get(&img->globals, l->entry_name);
     u32 tii;
     ObjSecId tsid;
     ObjAtomId taid;
     if (gc_def_site(img, l, id, &tii, &tsid, &taid)) {
       if (taid != OBJ_ATOM_NONE)
         gc_mark_atom(g, &q, h, tii, taid);
       else
         gc_mark(g, &q, h, tii, tsid);
     }
   }
 
   gc_mark_script_extern_roots(l, img, g, &q, h);
   gc_mark_script_keep_roots(l, img, g, &q, h);
 
   /* Keep executable definitions that a linked shared library references but
    * nothing in the executable does (e.g. FreeBSD libc.so.7's back-references
    * to crt-defined `environ` / `__progname`). Without rooting these, GC drops
    * the defining section and the resulting dynamic exe fails to load
    * ("Undefined symbol"). read_elf_dso records each DSO's undef names. */
   for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
     LinkInput* in = LinkInputs_at(&l->inputs, ii);
     const ObjImage* dim;
     u32 u, nu;
     if (in->kind != LINK_INPUT_DSO_BYTES || !in->obj) continue;
     dim = obj_image(in->obj);
     nu = obj_image_nundefs(dim);
     for (u = 0; u < nu; ++u) {
       LinkSymId id = symhash_get(&img->globals, obj_image_undef(dim, u));
       u32 tii;
       ObjSecId tsid;
       ObjAtomId taid;
       if (id == LINK_SYM_NONE) continue;
       if (gc_def_site(img, l, id, &tii, &tsid, &taid)) {
         if (taid != OBJ_ATOM_NONE)
           gc_mark_atom(g, &q, h, tii, taid);
         else
           gc_mark(g, &q, h, tii, tsid);
       }
     }
   }
 
   while (q.n > 0) {
     u64 v = q.items[--q.n];
     u32 cii = GC_II(v);
     int c_is_atom = GC_IS_ATOM(v);
     ObjSecId cj = (ObjSecId)GC_J(v);
     ObjBuilder* ob = LinkInputs_at(&l->inputs, cii)->obj;
     InputMap* m = &img->input_maps[cii];
     const ObjAtom* src_atom =
         c_is_atom ? obj_atom_get(ob, (ObjAtomId)cj) : NULL;
     ObjSecId src_sec = src_atom ? src_atom->section_id : cj;
     u32 total = obj_reloc_total(ob);
     (void)obj_section_count;
     if (!total) continue;
     for (k = 0; k < total; ++k) {
       const Reloc* r = obj_reloc_at(ob, k);
       LinkSymId target;
       const LinkSymbol* tsym;
       u32 tii;
       ObjSecId tsid;
       ObjAtomId taid;
       if (r->section_id != src_sec) continue;
       if (src_atom) {
         u64 begin = src_atom->offset;
         u64 end = begin + src_atom->size;
         if ((u64)r->offset < begin || (u64)r->offset >= end) continue;
       }
       if (r->sym == OBJ_SYM_NONE || r->sym >= m->nsym) continue;
       target = m->sym[r->sym];
       if (target == LINK_SYM_NONE) continue;
       tsym = LinkSyms_at(&img->syms, target - 1);
 
       if (tsym->name != 0) {
         size_t off, ilen;
         Slice nm_s = pool_slice(l->c->global, tsym->name);
         const char* nm = nm_s.s;
         size_t namelen = nm_s.len;
         if (link_gc_split_start_stop(nm, namelen, &off, &ilen, NULL)) {
           Sym secname = pool_intern_slice(l->c->global,
                                           (Slice){.s = nm + off, .len = ilen});
           gc_promote_by_section_name(l, img, g, &q, h, secname);
         }
       }
 
       if (gc_def_site(img, l, target, &tii, &tsid, &taid)) {
         if (taid != OBJ_ATOM_NONE)
           gc_mark_atom(g, &q, h, tii, taid);
         else
           gc_mark(g, &q, h, tii, tsid);
       }
     }
   }
 
   if (q.items) h->free(h, q.items, sizeof(*q.items) * q.cap);
 }
 
 void link_gc_drop_dead_globals(Linker* l, LinkImage* img, const GcLive* g) {
   u32 i;
   if (!l->gc_sections) return;
   for (i = 0; i < LinkSyms_count(&img->syms); ++i) {
     LinkSymbol* s = LinkSyms_at(&img->syms, i);
     ObjBuilder* ob;
     const ObjSym* osym;
     ObjSecId osid;
     ObjAtomId aid;
     if (!s->defined) continue;
     if (s->kind == SK_ABS || s->kind == SK_COMMON) continue;
     if (s->input_id == LINK_INPUT_NONE) continue;
     ob = LinkInputs_at(&l->inputs, s->input_id - 1)->obj;
     osym = obj_symbol_get(ob, s->obj_sym);
     if (!osym) continue;
     osid = osym->section_id;
     if (osid == OBJ_SEC_NONE) continue;
     aid = link_input_sym_atom(&img->input_maps[s->input_id - 1u], s->obj_sym);
     if (aid != OBJ_ATOM_NONE) {
       if (link_gc_atom_live_get(g, (u32)(s->input_id - 1u), aid)) continue;
       s->defined = 0;
       s->vaddr = 0;
       s->section_id = LINK_SEC_NONE;
       continue;
     }
     if (link_gc_live_get(g, (u32)(s->input_id - 1u), osid)) continue;
     s->defined = 0;
     s->vaddr = 0;
     s->section_id = LINK_SEC_NONE;
   }
 }
 
 /* ---- archive ingestion ---- */
 
 static void include_archive_member(Linker* l, const LinkArchive* ar,
                                    LinkArchiveMember* mem) {
   LinkInput* in;
   LinkInputId id;
   u32 idx;
   Sym coff_dll = 0;
   if (mem->included) return;
   if (mem->obj)
     link_merge_elf_e_flags(
         l, mem->obj,
         mem->name ? pool_slice(l->c->global, mem->name)
                   : SLICE_LIT("<unnamed archive member>"));
   in = LinkInputs_push(&l->inputs, &idx);
   if (!in)
     compiler_panic(l->c, SRCLOC_NONE,
                    "link: oom growing inputs (archive member)");
   id = (LinkInputId)(idx + 1u);
   in->id = id;
   /* PE/COFF short-import shim: read_coff_short_import stashes the
    * providing DLL name on the ObjBuilder. Such members behave like
    * DSO inputs — symbols are exports, not local definitions — so route
    * through LINK_INPUT_DSO_BYTES with the DLL name as the soname. */
   if (mem->obj && obj_get_coff_import_dll(mem->obj, &coff_dll) && coff_dll) {
     in->kind = LINK_INPUT_DSO_BYTES;
     in->soname = coff_dll;
     /* Short-import NameType may make the DLL export name differ from the
      * local symbol name (EXPORTAS etc.); carry it for import-table synthesis.
      */
     {
       Sym coff_imp_name = 0;
       if (obj_get_coff_import_name(mem->obj, &coff_imp_name))
         in->coff_import_name = coff_imp_name;
     }
   } else {
     in->kind = LINK_INPUT_OBJ_BYTES;
   }
   in->order = ar->order;
   in->obj = mem->obj;
   in->name = mem->name;
   mem->included = 1;
   mem->obj = NULL;
 }
 
 static void scan_presence_before(Linker* l, u32 max_order, SymHash* defined,
                                  SymHash* undefs) {
   u32 ii;
   ObjSymIter* it;
   ObjSymEntry e;
   for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
     LinkInput* in = LinkInputs_at(&l->inputs, ii);
     ObjBuilder* ob = in->obj;
     int is_dso = (in->kind == LINK_INPUT_DSO_BYTES);
     if (!ob || in->order > max_order) continue;
     it = obj_symiter_new(ob);
     while (obj_symiter_next(it, &e)) {
       const ObjSym* s = e.sym;
       if (s->name == 0) continue;
       if (s->bind == SB_LOCAL) continue;
       if (is_dso) {
         /* A DSO's exported symbols satisfy undefined references, so a later
          * static-archive member must NOT be pulled to redefine them. kit
          * records DSO exports as OBJ_SEC_NONE globals (the importer's view),
          * which obj_sym_is_logical_undef would otherwise misclassify as
          * undefined — leaving e.g. a real libc's atoi looking unsatisfied and
          * letting the freestanding rt's atoi shadow it. The DSO's own undefs
          * (SK_UNDEF) are not exports and stay out of `defined`. */
         if (s->kind != SK_UNDEF) symhash_set(defined, s->name, 1u);
         continue;
       }
       /* An unreferenced global/weak extern declaration is a header
        * artifact, not a real demand to pull from an archive.  Without
        * this prune the C frontend's per-extern undef synthesis (e.g.
        * every prototype in <math.h>) drags in matching archive members
        * even when the user's source never references them. Matches the
        * spurious-UNDEF prune in link_resolve_symbols and obj_sweep_dead
        * at .o emit (obj.c). */
       if (link_sym_is_spurious_undef(s)) continue;
       if (obj_sym_is_logical_undef(s))
         symhash_set(undefs, s->name, 1u);
       else
         symhash_set(defined, s->name, 1u);
     }
     obj_symiter_free(it);
   }
 }
 
 static int inputs_have_defined_ifunc_before(Linker* l, u32 max_order) {
   u32 ii;
   ObjSymIter* it;
   ObjSymEntry e;
   for (ii = 0; ii < LinkInputs_count(&l->inputs); ++ii) {
     LinkInput* in = LinkInputs_at(&l->inputs, ii);
     ObjBuilder* ob = in->obj;
     if (!ob || in->order > max_order) continue;
     it = obj_symiter_new(ob);
     while (obj_symiter_next(it, &e)) {
       const ObjSym* s = e.sym;
       if (s->kind == SK_IFUNC) {
         obj_symiter_free(it);
         return 1;
       }
     }
     obj_symiter_free(it);
   }
   return 0;
 }
 
 static int member_satisfies(LinkArchiveMember* mem, const SymHash* defined,
                             const SymHash* wanted, int weak_undef_pulls) {
   ObjSymIter* it;
   ObjSymEntry e;
   int hit = 0;
   it = obj_symiter_new(mem->obj);
   while (obj_symiter_next(it, &e)) {
     const ObjSym* s = e.sym;
     if (s->name == 0) continue;
     /* In COFF archives, WEAK_EXTERNAL alias declarations are read as
      * SB_WEAK + SK_UNDEF (kit has no native alias model — see
      * coff_read.c step "WEAK_EXTERNAL primary").  The archive's symbol
      * map still lists the member as the canonical provider of that
      * name, so treat such weak undefs as defining for the archive-pull
      * decision (formats whose COMDAT semantics pull on a weak undef —
      * obj_format_weak_undef_pulls_archive_member). The actual
      * alias-to-target resolution happens later in link_resolve_undefs. */
     if (s->kind == SK_UNDEF) {
       if (!(weak_undef_pulls && s->bind == SB_WEAK)) continue;
     }
     if (s->bind != SB_GLOBAL && s->bind != SB_WEAK) continue;
     if (symhash_get(wanted, s->name) == LINK_SYM_NONE) continue;
     if (symhash_get(defined, s->name) != LINK_SYM_NONE) continue;
     hit = 1;
     break;
   }
   obj_symiter_free(it);
   return hit;
 }
 
 static int scan_archive_once(Linker* l, LinkArchive* ar, u32 max_order,
                              Sym want_ifunc_init, int weak_undef_pulls) {
   SymHash defined, undefs;
   int changed = 0;
   u32 m;
   symhash_init(&defined, l->heap);
   symhash_init(&undefs, l->heap);
   scan_presence_before(l, max_order, &defined, &undefs);
   if (want_ifunc_init != 0 &&
       symhash_get(&defined, want_ifunc_init) == LINK_SYM_NONE)
     symhash_set(&undefs, want_ifunc_init, 1u);
   if (l->script && l->script->externs) {
     u32 ei;
     for (ei = 0; ei < l->script->nexterns; ++ei) {
       Sym ex = pool_intern_slice(l->c->global, l->script->externs[ei]);
       if (symhash_get(&defined, ex) == LINK_SYM_NONE)
         symhash_set(&undefs, ex, 1u);
     }
   }
 
   for (m = 0; m < ar->nmembers; ++m) {
     LinkArchiveMember* mem = &ar->members[m];
     if (mem->included) continue;
     if (!mem->obj) continue; /* long-form skip (head/trailer) */
     if (!member_satisfies(mem, &defined, &undefs, weak_undef_pulls)) continue;
     include_archive_member(l, ar, mem);
     changed = 1;
   }
   symhash_fini(&defined);
   symhash_fini(&undefs);
   return changed;
 }
 
 /* Synthesize an ObjBuilder providing the mingw CRT ctor/dtor list
  * boundary symbols (`__CTOR_LIST__`, `__CTOR_END__`, `__DTOR_LIST__`,
  * `__DTOR_END__`) backed by a 16-byte zero blob.  mingw's gccmain.o
  * references these and walks them at program startup; lld/binutils
  * generate them via the linker script's `.ctors` / `.dtors` rules.
  * kit has no script for PE, so we inject an equivalent here.
  *
  * Zero contents are intentional for the empty-list case:
  *   - __do_global_ctors loads `*(u32*)__CTOR_LIST__`; sees 0; cbz
  *     short-circuit returns without iterating.
  *   - __do_global_dtors loads `*(u64*)__DTOR_LIST__`; sees 0; cbz
  *     short-circuit returns.
  *
  * For programs that emit real ctor/dtor sections this synth would
  * need to coordinate with .ctors/.dtors layout; v1 covers the empty
  * case (hello-world through mingw CRT). */
 /* Registered as the COFF format's synth_inputs hook (src/obj/registry.c), so
  * it is only ever invoked for COFF targets — no obj==COFF guard needed. */
 void link_synth_coff_ctor_dtor_list(Linker* l) {
   ObjBuilder* ob;
   ObjSecId sid;
   static const u8 kZeros[16] = {0};
   LinkInput* in;
   u32 idx;
   if (!l) return;
   ob = obj_new(l->c);
   if (!ob) return;
   sid = obj_section_ex(
       ob, pool_intern_slice(l->c->global, SLICE_LIT(".rdata$ctors")),
       SEC_RODATA, SSEM_PROGBITS, SF_ALLOC | SF_RETAIN, 16, 0u, 0u, 0u);
   obj_section_replace_bytes(ob, sid, kZeros, sizeof(kZeros));
   obj_symbol_ex(ob, pool_intern_slice(l->c->global, SLICE_LIT("__CTOR_LIST__")),
                 SB_GLOBAL, SV_DEFAULT, SK_OBJ, sid, 0, 0, 0);
   obj_symbol_ex(ob, pool_intern_slice(l->c->global, SLICE_LIT("__CTOR_END__")),
                 SB_GLOBAL, SV_DEFAULT, SK_OBJ, sid, 0, 0, 0);
   obj_symbol_ex(ob, pool_intern_slice(l->c->global, SLICE_LIT("__DTOR_LIST__")),
                 SB_GLOBAL, SV_DEFAULT, SK_OBJ, sid, 0, 0, 0);
   obj_symbol_ex(ob, pool_intern_slice(l->c->global, SLICE_LIT("__DTOR_END__")),
                 SB_GLOBAL, SV_DEFAULT, SK_OBJ, sid, 0, 0, 0);
   /* __chkstk: synthesized only for arches whose link descriptor carries the
    * stub bytes (aarch64). x64 needs none — its codegen emits inline probes (or
    * links libmingwex's plain-object __chkstk). Driven by the descriptor, so no
    * arch identity is consulted here. */
   {
     const LinkArchDesc* la = link_arch_desc_for(l->c);
     if (la && la->coff_chkstk_bytes && la->coff_chkstk_len) {
       ObjSecId tsid = obj_section_ex(
           ob, pool_intern_slice(l->c->global, SLICE_LIT(".text$chkstk")),
           SEC_TEXT, SSEM_PROGBITS, SF_ALLOC | SF_EXEC | SF_RETAIN, 4, 0u, 0u,
           0u);
       obj_section_replace_bytes(ob, tsid, la->coff_chkstk_bytes,
                                 la->coff_chkstk_len);
       obj_symbol_ex(ob, pool_intern_slice(l->c->global, SLICE_LIT("__chkstk")),
                     SB_GLOBAL, SV_DEFAULT, SK_FUNC, tsid, 0,
                     la->coff_chkstk_len, 0);
     }
   }
   obj_finalize(ob);
   in = LinkInputs_push(&l->inputs, &idx);
   if (!in)
     compiler_panic(l->c, SRCLOC_NONE, "link: oom growing inputs (synth)");
   in->id = (LinkInputId)(idx + 1u);
   in->kind = LINK_INPUT_OBJ_BYTES;
   in->order = l->next_input_order++;
   in->obj = ob;
   in->name =
       pool_intern_slice(l->c->global, SLICE_LIT("<kit-synth-coff-runtime>"));
   in->soname = 0;
 }
 
 void link_ingest_archives(Linker* l) {
   u32 a, m;
   int weak_undef_pulls;
   if (LinkArchives_count(&l->archives) == 0) return;
   weak_undef_pulls = obj_format_weak_undef_pulls_archive_member(l->c);
 
   for (a = 0; a < LinkArchives_count(&l->archives); ++a) {
     LinkArchive* ar = LinkArchives_at(&l->archives, a);
     if (!ar->whole_archive) continue;
     for (m = 0; m < ar->nmembers; ++m) {
       /* obj==NULL is the long-form COFF head/trailer skip path
        * (set by link_add_archive_bytes). Drop them silently. */
       if (!ar->members[m].obj) continue;
       include_archive_member(l, ar, &ar->members[m]);
     }
   }
 
   if (obj_format_global_archive_fixpoint(l->c)) {
     for (;;) {
       int changed = 0;
       for (a = 0; a < LinkArchives_count(&l->archives); ++a) {
         LinkArchive* ar = LinkArchives_at(&l->archives, a);
         if (ar->whole_archive) continue;
         changed |= scan_archive_once(l, ar, ~0u, 0, weak_undef_pulls);
       }
       if (!changed) break;
     }
     return;
   }
 
   for (a = 0; a < LinkArchives_count(&l->archives); ++a) {
     LinkArchive* ar = LinkArchives_at(&l->archives, a);
     Sym want_ifunc_init = 0;
     if (ar->whole_archive) continue;
     if (l->emit_static_exe && inputs_have_defined_ifunc_before(l, ar->order))
       want_ifunc_init =
           pool_intern_slice(l->c->global, SLICE_LIT("__kit_ifunc_init"));
     for (;;) {
       if (!scan_archive_once(l, ar, ar->order, want_ifunc_init,
                              weak_undef_pulls))
         break;
     }
   }
 }