kit

obj.c (54992B)

---

 /* In-memory ObjBuilder. Section, symbol, group, and reloc storage all
  * use segmented arrays (core/segvec.h) so the T* pointers obj_*_get
  * returns stay valid as the table grows. Section bytes use the chunked
  * Buf type. Index 0 of each id space is reserved as "none".
  *
  * obj_finalize is the read-side gate: post-finalize, write-side calls
  * are still legal (the reader paths use them too) but consumers can
  * count on the index spaces being stable. */
 
 #include "obj/obj.h"
 
 #include <string.h>
 
 #include "core/hashmap.h"
 #include "core/heap.h"
 #include "core/pool.h"
 #include "core/segvec.h"
 #include "core/vec.h"
 
 SEGVEC_DEFINE(Sections, Section, 5); /* 32 entries per segment */
 SEGVEC_DEFINE(Symbols, ObjSym, 6);   /* 64 entries per segment */
 
 /* name (interned Sym) -> first defining ObjSymId. The authoritative index for
  * obj_symbol_find: the whole-program LTO builder holds every TU's symbols in
  * one builder, so the historical linear scan is O(n^2) at decl time. The index
  * stores the first id seen for a name (matching the scan's "first match"
  * semantics), and obj_symbol_find is a pure O(1) hash lookup with no fallback.
  * obj_symbol_rename keeps the index exact (re-homing or dropping a renamed
  * symbol's entry), so the lookup never sees a stale hit. */
 HASHMAP_DEFINE(SymNameIndex, Sym, ObjSymId, hash_u32);
 
 /* (name, kind) -> first PROGBITS ObjSecId. obj_section is a find-or-create that
  * collapses repeated requests for the same logical section (e.g. one .rodata
  * per literal) onto a single Section; without this index that find is a linear
  * scan of every section, which is O(n^2) once a build emits many distinct
  * sections (e.g. -ffunction-sections). The key packs (name, kind) and is always
  * odd so it never collides with the hashmap's 0 empty-slot sentinel. */
 HASHMAP_DEFINE(SecKeyIndex, u64, ObjSecId, hash_u64);
 SEGVEC_DEFINE(Relocs, Reloc, 6);    /* 64 entries per segment */
 SEGVEC_DEFINE(Groups, ObjGroup, 3); /*  8 entries per segment */
 SEGVEC_DEFINE(Atoms, ObjAtom, 5);   /* 32 entries per segment */
 
 /* COFF WEAK_EXTERNAL alias declaration: symbol `sym` is an alias for the
  * symbol named `target`. Rare (only import-archive members and the like
  * carry these), so a side-vector keyed by ObjSymId keeps ObjSym lean
  * instead of growing every symbol. See obj_set_weak_alias. */
 typedef struct ObjWeakAlias {
   ObjSymId sym;
   Sym target;
 } ObjWeakAlias;
 SEGVEC_DEFINE(WeakAliases, ObjWeakAlias, 3); /* 8 entries per segment */
 
 #define OBJ_EXT_SLOT_COUNT 6 /* OBJ_EXT_NONE..OBJ_EXT_WASM_IMPORTS */
 
 typedef struct ObjExtSlot {
   void* payload;
   ObjExtFreeFn free_fn;
 } ObjExtSlot;
 
 struct KitObjBuilder {
   Compiler* c;
   Heap* heap;
   Sections sections;        /* index 0 reserved as "none" */
   Symbols symbols;          /* index 0 reserved as "none" */
   Relocs relocs;            /* flat across all sections; filtered on read */
   Groups groups;            /* index 0 reserved as "none" */
   Atoms atoms;              /* index 0 reserved as "none" */
   SymNameIndex sym_by_name; /* name -> first ObjSymId; accelerates find */
   SecKeyIndex sec_by_key;   /* (name,kind) -> first PROGBITS ObjSecId */
   /* Format-specific ELF e_flags. Set by read_elf to the input's
    * e_flags (e.g. on RISC-V, EF_RISCV_RVC | EF_RISCV_FLOAT_ABI_DOUBLE);
    * consumed by emit_elf to round-trip. Zero when not set — emit_elf
    * derives a sensible default by arch. */
   u32 elf_e_flags;
   u8 elf_e_flags_set;
   /* COFF short-import annotation. Carries the providing DLL name when
    * the builder was synthesized by read_coff from a Microsoft short
    * import record; zero / unset otherwise. See obj_set_coff_import_dll. */
   Sym coff_import_dll;
   u8 coff_import_dll_set;
   /* COFF short-import IMPORT NAME override. The Microsoft short-import
    * NameType field can make the name the loader resolves in the DLL differ
    * from the local symbol name (NOPREFIX/UNDECORATE strip decoration;
    * EXPORTAS stores an explicit export name). Carries that resolved import
    * name when it differs from the symbol name; zero / unset otherwise. The
    * local symbol keeps its own name so references still resolve; only the PE
    * hint/name-table entry uses this. See obj_set_coff_import_name. */
   Sym coff_import_name;
   u8 coff_import_name_set;
   /* COFF WEAK_EXTERNAL alias declarations read from the input (symbol ->
    * fallback/default symbol name). Empty on builders that carry none. See
    * obj_set_weak_alias / obj_get_weak_alias. */
   WeakAliases weak_aliases;
   /* Cached undef extern `__tlv_bootstrap` (Mach-O on-disk name) used by
    * obj_define_tls when emitting `_Thread_local` storage on Mach-O.
    * Lazily materialized on the first TLV emission; OBJ_SYM_NONE otherwise. */
   ObjSymId tlv_bootstrap_sym;
   /* Format-specific extension payloads keyed by ObjExtKind. */
   ObjExtSlot ext[OBJ_EXT_SLOT_COUNT];
   /* Linked-image view (segments + dynamic info). NULL on relocatable
    * inputs; lazily created by obj_image_ensure. See obj.h. */
   ObjImage* image;
   /* Per-section reloc index (lazy cache). Without it, every native emitter
    * rescans the whole flat reloc table once per section — O(n_sections *
    * n_relocs), a latent superlinear axis that grows with -ffunction-sections
    * and literal fan-out. `reloc_index` holds the global indices of live
    * relocs grouped by section in ascending global order; `reloc_index_off`
    * is the prefix-offset array (len reloc_index_nsec+1) so section `s`'s run
    * is reloc_index[off[s] .. off[s+1]). Rebuilt by obj_reloc_index_ensure
    * when `reloc_index_dirty` (set on reloc add and on obj_sweep_dead). */
   u32* reloc_index;
   u32* reloc_index_off;
   u32 reloc_index_nsec; /* #sections reloc_index_off was sized for */
   u32 reloc_index_len;  /* #live relocs in reloc_index */
   u8 reloc_index_dirty;
 };
 
 struct ObjSymIter {
   const ObjBuilder* ob;
   u32 idx; /* next index to return */
 };
 
 static void obj_image_free_(ObjBuilder*);
 
 /* ---- lifecycle ---- */
 
 ObjBuilder* obj_new(Compiler* c) {
   Heap* h = (Heap*)c->ctx->heap;
   ObjBuilder* ob = (ObjBuilder*)h->alloc(h, sizeof(*ob), _Alignof(ObjBuilder));
   if (!ob) return NULL;
   memset(ob, 0, sizeof(*ob));
   ob->c = c;
   ob->heap = h;
   Sections_init(&ob->sections, h);
   Symbols_init(&ob->symbols, h);
   Relocs_init(&ob->relocs, h);
   Groups_init(&ob->groups, h);
   Atoms_init(&ob->atoms, h);
   /* Pre-size the symbol-name index: a typical TU has hundreds of symbols, and
    * the default 16-slot map would otherwise resize/rehash ~4 times (16->256)
    * while declarations stream in. 256 (a power of two, holds 192 at the 3/4
    * load factor) skips that early cascade. Order-preserving — resize reinserts
    * and the first-wins set at obj_symbol_make is unchanged. */
   SymNameIndex_init_cap(&ob->sym_by_name, h, 256u);
   SecKeyIndex_init(&ob->sec_by_key, h);
   WeakAliases_init(&ob->weak_aliases, h);
 
   /* Reserve index 0 in each id space as the "none" sentinel. SegVec
    * pushes are zeroed, so the sentinel slots have all-zero fields. */
   if (!Sections_push(&ob->sections, NULL) ||
       !Symbols_push(&ob->symbols, NULL) || !Groups_push(&ob->groups, NULL) ||
       !Atoms_push(&ob->atoms, NULL)) {
     obj_free(ob);
     return NULL;
   }
   return ob;
 }
 
 Compiler* obj_compiler(const ObjBuilder* ob) { return ob ? ob->c : NULL; }
 
 /* Pre-size the symbol-name index for `n` incoming symbols. Object readers know
  * the symbol count up front (the symtab header), so calling this before
  * streaming symbols in skips the resize cascade off obj_new's 256-slot default
  * on a symbol-heavy object (e.g. a large .o the linker ingests). No-op once the
  * index is already large enough; order-preserving (resize reinserts). */
 void obj_reserve_symbols(ObjBuilder* ob, u32 n) {
   if (ob) SymNameIndex_reserve(&ob->sym_by_name, n);
 }
 
 /* Private accessors for the `_tlv_bootstrap` cache used by obj_define_tls.
  * Lives in obj.c so the ObjBuilder field doesn't leak through obj.h. */
 ObjSymId obj_tlv_bootstrap_get(const ObjBuilder* ob) {
   return ob ? ob->tlv_bootstrap_sym : OBJ_SYM_NONE;
 }
 void obj_tlv_bootstrap_set(ObjBuilder* ob, ObjSymId id) {
   if (ob) ob->tlv_bootstrap_sym = id;
 }
 
 void obj_free(ObjBuilder* ob) {
   u32 i, n;
   if (!ob) return;
   for (i = 0; i < OBJ_EXT_SLOT_COUNT; ++i) {
     if (ob->ext[i].payload && ob->ext[i].free_fn) {
       ob->ext[i].free_fn(ob->c, ob->ext[i].payload);
     }
     ob->ext[i].payload = NULL;
     ob->ext[i].free_fn = NULL;
   }
   n = Sections_count(&ob->sections);
   for (i = 1; i < n; ++i) {
     Section* s = Sections_at(&ob->sections, i);
     if (s) buf_fini(&s->bytes);
   }
   n = Groups_count(&ob->groups);
   for (i = 1; i < n; ++i) {
     ObjGroup* g = Groups_at(&ob->groups, i);
     if (g && g->sections) {
       ob->heap->free(ob->heap, g->sections, sizeof(ObjSecId) * g->nsections);
     }
   }
   Sections_fini(&ob->sections);
   Symbols_fini(&ob->symbols);
   Relocs_fini(&ob->relocs);
   Groups_fini(&ob->groups);
   Atoms_fini(&ob->atoms);
   SymNameIndex_fini(&ob->sym_by_name);
   SecKeyIndex_fini(&ob->sec_by_key);
   WeakAliases_fini(&ob->weak_aliases);
   obj_image_free_(ob);
   if (ob->reloc_index)
     ob->heap->free(ob->heap, ob->reloc_index,
                    sizeof(u32) * ob->reloc_index_len);
   if (ob->reloc_index_off)
     ob->heap->free(ob->heap, ob->reloc_index_off,
                    sizeof(u32) * (ob->reloc_index_nsec + 1u));
   ob->heap->free(ob->heap, ob, sizeof(*ob));
 }
 
 void obj_set_elf_e_flags(ObjBuilder* ob, u32 e_flags) {
   if (!ob) return;
   ob->elf_e_flags = e_flags;
   ob->elf_e_flags_set = 1;
 }
 
 int obj_get_elf_e_flags(const ObjBuilder* ob, u32* out) {
   if (!ob || !ob->elf_e_flags_set) return 0;
   if (out) *out = ob->elf_e_flags;
   return 1;
 }
 
 void obj_set_coff_import_dll(ObjBuilder* ob, Sym dll_name) {
   if (!ob) return;
   ob->coff_import_dll = dll_name;
   ob->coff_import_dll_set = 1;
 }
 
 int obj_get_coff_import_dll(const ObjBuilder* ob, Sym* out) {
   if (!ob || !ob->coff_import_dll_set) return 0;
   if (out) *out = ob->coff_import_dll;
   return 1;
 }
 
 void obj_set_coff_import_name(ObjBuilder* ob, Sym import_name) {
   if (!ob) return;
   ob->coff_import_name = import_name;
   ob->coff_import_name_set = 1;
 }
 
 int obj_get_coff_import_name(const ObjBuilder* ob, Sym* out) {
   if (!ob || !ob->coff_import_name_set) return 0;
   if (out) *out = ob->coff_import_name;
   return 1;
 }
 
 void obj_set_weak_alias(ObjBuilder* ob, ObjSymId sym, Sym target) {
   if (!ob || sym == OBJ_SYM_NONE || target == 0) return;
   /* Overwrite an existing entry for this sym rather than duplicating. */
   u32 n = WeakAliases_count(&ob->weak_aliases);
   for (u32 i = 0; i < n; ++i) {
     ObjWeakAlias* a = WeakAliases_at(&ob->weak_aliases, i);
     if (a->sym == sym) {
       a->target = target;
       return;
     }
   }
   ObjWeakAlias* slot = WeakAliases_push(&ob->weak_aliases, NULL);
   if (!slot) return; /* OOM: alias recovery falls back to the name heuristic */
   slot->sym = sym;
   slot->target = target;
 }
 
 Sym obj_get_weak_alias(const ObjBuilder* ob, ObjSymId sym) {
   if (!ob || sym == OBJ_SYM_NONE) return 0;
   u32 n = WeakAliases_count(&ob->weak_aliases);
   for (u32 i = 0; i < n; ++i) {
     const ObjWeakAlias* a = WeakAliases_at(&ob->weak_aliases, i);
     if (a->sym == sym) return a->target;
   }
   return 0;
 }
 
 u32 obj_weak_alias_count(const ObjBuilder* ob) {
   return ob ? WeakAliases_count(&ob->weak_aliases) : 0;
 }
 
 int obj_weak_alias_at(const ObjBuilder* ob, u32 i, ObjSymId* sym_out,
                       Sym* target_out) {
   if (!ob || i >= WeakAliases_count(&ob->weak_aliases)) return 0;
   const ObjWeakAlias* a = WeakAliases_at(&ob->weak_aliases, i);
   if (sym_out) *sym_out = a->sym;
   if (target_out) *target_out = a->target;
   return 1;
 }
 
 /* ---- linked-image view ---- */
 
 struct ObjImage {
   Heap* heap;
   ObjKind kind;
   u64 entry;
   u64 image_base;
   Sym interp;
   Sym soname;
   ObjSegment* segs;
   u32 nsegs, cap_segs;
   ObjImageDep* deps;
   u32 ndeps, cap_deps;
   Sym* rpaths;
   u32 nrpaths, cap_rpaths;
   ObjImageSym* dynsyms;
   u32 ndynsyms, cap_dynsyms;
   ObjImageReloc* dynrelocs;
   u32 ndynrelocs, cap_dynrelocs;
   ObjImageRaw* raws;
   u32 nraws, cap_raws;
   /* Undefined symbol names a DSO references (interned). Used by the linker's
    * --gc-sections pass to keep executable-defined symbols a shared library
    * needs (e.g. libc.so.7's `environ` / `__progname`) from being collected. */
   Sym* undefs;
   u32 nundefs, cap_undefs;
 };
 
 static void obj_image_free_(ObjBuilder* ob) {
   ObjImage* im;
   if (!ob || !ob->image) return;
   im = ob->image;
   /* The image owns each dep's imports[] array container (allocated from
    * im->heap by the PE reader); the Sym values inside stay interned in the
    * global pool and are not freed here. ELF/Mach-O deps carry imports==NULL. */
   if (im->deps) {
     for (u32 i = 0; i < im->ndeps; ++i) {
       const ObjImageDep* d = &im->deps[i];
       if (d->imports)
         im->heap->free(im->heap, (void*)d->imports,
                        sizeof(*d->imports) * d->nimports);
     }
   }
   if (im->segs)
     im->heap->free(im->heap, im->segs, sizeof(*im->segs) * im->cap_segs);
   if (im->deps)
     im->heap->free(im->heap, im->deps, sizeof(*im->deps) * im->cap_deps);
   if (im->rpaths)
     im->heap->free(im->heap, im->rpaths, sizeof(*im->rpaths) * im->cap_rpaths);
   if (im->dynsyms)
     im->heap->free(im->heap, im->dynsyms,
                    sizeof(*im->dynsyms) * im->cap_dynsyms);
   if (im->dynrelocs)
     im->heap->free(im->heap, im->dynrelocs,
                    sizeof(*im->dynrelocs) * im->cap_dynrelocs);
   if (im->raws)
     im->heap->free(im->heap, im->raws, sizeof(*im->raws) * im->cap_raws);
   if (im->undefs)
     im->heap->free(im->heap, im->undefs, sizeof(*im->undefs) * im->cap_undefs);
   ob->heap->free(ob->heap, im, sizeof(*im));
   ob->image = NULL;
 }
 
 const ObjImage* obj_image(const ObjBuilder* ob) {
   return ob ? ob->image : NULL;
 }
 
 ObjImage* obj_image_ensure(ObjBuilder* ob, ObjKind kind) {
   ObjImage* im;
   if (!ob) return NULL;
   if (ob->image) {
     ob->image->kind = kind;
     return ob->image;
   }
   im = (ObjImage*)ob->heap->alloc(ob->heap, sizeof(*im), _Alignof(ObjImage));
   if (!im) return NULL;
   memset(im, 0, sizeof(*im));
   im->heap = ob->heap;
   im->kind = kind;
   ob->image = im;
   return im;
 }
 
 void obj_image_set_entry(ObjImage* im, u64 entry) {
   if (im) im->entry = entry;
 }
 void obj_image_set_base(ObjImage* im, u64 image_base) {
   if (im) im->image_base = image_base;
 }
 void obj_image_set_interp(ObjImage* im, Sym interp) {
   if (im) im->interp = interp;
 }
 void obj_image_set_soname(ObjImage* im, Sym soname) {
   if (im) im->soname = soname;
 }
 
 void obj_image_add_segment(ObjImage* im, const ObjSegment* seg) {
   if (!im || !seg) return;
   if (VEC_GROW(im->heap, im->segs, im->cap_segs, im->nsegs + 1)) return;
   im->segs[im->nsegs++] = *seg;
 }
 void obj_image_add_dep(ObjImage* im, const ObjImageDep* dep) {
   ObjImageDep d;
   if (!im || !dep) return;
   if (VEC_GROW(im->heap, im->deps, im->cap_deps, im->ndeps + 1)) return;
   d = *dep;
   /* Deep-copy the imports[] name array into image-heap-owned memory so the
    * reader may pass a transient (scratch/arena) array; obj_image_free_
    * releases this copy. The Sym values inside are global-interned and not
    * owned here. ELF/Mach-O deps carry imports==NULL (nimports==0). */
   if (d.nimports && dep->imports) {
     Sym* copy = (Sym*)im->heap->alloc(im->heap, sizeof(Sym) * d.nimports,
                                       _Alignof(Sym));
     if (!copy) {
       d.imports = NULL;
       d.nimports = 0;
     } else {
       memcpy(copy, dep->imports, sizeof(Sym) * d.nimports);
       d.imports = copy;
     }
   } else {
     d.imports = NULL;
     d.nimports = 0;
   }
   im->deps[im->ndeps++] = d;
 }
 void obj_image_add_rpath(ObjImage* im, Sym rpath) {
   if (!im) return;
   if (VEC_GROW(im->heap, im->rpaths, im->cap_rpaths, im->nrpaths + 1)) return;
   im->rpaths[im->nrpaths++] = rpath;
 }
 void obj_image_add_dynsym(ObjImage* im, const ObjImageSym* sym) {
   if (!im || !sym) return;
   if (VEC_GROW(im->heap, im->dynsyms, im->cap_dynsyms, im->ndynsyms + 1))
     return;
   im->dynsyms[im->ndynsyms++] = *sym;
 }
 void obj_image_add_dynreloc(ObjImage* im, const ObjImageReloc* rel) {
   if (!im || !rel) return;
   if (VEC_GROW(im->heap, im->dynrelocs, im->cap_dynrelocs, im->ndynrelocs + 1))
     return;
   im->dynrelocs[im->ndynrelocs++] = *rel;
 }
 void obj_image_add_undef(ObjImage* im, Sym name) {
   if (!im || !name) return;
   if (VEC_GROW(im->heap, im->undefs, im->cap_undefs, im->nundefs + 1)) return;
   im->undefs[im->nundefs++] = name;
 }
 void obj_image_add_raw(ObjImage* im, const ObjImageRaw* raw) {
   if (!im || !raw) return;
   if (VEC_GROW(im->heap, im->raws, im->cap_raws, im->nraws + 1)) return;
   im->raws[im->nraws++] = *raw;
 }
 
 ObjKind obj_image_kind(const ObjImage* im) {
   return im ? im->kind : OBJ_KIND_REL;
 }
 u64 obj_image_entry(const ObjImage* im) { return im ? im->entry : 0; }
 u64 obj_image_base(const ObjImage* im) { return im ? im->image_base : 0; }
 Sym obj_image_interp(const ObjImage* im) { return im ? im->interp : 0; }
 Sym obj_image_soname(const ObjImage* im) { return im ? im->soname : 0; }
 
 u32 obj_image_nsegments(const ObjImage* im) { return im ? im->nsegs : 0; }
 const ObjSegment* obj_image_segment(const ObjImage* im, u32 idx) {
   return (im && idx < im->nsegs) ? &im->segs[idx] : NULL;
 }
 u32 obj_image_ndeps(const ObjImage* im) { return im ? im->ndeps : 0; }
 const ObjImageDep* obj_image_dep(const ObjImage* im, u32 idx) {
   return (im && idx < im->ndeps) ? &im->deps[idx] : NULL;
 }
 u32 obj_image_nrpaths(const ObjImage* im) { return im ? im->nrpaths : 0; }
 Sym obj_image_rpath(const ObjImage* im, u32 idx) {
   return (im && idx < im->nrpaths) ? im->rpaths[idx] : 0;
 }
 u32 obj_image_ndynsyms(const ObjImage* im) { return im ? im->ndynsyms : 0; }
 const ObjImageSym* obj_image_dynsym(const ObjImage* im, u32 idx) {
   return (im && idx < im->ndynsyms) ? &im->dynsyms[idx] : NULL;
 }
 u32 obj_image_ndynrelocs(const ObjImage* im) { return im ? im->ndynrelocs : 0; }
 const ObjImageReloc* obj_image_dynreloc(const ObjImage* im, u32 idx) {
   return (im && idx < im->ndynrelocs) ? &im->dynrelocs[idx] : NULL;
 }
 u32 obj_image_nundefs(const ObjImage* im) { return im ? im->nundefs : 0; }
 Sym obj_image_undef(const ObjImage* im, u32 idx) {
   return (im && idx < im->nundefs) ? im->undefs[idx] : 0;
 }
 u32 obj_image_nraws(const ObjImage* im) { return im ? im->nraws : 0; }
 const ObjImageRaw* obj_image_raw(const ObjImage* im, u32 idx) {
   return (im && idx < im->nraws) ? &im->raws[idx] : NULL;
 }
 
 void obj_ext_set(ObjBuilder* ob, ObjExtKind kind, void* payload,
                  ObjExtFreeFn free_fn) {
   if (!ob || (u32)kind >= OBJ_EXT_SLOT_COUNT) return;
   if (ob->ext[kind].payload && ob->ext[kind].free_fn &&
       ob->ext[kind].payload != payload) {
     ob->ext[kind].free_fn(ob->c, ob->ext[kind].payload);
   }
   ob->ext[kind].payload = payload;
   ob->ext[kind].free_fn = free_fn;
 }
 
 void* obj_ext_get(const ObjBuilder* ob, ObjExtKind kind) {
   if (!ob || (u32)kind >= OBJ_EXT_SLOT_COUNT) return NULL;
   return ob->ext[kind].payload;
 }
 
 void obj_ext_clear(ObjBuilder* ob, ObjExtKind kind) {
   if (!ob || (u32)kind >= OBJ_EXT_SLOT_COUNT) return;
   if (ob->ext[kind].payload && ob->ext[kind].free_fn) {
     ob->ext[kind].free_fn(ob->c, ob->ext[kind].payload);
   }
   ob->ext[kind].payload = NULL;
   ob->ext[kind].free_fn = NULL;
 }
 
 /* ---- write side ---- */
 
 /* Pack (name, kind) into a nonzero hashmap key. The low bit is always set so
  * the key is never 0 (the empty-slot sentinel), and name/kind occupy disjoint
  * bit ranges so distinct (name, kind) pairs never collide. */
 static u64 sec_progbits_key(Sym name, SecKind kind) {
   return (((u64)name) << 17) | (((u64)(u16)kind) << 1) | 1u;
 }
 
 ObjSecId obj_section(ObjBuilder* ob, Sym name, SecKind kind, u16 flags,
                      u32 align) {
   /* Find-or-create by (name, kind, sem=PROGBITS). Repeated calls for the
    * same logical section — e.g. one .rodata per FP/string literal, or one
    * .data per static initializer — collapse onto a single Section and
    * accumulate bytes into it instead of emitting a fan-out of identically-
    * named output sections.  Merge align (max) and flags (union) so a
    * stricter requirement from a later caller wins. The PROGBITS find is an
    * O(1) index lookup (sec_by_key), kept exact by obj_section_ex. */
   ObjSecId* hit =
       SecKeyIndex_get(&ob->sec_by_key, sec_progbits_key(name, kind));
   if (hit) {
     Section* s = Sections_at(&ob->sections, *hit);
     if (s) {
       if (align > s->align) s->align = align;
       s->flags = (u16)(s->flags | flags);
       /* Pad to align so the next obj_reserve / obj_write lands at an
        * offset that satisfies this caller's alignment.  Without this
        * each contribution is laid out at whatever offset the prior
        * write happened to leave, so a 4-byte global following a 6-byte
        * string lands at .data+6 — and any LDST32 reloc against the
        * containing section breaks at link time. */
       u32 a = align ? align : 1u;
       if (a > 1u) {
         u32 cur = buf_pos(&s->bytes);
         u32 mis = cur & (a - 1u);
         if (mis) {
           u32 pad = a - mis;
           u8* dst = buf_reserve(&s->bytes, pad);
           if (dst) memset(dst, 0, pad);
         }
       }
       return *hit;
     }
   }
   return obj_section_ex(ob, name, kind, SSEM_PROGBITS, flags, align, 0,
                         OBJ_SEC_NONE, 0);
 }
 
 ObjSecId obj_section_ex(ObjBuilder* ob, Sym name, SecKind kind, SecSem sem,
                         u16 flags, u32 align, u32 entsize, u32 link, u32 info) {
   u32 id;
   Section* s = Sections_push(&ob->sections, &id);
   if (!s) return OBJ_SEC_NONE;
   s->name = name;
   s->kind = (u16)kind;
   s->flags = flags;
   s->sem = (u16)sem;
   s->ext_kind = OBJ_EXT_NONE;
   s->align = align ? align : 1;
   s->entsize = entsize;
   s->link = (ObjSecId)link;
   s->info = info;
   s->group_id = OBJ_GROUP_NONE;
   s->bss_size = 0;
   s->addr = 0;
   buf_init(&s->bytes, ob->heap);
   /* Index PROGBITS sections so obj_section's find is O(1). try_insert keeps the
    * first id for a (name, kind), matching the old scan's first-match semantics
    * (and leaving distinct same-named COMDAT sections, created directly here, to
    * resolve to the first — exactly as the linear scan did). */
   if (sem == SSEM_PROGBITS)
     (void)SecKeyIndex_try_insert(&ob->sec_by_key, sec_progbits_key(name, kind),
                                  (ObjSecId)id, NULL);
   return (ObjSecId)id;
 }
 
 void obj_section_set_addr(ObjBuilder* ob, ObjSecId id, u64 addr) {
   Section* s = Sections_at(&ob->sections, id);
   if (s && id != OBJ_SEC_NONE) s->addr = addr;
 }
 
 void obj_section_set_flags(ObjBuilder* ob, ObjSecId id, u16 flags) {
   Section* s = Sections_at(&ob->sections, id);
   if (s && id != OBJ_SEC_NONE) s->flags = flags;
 }
 
 void obj_section_set_entsize(ObjBuilder* ob, ObjSecId id, u32 entsize) {
   Section* s = Sections_at(&ob->sections, id);
   if (s && id != OBJ_SEC_NONE) s->entsize = entsize;
 }
 
 void obj_section_set_align(ObjBuilder* ob, ObjSecId id, u32 align) {
   Section* s = Sections_at(&ob->sections, id);
   if (s && id != OBJ_SEC_NONE) s->align = align ? align : 1;
 }
 
 void obj_section_set_group(ObjBuilder* ob, ObjSecId id, ObjGroupId gid) {
   Section* s = Sections_at(&ob->sections, id);
   if (s && id != OBJ_SEC_NONE) s->group_id = gid;
 }
 
 void obj_section_set_link_info(ObjBuilder* ob, ObjSecId id, ObjSecId link,
                                u32 info) {
   Section* s;
   if (id == OBJ_SEC_NONE) return;
   s = Sections_at(&ob->sections, id);
   if (!s) return;
   s->link = link;
   s->info = info;
 }
 
 void obj_section_set_ext(ObjBuilder* ob, ObjSecId id, ObjExtKind ek,
                          u32 ext_type, u32 ext_flags) {
   Section* s;
   if (id == OBJ_SEC_NONE) return;
   s = Sections_at(&ob->sections, id);
   if (!s) return;
   s->ext_kind = (u16)ek;
   s->ext_type = ext_type;
   s->ext_flags = ext_flags;
 }
 
 /* A NOBITS section (.bss / .tbss) stores no bytes — only a size. decl.c and
  * obj_align_to already treat SEC_BSS this way regardless of sem; obj_write and
  * obj_pos must agree so the MCEmitter path (the standalone assembler's
  * `.zero`/`.skip` fills and label positions) advances and reports the bss_size
  * cursor instead of a byte buffer that the emitters then ignore. Codegen never
  * writes/positions a BSS section through these (it uses obj_reserve_bss and its
  * own counter), so this only affects the assembler's path. */
 static int sec_is_nobits(const Section* s) {
   return s->sem == SSEM_NOBITS || s->kind == SEC_BSS;
 }
 
 void obj_write(ObjBuilder* ob, ObjSecId id, const void* data, size_t n) {
   Section* s;
   if (id == OBJ_SEC_NONE) return;
   s = Sections_at(&ob->sections, id);
   if (!s) return;
   if (sec_is_nobits(s)) {
     s->bss_size += (u32)n; /* reserve zero-fill space; store nothing */
     return;
   }
   buf_write(&s->bytes, data, n);
 }
 
 /* See obj.h: the byte buffer for a PROGBITS section, NULL for NOBITS/.bss (so
  * the caller falls back to obj_write's bss_size path) or invalid ids. Lets the
  * MCEmitter hoist the per-emit Sections_at deref + nobits branch out of the hot
  * loop, re-resolving only at set_section. */
 Buf* obj_section_bytes(ObjBuilder* ob, ObjSecId id) {
   Section* s;
   if (id == OBJ_SEC_NONE) return NULL;
   s = Sections_at(&ob->sections, id);
   if (!s || sec_is_nobits(s)) return NULL;
   return &s->bytes;
 }
 
 u8* obj_reserve(ObjBuilder* ob, ObjSecId id, size_t n) {
   Section* s;
   if (id == OBJ_SEC_NONE) return NULL;
   s = Sections_at(&ob->sections, id);
   return s ? buf_reserve(&s->bytes, n) : NULL;
 }
 
 void obj_reserve_bss(ObjBuilder* ob, ObjSecId id, u32 size, u32 align) {
   Section* s;
   if (id == OBJ_SEC_NONE) return;
   s = Sections_at(&ob->sections, id);
   if (!s) return;
   s->bss_size = size;
   if (align) s->align = align;
 }
 
 u32 obj_align_to(ObjBuilder* ob, ObjSecId id, u32 align) {
   Section* s;
   u32 a, cur, base, pad;
   if (id == OBJ_SEC_NONE) return 0;
   s = Sections_at(&ob->sections, id);
   if (!s) return 0;
   a = align ? align : 1u;
   /* Treat SEC_BSS like NOBITS even when sem is the default PROGBITS —
    * decl.c creates .bss via the simple obj_section, but emit_macho /
    * emit_elf both route SEC_BSS through the zerofill path regardless
    * of sem, so the byte buf is ignored on output and only bss_size
    * matters. */
   if (s->sem == SSEM_NOBITS || s->kind == SEC_BSS) {
     base = (s->bss_size + (a - 1u)) & ~(a - 1u);
     s->bss_size = base;
     if (a > s->align) s->align = a;
     return base;
   }
   cur = buf_pos(&s->bytes);
   base = (cur + (a - 1u)) & ~(a - 1u);
   pad = base - cur;
   if (pad) {
     u8* p = buf_reserve(&s->bytes, pad);
     if (p) memset(p, 0, pad);
   }
   if (a > s->align) s->align = a;
   return base;
 }
 
 u32 obj_pos(ObjBuilder* ob, ObjSecId id) {
   Section* s;
   if (id == OBJ_SEC_NONE) return 0;
   s = Sections_at(&ob->sections, id);
   if (!s) return 0;
   return sec_is_nobits(s) ? s->bss_size : buf_pos(&s->bytes);
 }
 
 void obj_patch(ObjBuilder* ob, ObjSecId id, u32 ofs, const void* data,
                size_t n) {
   Section* s;
   if (id == OBJ_SEC_NONE) return;
   s = Sections_at(&ob->sections, id);
   if (s) buf_patch(&s->bytes, ofs, data, n);
 }
 
 static ObjSymId obj_symbol_make(ObjBuilder* ob, Sym name, SymBind bind,
                                 SymVis vis, SymKind kind, ObjSecId section_id,
                                 u64 value, u64 size, u64 common_align,
                                 int index_name) {
   u32 id;
   ObjSym* s = Symbols_push(&ob->symbols, &id);
   if (!s) return OBJ_SYM_NONE;
   s->name = name;
   s->bind = (u16)bind;
   s->kind = (u16)kind;
   s->vis = (u8)vis;
   s->ext_kind = OBJ_EXT_NONE;
   s->section_id = section_id;
   s->value = value;
   s->size = size;
   s->common_align = common_align;
   s->atom_subordinate = 0;
   /* First-wins: record the lowest id for this name so obj_symbol_find returns
    * the same symbol the linear scan would. Later same-name symbols (legal for
    * STB_LOCAL) do not overwrite. */
   if (index_name && name && !SymNameIndex_get(&ob->sym_by_name, name))
     (void)SymNameIndex_set(&ob->sym_by_name, name, (ObjSymId)id);
   return (ObjSymId)id;
 }
 
 ObjSymId obj_symbol(ObjBuilder* ob, Sym name, SymBind bind, SymKind kind,
                     ObjSecId section_id, u64 value, u64 size) {
   return obj_symbol_ex(ob, name, bind, SV_DEFAULT, kind, section_id, value,
                        size, 0);
 }
 
 ObjSymId obj_symbol_ex(ObjBuilder* ob, Sym name, SymBind bind, SymVis vis,
                        SymKind kind, ObjSecId section_id, u64 value, u64 size,
                        u64 common_align) {
   return obj_symbol_make(ob, name, bind, vis, kind, section_id, value, size,
                          common_align, 1);
 }
 
 ObjSymId obj_symbol_defer(ObjBuilder* ob, Sym name, SymBind bind, SymVis vis,
                           SymKind kind, u64 size) {
   ObjSymId id;
   ObjSym* s;
   id = obj_symbol_make(ob, name, bind, vis, kind, OBJ_SEC_NONE, 0, size, 0, 0);
   if (id == OBJ_SYM_NONE) return OBJ_SYM_NONE;
   s = Symbols_at(&ob->symbols, id);
   if (s) s->removed = 1;
   return id;
 }
 
 ObjSymId obj_symbol_find(ObjBuilder* ob, Sym name) {
   /* Authoritative O(1) lookup — never a linear scan. Normal/live symbols are
    * indexed when created or published, and obj_symbol_rename keeps the index
    * exact. Deferred symbols deliberately stay out of this map until published.
    */
   ObjSymId* hit;
   if (!ob || !name) return OBJ_SYM_NONE;
   hit = SymNameIndex_get(&ob->sym_by_name, name);
   return hit ? *hit : OBJ_SYM_NONE;
 }
 
 void obj_symbol_define(ObjBuilder* ob, ObjSymId id, ObjSecId section_id,
                        u64 value, u64 size) {
   ObjSym* s;
   if (id == OBJ_SYM_NONE) return;
   s = Symbols_at(&ob->symbols, id);
   if (!s) return;
   s->section_id = section_id;
   s->value = value;
   s->size = size;
   if (s->kind == SK_UNDEF) s->kind = SK_OBJ;
 }
 
 void obj_symbol_define_live(ObjBuilder* ob, ObjSymId id, ObjSecId section_id,
                             u64 value, u64 size) {
   ObjSym* s;
   ObjSymId* slot;
   obj_symbol_define(ob, id, section_id, value, size);
   if (!ob || id == OBJ_SYM_NONE) return;
   s = Symbols_at(&ob->symbols, id);
   if (!s) return;
   s->removed = 0;
   if (s->name) {
     slot = SymNameIndex_get(&ob->sym_by_name, s->name);
     if (!slot || *slot > id)
       (void)SymNameIndex_set(&ob->sym_by_name, s->name, id);
   }
 }
 
 void obj_symbol_set_flags(ObjBuilder* ob, ObjSymId id, u16 flags) {
   ObjSym* s;
   if (id == OBJ_SYM_NONE) return;
   s = Symbols_at(&ob->symbols, id);
   if (!s) return;
   s->flags = flags;
 }
 
 void obj_symbol_set_atom_subordinate(ObjBuilder* ob, ObjSymId id,
                                      int subordinate) {
   ObjSym* s;
   if (id == OBJ_SYM_NONE) return;
   s = Symbols_at(&ob->symbols, id);
   if (!s) return;
   s->atom_subordinate = subordinate ? 1u : 0u;
 }
 
 void obj_reloc(ObjBuilder* ob, ObjSecId section_id, u32 offset, RelocKind kind,
                ObjSymId sym, i64 addend) {
   obj_reloc_ex(ob, section_id, offset, kind, sym, addend, 1, 0);
 }
 
 void obj_reloc_ex(ObjBuilder* ob, ObjSecId section_id, u32 offset,
                   RelocKind kind, ObjSymId sym, i64 addend, int explicit_addend,
                   int pair) {
   Reloc* r = Relocs_push(&ob->relocs, NULL);
   if (!r) return;
   r->section_id = section_id;
   r->offset = offset;
   r->kind = (u16)kind;
   r->has_explicit_addend = (u8)(explicit_addend ? 1 : 0);
   r->pair = (u8)pair;
   r->sym = sym;
   r->addend = addend;
   ob->reloc_index_dirty = 1; /* invalidate the per-section reloc index */
   /* Any reloc against this symbol is enough to retain it through the
    * emit-time UNDEF prune. See ObjSym::referenced. */
   obj_sym_mark_referenced(ob, sym);
 }
 
 void obj_sym_mark_referenced(ObjBuilder* ob, ObjSymId id) {
   ObjSym* s;
   if (id == OBJ_SYM_NONE) return;
   s = Symbols_at(&ob->symbols, id);
   if (s) s->referenced = 1;
 }
 
 void obj_sym_set_referenced(ObjBuilder* ob, ObjSymId id, int referenced) {
   ObjSym* s;
   if (id == OBJ_SYM_NONE) return;
   s = Symbols_at(&ob->symbols, id);
   if (s) s->referenced = referenced ? 1u : 0u;
 }
 
 ObjAtomId obj_atom_define(ObjBuilder* ob, ObjSecId section_id, u32 offset,
                           u32 size, ObjSymId signature, u32 flags) {
   u32 id;
   ObjAtom* a;
   if (!ob || section_id == OBJ_SEC_NONE) return OBJ_ATOM_NONE;
   a = Atoms_push(&ob->atoms, &id);
   if (!a) return OBJ_ATOM_NONE;
   a->section_id = section_id;
   a->offset = offset;
   a->size = size;
   a->signature = signature;
   a->flags = flags;
   return (ObjAtomId)id;
 }
 
 ObjGroupId obj_group(ObjBuilder* ob, Sym name, ObjSymId signature, u32 flags) {
   u32 id;
   ObjGroup* g = Groups_push(&ob->groups, &id);
   if (!g) return OBJ_GROUP_NONE;
   g->name = name;
   g->signature = signature;
   g->flags = flags;
   return (ObjGroupId)id;
 }
 
 void obj_group_add_section(ObjBuilder* ob, ObjGroupId gid, ObjSecId sec) {
   ObjGroup* g;
   ObjSecId* p;
   if (gid == OBJ_GROUP_NONE) return;
   g = Groups_at(&ob->groups, gid);
   if (!g) return;
   /* Linear realloc — group section counts are tiny (handful per group). */
   p = (ObjSecId*)ob->heap->realloc(
       ob->heap, g->sections, sizeof(ObjSecId) * g->nsections,
       sizeof(ObjSecId) * (g->nsections + 1), _Alignof(ObjSecId));
   if (!p) return;
   p[g->nsections++] = sec;
   g->sections = p;
 }
 
 void obj_finalize(ObjBuilder* ob) {
   /* No flat-offset patching needed yet — section bytes are read out via
    * buf_flatten on demand by emitters. Keep this hook in place: when a
    * future writer wants intra-section fixups (e.g. label-to-offset
    * resolution after the full section is written), this is where they
    * land. */
   (void)ob;
 }
 
 /* ---- mutators (strip / objcopy support) ---- */
 
 void obj_section_remove(ObjBuilder* ob, ObjSecId id) {
   Section* s;
   if (!ob || id == OBJ_SEC_NONE) return;
   s = Sections_at(&ob->sections, id);
   if (!s) return;
   s->removed = 1;
 }
 
 void obj_symbol_remove(ObjBuilder* ob, ObjSymId id) {
   ObjSym* s;
   if (!ob || id == OBJ_SYM_NONE) return;
   s = Symbols_at(&ob->symbols, id);
   if (!s) return;
   s->removed = 1;
 }
 
 void obj_group_remove(ObjBuilder* ob, ObjGroupId id) {
   ObjGroup* g;
   if (!ob || id == OBJ_GROUP_NONE) return;
   g = Groups_at(&ob->groups, id);
   if (!g) return;
   g->removed = 1;
 }
 
 void obj_section_rename(ObjBuilder* ob, ObjSecId id, Sym new_name) {
   Section* s;
   if (!ob || id == OBJ_SEC_NONE) return;
   s = Sections_at(&ob->sections, id);
   if (!s) return;
   s->name = new_name;
 }
 
 void obj_symbol_rename(ObjBuilder* ob, ObjSymId id, Sym new_name) {
   ObjSym* s;
   Sym old;
   ObjSymId* slot;
   if (!ob || id == OBJ_SYM_NONE) return;
   s = Symbols_at(&ob->symbols, id);
   if (!s) return;
   old = s->name;
   s->name = new_name;
   if (old == new_name) return;
   /* Keep the name index exact so obj_symbol_find stays a pure hash lookup.
    * If this symbol was the indexed entry for its old name, hand the entry to
    * the next-lowest symbol still carrying that name (duplicate STB_LOCAL names
    * are legal), or drop it. This is the only scan in the symbol-index path and
    * it is confined to obj_symbol_rename — a cold objcopy-style operation, never
    * the codegen/find hot path. */
   if (old) {
     slot = SymNameIndex_get(&ob->sym_by_name, old);
     if (slot && *slot == id) {
       ObjSymId repl = OBJ_SYM_NONE;
       u32 n = Symbols_count(&ob->symbols);
       for (u32 i = 1; i < n; ++i) {
         ObjSym* t = Symbols_at(&ob->symbols, i);
         if (t && (ObjSymId)i != id && t->name == old) {
           repl = (ObjSymId)i;
           break;
         }
       }
       if (repl != OBJ_SYM_NONE)
         (void)SymNameIndex_set(&ob->sym_by_name, old, repl);
       else
         SymNameIndex_del(&ob->sym_by_name, old);
     }
   }
   /* new_name resolves to the lowest id that carries it (first-match order). A
    * rename can give an existing lower-id symbol this name, so lower an existing
    * entry when warranted. */
   if (new_name) {
     slot = SymNameIndex_get(&ob->sym_by_name, new_name);
     if (!slot || *slot > id)
       (void)SymNameIndex_set(&ob->sym_by_name, new_name, id);
   }
 }
 
 void obj_symbol_set_bind(ObjBuilder* ob, ObjSymId id, SymBind bind) {
   ObjSym* s;
   if (!ob || id == OBJ_SYM_NONE) return;
   s = Symbols_at(&ob->symbols, id);
   if (!s) return;
   s->bind = (u16)bind;
 }
 
 void obj_symbol_set_vis(ObjBuilder* ob, ObjSymId id, SymVis vis) {
   ObjSym* s;
   if (!ob || id == OBJ_SYM_NONE) return;
   s = Symbols_at(&ob->symbols, id);
   if (!s) return;
   s->vis = (u8)vis;
 }
 
 void obj_section_replace_bytes(ObjBuilder* ob, ObjSecId id, const u8* data,
                                size_t n) {
   Section* s;
   if (!ob || id == OBJ_SEC_NONE) return;
   s = Sections_at(&ob->sections, id);
   if (!s) return;
   /* Drop the old chunked Buf and reinitialize empty, then write the new
    * bytes. Cheaper than scanning + patching when the replacement is
    * different-sized — which it usually is (objcopy --update-section). */
   buf_fini(&s->bytes);
   buf_init(&s->bytes, ob->heap);
   s->bss_size = 0;
   if (data && n) buf_write(&s->bytes, data, n);
 }
 
 void obj_sweep_dead(ObjBuilder* ob) {
   u32 nsec = Sections_count(&ob->sections);
   u32 nsym = Symbols_count(&ob->symbols);
   u32 nrel = Relocs_count(&ob->relocs);
   u32 ngrp = Groups_count(&ob->groups);
   u32 i;
 
   /* Pass 1: cascade removed sections into their defining symbols. Also
    * absorbs the historical UNDEF-prune predicate: any non-referenced
    * global/weak symbol that lacks a defining section (and isn't an ABS
    * or COMMON definition, both of which legitimately have section_id ==
    * OBJ_SEC_NONE) is a spurious extern from a header — drop it.
    *
    * The "no defining section" test matches macho_emit's sym_is_undef,
    * which is stronger than `kind == SK_UNDEF`: frontends mint SK_OBJ /
    * SK_TLS / SK_FUNC entries for extern decls and only set them to
    * SK_UNDEF for true references, so checking section_id catches both. */
   for (i = 1; i < nsym; ++i) {
     ObjSym* s = Symbols_at(&ob->symbols, i);
     if (!s || s->removed) continue;
     if (s->section_id != OBJ_SEC_NONE) {
       const Section* sec = Sections_at(&ob->sections, s->section_id);
       if (sec && sec->removed) {
         s->removed = 1;
         continue;
       }
     }
     if (s->section_id == OBJ_SEC_NONE && s->kind != SK_ABS &&
         s->kind != SK_COMMON && !s->referenced &&
         (s->bind == SB_GLOBAL || s->bind == SB_WEAK)) {
       s->removed = 1;
     }
   }
 
   /* Pass 2: drop relocs that became dangling. A reloc is dead if its
    * containing section, its target symbol, or the symbol's defining
    * section is gone. */
   for (i = 0; i < nrel; ++i) {
     Reloc* r = Relocs_at(&ob->relocs, i);
     if (!r || r->removed) continue;
     if (r->section_id != OBJ_SEC_NONE) {
       const Section* sec = Sections_at(&ob->sections, r->section_id);
       if (!sec || sec->removed) {
         r->removed = 1;
         continue;
       }
     }
     if (r->sym != OBJ_SYM_NONE) {
       const ObjSym* ts = Symbols_at(&ob->symbols, r->sym);
       if (!ts || ts->removed) r->removed = 1;
     }
   }
 
   {
     u32 natom = Atoms_count(&ob->atoms);
     for (i = 1; i < natom; ++i) {
       ObjAtom* a = Atoms_at(&ob->atoms, i);
       const Section* sec;
       const ObjSym* sig;
       if (!a || a->removed) continue;
       sec = Sections_at(&ob->sections, a->section_id);
       if (!sec || sec->removed) {
         a->removed = 1;
         continue;
       }
       if (a->signature != OBJ_SYM_NONE) {
         sig = Symbols_at(&ob->symbols, a->signature);
         if (!sig || sig->removed) a->removed = 1;
       }
     }
   }
 
   /* Pass 3: compact each group's member list to drop removed sections;
    * tombstone the group if its list empties out or its signature symbol
    * is removed. Member list is rewritten in place — the storage stays
    * the same size, the trailing slots just become unused. */
   for (i = 1; i < ngrp; ++i) {
     ObjGroup* g = Groups_at(&ob->groups, i);
     u32 w, r;
     if (!g || g->removed) continue;
     if (g->signature != OBJ_SYM_NONE) {
       const ObjSym* sig = Symbols_at(&ob->symbols, g->signature);
       if (!sig || sig->removed) {
         g->removed = 1;
         continue;
       }
     }
     w = 0;
     for (r = 0; r < g->nsections; ++r) {
       ObjSecId sid = g->sections[r];
       const Section* sec =
           (sid != OBJ_SEC_NONE) ? Sections_at(&ob->sections, sid) : NULL;
       if (sec && !sec->removed) g->sections[w++] = sid;
     }
     g->nsections = w;
     if (w == 0) g->removed = 1;
   }
 
   /* Pass 4: clear Section.link if it now points at a removed section.
    * (Section.info is type-dependent — leave it to the emitter, which
    * already inspects the sem to interpret it.) */
   for (i = 1; i < nsec; ++i) {
     Section* s = Sections_at(&ob->sections, i);
     if (!s || s->removed) continue;
     if (s->link != OBJ_SEC_NONE) {
       const Section* lk = Sections_at(&ob->sections, s->link);
       if (!lk || lk->removed) s->link = OBJ_SEC_NONE;
     }
   }
 
   /* Removed flags changed — the per-section reloc index must rebuild. */
   ob->reloc_index_dirty = 1;
 }
 
 /* ---- read side ---- */
 
 /* (Re)build the per-section reloc index: a counting sort of the live relocs
  * keyed by section_id, preserving ascending global order within each section.
  * O(n_relocs + n_sections). Idempotent while the index stays clean; callers
  * reach it through obj_reloc_count / obj_reloc_section. Cast away const at the
  * call sites — the index is a lazily-filled cache, not logical state. */
 static void obj_reloc_index_ensure(ObjBuilder* ob) {
   u32 nsec, total, i, nlive;
   u32* off;
   if (ob->reloc_index_off && !ob->reloc_index_dirty) return;
   nsec = Sections_count(&ob->sections);
   total = Relocs_count(&ob->relocs);
 
   if (!ob->reloc_index_off || ob->reloc_index_nsec != nsec) {
     if (ob->reloc_index_off)
       ob->heap->free(ob->heap, ob->reloc_index_off,
                      sizeof(u32) * (ob->reloc_index_nsec + 1u));
     off = (u32*)ob->heap->alloc(ob->heap, sizeof(u32) * (nsec + 1u),
                                 _Alignof(u32));
     ob->reloc_index_off = off;
     ob->reloc_index_nsec = nsec;
   } else {
     off = ob->reloc_index_off;
   }
   memset(off, 0, sizeof(u32) * (nsec + 1u));
 
   /* Pass 1: tally live relocs into off[section_id + 1]. */
   nlive = 0;
   for (i = 0; i < total; ++i) {
     const Reloc* r = Relocs_at(&ob->relocs, i);
     if (r->removed) continue;
     ++off[r->section_id + 1u];
     ++nlive;
   }
   /* Prefix-sum: off[s] = start of section s's run; off[nsec] = nlive. */
   for (i = 1; i <= nsec; ++i) off[i] += off[i - 1u];
 
   if (!ob->reloc_index || ob->reloc_index_len != nlive) {
     if (ob->reloc_index)
       ob->heap->free(ob->heap, ob->reloc_index,
                      sizeof(u32) * ob->reloc_index_len);
     ob->reloc_index = nlive ? (u32*)ob->heap->alloc(
                                   ob->heap, sizeof(u32) * nlive, _Alignof(u32))
                             : NULL;
     ob->reloc_index_len = nlive;
   }
 
   /* Pass 2: scatter global indices into per-section runs. A heap-temp cursor
    * (seeded from off[]) keeps the prefix offsets intact for the readers. */
   if (nlive) {
     u32* cur = (u32*)ob->heap->alloc(ob->heap, sizeof(u32) * (nsec + 1u),
                                      _Alignof(u32));
     memcpy(cur, off, sizeof(u32) * (nsec + 1u));
     for (i = 0; i < total; ++i) {
       const Reloc* r = Relocs_at(&ob->relocs, i);
       if (r->removed) continue;
       ob->reloc_index[cur[r->section_id]++] = i;
     }
     ob->heap->free(ob->heap, cur, sizeof(u32) * (nsec + 1u));
   }
   ob->reloc_index_dirty = 0;
 }
 
 u32 obj_section_count(const ObjBuilder* ob) {
   return Sections_count(&ob->sections);
 }
 
 const Section* obj_section_get(const ObjBuilder* ob, ObjSecId id) {
   if (id == OBJ_SEC_NONE) return NULL;
   return Sections_at(&ob->sections, id);
 }
 
 u32 obj_reloc_count(const ObjBuilder* ob, ObjSecId id) {
   obj_reloc_index_ensure((ObjBuilder*)ob);
   if (id >= ob->reloc_index_nsec) return 0;
   return ob->reloc_index_off[id + 1u] - ob->reloc_index_off[id];
 }
 
 const u32* obj_reloc_section(const ObjBuilder* ob, ObjSecId id, u32* out_len) {
   obj_reloc_index_ensure((ObjBuilder*)ob);
   if (id >= ob->reloc_index_nsec) {
     if (out_len) *out_len = 0;
     return NULL;
   }
   if (out_len)
     *out_len = ob->reloc_index_off[id + 1u] - ob->reloc_index_off[id];
   return ob->reloc_index + ob->reloc_index_off[id];
 }
 
 u32 obj_reloc_total(const ObjBuilder* ob) { return Relocs_count(&ob->relocs); }
 
 const Reloc* obj_reloc_at(const ObjBuilder* ob, u32 idx) {
   return Relocs_at(&ob->relocs, idx);
 }
 
 const ObjSym* obj_symbol_get(const ObjBuilder* ob, ObjSymId id) {
   if (id == OBJ_SYM_NONE) return NULL;
   return Symbols_at(&ob->symbols, id);
 }
 
 u32 obj_atom_count(const ObjBuilder* ob) { return Atoms_count(&ob->atoms); }
 
 const ObjAtom* obj_atom_get(const ObjBuilder* ob, ObjAtomId id) {
   if (id == OBJ_ATOM_NONE) return NULL;
   return Atoms_at(&ob->atoms, id);
 }
 
 int obj_section_has_atoms(const ObjBuilder* ob, ObjSecId sid) {
   u32 n;
   if (!ob || sid == OBJ_SEC_NONE) return 0;
   n = Atoms_count(&ob->atoms);
   for (u32 i = 1; i < n; ++i) {
     const ObjAtom* a = Atoms_at(&ob->atoms, i);
     if (a && !a->removed && a->section_id == sid) return 1;
   }
   return 0;
 }
 
 ObjAtomId obj_atom_find(const ObjBuilder* ob, ObjSecId sid, u32 offset) {
   u32 n;
   if (!ob || sid == OBJ_SEC_NONE) return OBJ_ATOM_NONE;
   n = Atoms_count(&ob->atoms);
   for (u32 i = 1; i < n; ++i) {
     const ObjAtom* a = Atoms_at(&ob->atoms, i);
     u64 begin, end;
     if (!a || a->removed || a->section_id != sid) continue;
     begin = a->offset;
     end = begin + a->size;
     if (a->size != 0 && (u64)offset >= begin && (u64)offset < end)
       return (ObjAtomId)i;
   }
   for (u32 i = 1; i < n; ++i) {
     const ObjAtom* a = Atoms_at(&ob->atoms, i);
     if (!a || a->removed || a->section_id != sid) continue;
     if (a->size == 0 && offset == a->offset) return (ObjAtomId)i;
   }
   return OBJ_ATOM_NONE;
 }
 
 ObjAtomId obj_atom_find_symbol(const ObjBuilder* ob, ObjSymId sym) {
   const ObjSym* s;
   ObjAtomId aid;
   u32 n;
   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 = obj_atom_find(ob, s->section_id, (u32)s->value);
   if (aid != OBJ_ATOM_NONE) return aid;
   n = Atoms_count(&ob->atoms);
   for (u32 i = 1; i < n; ++i) {
     const ObjAtom* a = Atoms_at(&ob->atoms, i);
     if (a && !a->removed && a->signature == sym) return (ObjAtomId)i;
   }
   return OBJ_ATOM_NONE;
 }
 
 u32 obj_group_count(const ObjBuilder* ob) { return Groups_count(&ob->groups); }
 
 const ObjGroup* obj_group_get(const ObjBuilder* ob, ObjGroupId id) {
   if (id == OBJ_GROUP_NONE) return NULL;
   return Groups_at(&ob->groups, id);
 }
 
 ObjSymIter* obj_symiter_new(const ObjBuilder* ob) {
   ObjSymIter* it =
       (ObjSymIter*)ob->heap->alloc(ob->heap, sizeof(*it), _Alignof(ObjSymIter));
   if (!it) return NULL;
   it->ob = ob;
   it->idx = 1; /* skip the id-0 sentinel */
   return it;
 }
 
 int obj_symiter_next(ObjSymIter* it, ObjSymEntry* out) {
   const ObjSym* s;
   if (!it) return 0;
   s = Symbols_at(&it->ob->symbols, it->idx);
   if (!s) return 0;
   out->id = it->idx;
   out->sym = s;
   it->idx++;
   return 1;
 }
 
 void obj_symiter_free(ObjSymIter* it) {
   if (!it) return;
   ((Heap*)it->ob->heap)->free((Heap*)it->ob->heap, it, sizeof(*it));
 }
 
 struct ObjGroupIter {
   const ObjBuilder* ob;
   u32 idx; /* next index to return */
 };
 
 ObjGroupIter* obj_groupiter_new(const ObjBuilder* ob) {
   ObjGroupIter* it = (ObjGroupIter*)ob->heap->alloc(ob->heap, sizeof(*it),
                                                     _Alignof(ObjGroupIter));
   if (!it) return NULL;
   it->ob = ob;
   it->idx = 1; /* skip the id-0 sentinel */
   return it;
 }
 
 int obj_groupiter_next(ObjGroupIter* it, ObjGroupEntry* out) {
   const ObjGroup* g;
   if (!it) return 0;
   g = Groups_at(&it->ob->groups, it->idx);
   if (!g) return 0;
   out->id = it->idx;
   out->group = g;
   it->idx++;
   return 1;
 }
 
 void obj_groupiter_free(ObjGroupIter* it) {
   if (!it) return;
   ((Heap*)it->ob->heap)->free((Heap*)it->ob->heap, it, sizeof(*it));
 }
 
 /* Diagnostic spelling for a RelocKind. Drops the leading R_ from the enum
  * spelling so output reads like "RV_CALL" / "AARCH64_CALL26" — the same
  * spelling GNU objdump uses minus its arch prefix. */
 const char* reloc_kind_name(RelocKind k) {
   switch (k) {
 #define _CASE(name) \
   case name:        \
     return &(#name)[2] /* strip "R_" */
     _CASE(R_NONE);
     _CASE(R_ABS32);
     _CASE(R_ABS64);
     _CASE(R_REL32);
     _CASE(R_REL64);
     _CASE(R_PC32);
     _CASE(R_PC64);
     _CASE(R_GOT32);
     _CASE(R_PLT32);
     _CASE(R_ABS8);
     _CASE(R_ABS16);
     _CASE(R_PREL16);
     _CASE(R_TPOFF64);
     _CASE(R_AARCH64_ADR_GOT_PAGE);
     _CASE(R_AARCH64_LD64_GOT_LO12_NC);
     _CASE(R_AARCH64_JUMP26);
     _CASE(R_AARCH64_CALL26);
     _CASE(R_AARCH64_CONDBR19);
     _CASE(R_AARCH64_TSTBR14);
     _CASE(R_AARCH64_LD_PREL_LO19);
     _CASE(R_AARCH64_ADR_PREL_LO21);
     _CASE(R_AARCH64_INTRA_LABEL_ADDR);
     _CASE(R_AARCH64_ADR_PREL_PG_HI21);
     _CASE(R_AARCH64_ADR_PREL_PG_HI21_NC);
     _CASE(R_AARCH64_ADD_ABS_LO12_NC);
     _CASE(R_AARCH64_LDST8_ABS_LO12_NC);
     _CASE(R_AARCH64_LDST16_ABS_LO12_NC);
     _CASE(R_AARCH64_LDST32_ABS_LO12_NC);
     _CASE(R_AARCH64_LDST64_ABS_LO12_NC);
     _CASE(R_AARCH64_LDST128_ABS_LO12_NC);
     _CASE(R_AARCH64_TLVP_LOAD_PAGE21);
     _CASE(R_AARCH64_TLVP_LOAD_PAGEOFF12);
     _CASE(R_AARCH64_TLSLE_ADD_TPREL_HI12);
     _CASE(R_AARCH64_TLSLE_ADD_TPREL_LO12);
     _CASE(R_AARCH64_TLSLE_ADD_TPREL_LO12_NC);
     _CASE(R_AARCH64_TLSLE_LDST8_TPREL_LO12);
     _CASE(R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC);
     _CASE(R_AARCH64_TLSLE_LDST16_TPREL_LO12);
     _CASE(R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC);
     _CASE(R_AARCH64_TLSLE_LDST32_TPREL_LO12);
     _CASE(R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC);
     _CASE(R_AARCH64_TLSLE_LDST64_TPREL_LO12);
     _CASE(R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC);
     _CASE(R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21);
     _CASE(R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC);
     _CASE(R_COFF_ADDR32NB);
     _CASE(R_AARCH64_POINTER_TO_GOT);
     _CASE(R_AARCH64_TLSDESC_ADR_PAGE21);
     _CASE(R_AARCH64_TLSDESC_LD64_LO12);
     _CASE(R_AARCH64_TLSDESC_ADD_LO12);
     _CASE(R_AARCH64_TLSDESC_CALL);
     _CASE(R_RV_TLS_GD_HI20);
     _CASE(R_AARCH64_GLOB_DAT);
     _CASE(R_AARCH64_JUMP_SLOT);
     _CASE(R_AARCH64_RELATIVE);
     _CASE(R_AARCH64_COPY);
     _CASE(R_X64_PC8);
     _CASE(R_X64_32S);
     _CASE(R_X64_PLT32);
     _CASE(R_X64_GOTPCREL);
     _CASE(R_X64_GOTPCRELX);
     _CASE(R_X64_REX_GOTPCRELX);
     _CASE(R_X64_GOTPC32);
     _CASE(R_X64_GOTOFF64);
     _CASE(R_X64_TPOFF32);
     _CASE(R_X64_DTPOFF32);
     _CASE(R_X64_DTPMOD64);
     _CASE(R_X64_DTPOFF64);
     _CASE(R_X64_TLSGD);
     _CASE(R_X64_TLSLD);
     _CASE(R_X64_GOTTPOFF);
     _CASE(R_X64_GLOB_DAT);
     _CASE(R_X64_JUMP_SLOT);
     _CASE(R_X64_RELATIVE);
     _CASE(R_X64_COPY);
     _CASE(R_X64_TLV);
     _CASE(R_RV_HI20);
     _CASE(R_RV_LO12_I);
     _CASE(R_RV_LO12_S);
     _CASE(R_RV_BRANCH);
     _CASE(R_RV_JAL);
     _CASE(R_RV_CALL);
     _CASE(R_RV_PCREL_HI20);
     _CASE(R_RV_PCREL_LO12_I);
     _CASE(R_RV_PCREL_LO12_S);
     _CASE(R_RV_INTRA_AUIPC_ADDI);
     _CASE(R_RV_GOT_HI20);
     _CASE(R_RV_TLS_GOT_HI20);
     _CASE(R_RV_TPREL_HI20);
     _CASE(R_RV_TPREL_LO12_I);
     _CASE(R_RV_TPREL_LO12_S);
     _CASE(R_RV_TPREL_ADD);
     _CASE(R_ADD8);
     _CASE(R_ADD16);
     _CASE(R_ADD32);
     _CASE(R_ADD64);
     _CASE(R_SUB8);
     _CASE(R_SUB16);
     _CASE(R_SUB32);
     _CASE(R_SUB64);
     _CASE(R_RV_ALIGN);
     _CASE(R_RV_RVC_BRANCH);
     _CASE(R_RV_RVC_JUMP);
     _CASE(R_RV_RELAX);
     _CASE(R_SUB6);
     _CASE(R_SET6);
     _CASE(R_SET_ULEB128);
     _CASE(R_SUB_ULEB128);
     _CASE(R_WASM_FUNCIDX);
     _CASE(R_WASM_TABLEIDX);
     _CASE(R_WASM_MEMOFS);
     _CASE(R_WASM_TYPEIDX);
     _CASE(R_COFF_SECREL);
     _CASE(R_COFF_SECTION);
     _CASE(R_COFF_AARCH64_SECREL_LOW12A);
     _CASE(R_COFF_AARCH64_SECREL_HIGH12A);
     _CASE(R_COFF_AARCH64_SECREL_LOW12L);
     _CASE(R_ARM_THM_CALL);
     _CASE(R_ARM_THM_JUMP24);
     _CASE(R_ARM_THM_JUMP19);
     _CASE(R_ARM_THM_MOVW_ABS_NC);
     _CASE(R_ARM_THM_MOVT_ABS);
     _CASE(R_ARM_THM_MOVW_PREL_NC);
     _CASE(R_ARM_THM_MOVT_PREL);
     _CASE(R_ARM_TLS_LE32);
 #undef _CASE
   }
   return "UNKNOWN";
 }
 
 /* ---- shared string-table builder (see obj.h ObjStrtab) ------------------ */
 
 static u32 obj_strtab_hash(const char* s, u32 len) {
   u32 h = 2166136261u; /* FNV-1a */
   for (u32 i = 0; i < len; ++i) {
     h ^= (u8)s[i];
     h *= 16777619u;
   }
   return h;
 }
 
 void obj_strtab_init(ObjStrtab* t, Heap* h, int dedup) {
   memset(t, 0, sizeof *t);
   t->heap = h;
   t->dedup = dedup ? 1u : 0u;
 }
 
 static void obj_strtab_reserve(ObjStrtab* t, u32 extra) {
   u32 ncap;
   u8* nd;
   if (t->len + extra <= t->cap) return;
   ncap = t->cap ? t->cap : 256u;
   while (t->len + extra > ncap) ncap *= 2u;
   nd = (u8*)t->heap->alloc(t->heap, ncap, 1);
   if (t->data) {
     memcpy(nd, t->data, t->len);
     t->heap->free(t->heap, t->data, t->cap);
   }
   t->data = nd;
   t->cap = ncap;
 }
 
 void obj_strtab_put_raw(ObjStrtab* t, const void* bytes, u32 n) {
   if (!n) return;
   obj_strtab_reserve(t, n);
   memcpy(t->data + t->len, bytes, n);
   t->len += n;
 }
 
 static void obj_strtab_index_grow(ObjStrtab* t) {
   u32 ncap = t->scap ? t->scap * 2u : 256u;
   u32 mask = ncap - 1u;
   ObjStrtabEnt* ns = (ObjStrtabEnt*)t->heap->alloc(t->heap, sizeof(*ns) * ncap,
                                                    _Alignof(ObjStrtabEnt));
   memset(ns, 0, sizeof(*ns) * ncap);
   for (u32 i = 0; i < t->scap; ++i) {
     u32 j;
     if (!t->slots[i].len) continue;
     j = t->slots[i].hash & mask;
     while (ns[j].len) j = (j + 1u) & mask;
     ns[j] = t->slots[i];
   }
   if (t->slots) t->heap->free(t->heap, t->slots, sizeof(*t->slots) * t->scap);
   t->slots = ns;
   t->scap = ncap;
 }
 
 static u32 obj_strtab_append(ObjStrtab* t, const char* s, u32 len) {
   u32 off = t->len;
   obj_strtab_reserve(t, len + 1u);
   memcpy(t->data + off, s, len);
   t->data[off + len] = 0;
   t->len += len + 1u;
   return off;
 }
 
 u32 obj_strtab_add(ObjStrtab* t, const char* s, u32 len) {
   u32 h, mask, j, off;
   if (len == 0) return 0;
   if (!t->dedup) return obj_strtab_append(t, s, len);
   if ((t->sused + 1u) * 4u >= t->scap * 3u) obj_strtab_index_grow(t);
   h = obj_strtab_hash(s, len);
   mask = t->scap - 1u;
   j = h & mask;
   while (t->slots[j].len) {
     ObjStrtabEnt* e = &t->slots[j];
     if (e->hash == h && e->len == len && memcmp(t->data + e->off, s, len) == 0)
       return e->off;
     j = (j + 1u) & mask;
   }
   off = obj_strtab_append(t, s, len);
   t->slots[j].hash = h;
   t->slots[j].off = off;
   t->slots[j].len = len;
   t->sused++;
   return off;
 }
 
 u32 obj_strtab_size(const ObjStrtab* t) { return t->len; }
 u8* obj_strtab_data(ObjStrtab* t) { return t->data; }
 
 void obj_strtab_fini(ObjStrtab* t) {
   if (t->data) t->heap->free(t->heap, t->data, t->cap);
   if (t->slots) t->heap->free(t->heap, t->slots, sizeof(*t->slots) * t->scap);
   memset(t, 0, sizeof *t);
 }