kit

emit.c (30742B)

---

 /* Mach-O MH_OBJECT writer.  Walks a finalized ObjBuilder and emits a
  * 64-bit little-endian relocatable object via the supplied Writer.
  *
  * Layout strategy (MH_OBJECT — everything in one anonymous segment):
  *   1. plan Mach-O sections (one per non-symtab/strtab/rela ObjSection),
  *      mapping kit section names to (segname, sectname) pairs;
  *   2. partition ObjSyms into local / extdef / undef and assign final
  *      indices for LC_DYSYMTAB;
  *   3. build per-section relocation tables via the per-arch translator
  *      (only aarch64 is wired today);
  *   4. assign file offsets sequentially: header, load commands, section
  *      bytes, relocation tables, symbol table, string table;
  *   5. write header → load commands → section bytes → relocs → symtab
  *      → strtab.
  *
  * 64-bit little-endian only.  Big-endian / 32-bit panics at entry.
  *
  * Round-trip invariant: read_macho of
  * this output must produce an ObjBuilder shape-equivalent to the input,
  * modulo (a) Mach-O's mandatory (segname, sectname) pairing and (b)
  * any synthesized N_SECT symbols.  The (segname,sectname) form chosen
  * here is the canonical post-roundtrip shape — read_macho stores the
  * comma-joined "__SEG,__sect" form in Section.name so a re-emit
  * produces the same bytes. */
 
 #include <string.h>
 
 #include "core/arena.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 "obj/format.h"
 #include "obj/macho/macho.h"
 
 /* ---- LE writer helpers (Writer-based) ----
  * Thin aliases onto the shared writer_u*_le helpers (core/bytes.h). */
 
 #define wr_u32 writer_u32_le
 #define wr_u64 writer_u64_le
 
 static void wr_name16(Writer* w, const char* s, u32 len) {
   /* Mach-O section/segment names are 16-byte zero-padded fields.  Names
    * longer than 16 are truncated; the on-disk format leaves no room for
    * a longer encoding. */
   u8 buf[16];
   u32 n = len > 16 ? 16 : len;
   memcpy(buf, s, n);
   if (n < 16) memset(buf + n, 0, 16 - n);
   kit_writer_write(w, buf, 16);
 }
 
 /* ---- (segname,sectname) derivation ---- */
 
 /* Split a kit section name into Mach-O (segname, sectname) pair.
  * If `name` contains a comma, it is treated as already in
  * "__SEG,__sect" form and split at the first comma.  Otherwise we
  * derive the pair from SecKind, ignoring `name` (the input was an
  * ELF-shaped name like ".text" or ".rodata"). */
 typedef struct MSegSect {
   char segname[16];
   char sectname[16];
   u32 seg_len;
   u32 sect_len;
 } MSegSect;
 
 static void copy_fixed16(char* dst, u32* len_out, const char* src,
                          u32 src_len) {
   u32 n = src_len > 16 ? 16 : src_len;
   memcpy(dst, src, n);
   if (n < 16) memset(dst + n, 0, 16 - n);
   *len_out = n;
 }
 
 static void name_to_seg_sect(const char* name, u32 nlen, u16 sec_kind,
                              MSegSect* out) {
   /* Comma-separated form: take prefix as segname, suffix as sectname. */
   for (u32 i = 0; i < nlen; ++i) {
     if (name[i] == ',') {
       copy_fixed16(out->segname, &out->seg_len, name, i);
       copy_fixed16(out->sectname, &out->sect_len, name + i + 1, nlen - i - 1);
       return;
     }
   }
 
   /* Not comma-separated.  Derive from SecKind; ignore `name`. */
   const char* seg;
   const char* sect;
   switch (sec_kind) {
     case SEC_TEXT:
       seg = "__TEXT";
       sect = "__text";
       break;
     case SEC_RODATA:
       seg = "__TEXT";
       sect = "__const";
       break;
     case SEC_DATA:
       seg = "__DATA";
       sect = "__data";
       break;
     case SEC_BSS:
       seg = "__DATA";
       sect = "__bss";
       break;
     case SEC_DEBUG: {
       /* ".debug_*" → "__DWARF,__debug_*" (truncated to Mach-O's 16-byte
        * sectname, matching Apple's spelling). Shared with the DWARF
        * reader so the names round-trip. Any non-".debug_*" SEC_DEBUG
        * name falls back to the leading-dot strip. */
       char ds[17];
       seg = "__DWARF";
       copy_fixed16(out->segname, &out->seg_len, seg,
                    (u32)slice_from_cstr(seg).len);
       if (obj_macho_debug_sectname(name, nlen, ds)) {
         copy_fixed16(out->sectname, &out->sect_len, ds,
                      (u32)slice_from_cstr(ds).len);
       } else {
         sect = (nlen && name[0] == '.') ? name + 1 : name;
         copy_fixed16(out->sectname, &out->sect_len, sect,
                      (u32)((nlen && name[0] == '.') ? nlen - 1 : nlen));
       }
       return;
     }
     default:
       seg = "__DATA";
       sect = "__data";
       break;
   }
   copy_fixed16(out->segname, &out->seg_len, seg, (u32)slice_from_cstr(seg).len);
   copy_fixed16(out->sectname, &out->sect_len, sect,
                (u32)slice_from_cstr(sect).len);
 }
 
 /* ---- per-section plan ---- */
 
 typedef struct MSec {
   MSegSect ns;
   u64 addr;    /* assigned vmaddr within the segment */
   u64 size;    /* bytes (or bss size) */
   u32 fileoff; /* 0 for zerofill */
   u32 align;   /* power-of-two; stored as log2 in section_64.align */
   u32 reloff;  /* 0 if no relocs */
   u32 nreloc;
   u32 flags; /* S_TYPE | S_ATTR_* */
   u32 entsize;
   u32 obj_sec; /* originating ObjSecId */
   int is_zerofill;
   const Buf* obj_bytes; /* NULL when zerofill */
   u8* patch_bytes;      /* writable flattened copy with addends baked into
                          * reloc fields (x86_64); NULL → write obj_bytes verbatim */
   u8* relocs;           /* arena-allocated; nreloc * 8 bytes */
 } MSec;
 
 static u32 log2_align(u32 a) {
   u32 r = 0;
   while ((1u << r) < a) ++r;
   return r;
 }
 
 /* Lazily flatten m's section bytes into a writable arena buffer so x86_64
  * addends can be baked into the relocated fields. Returns NULL for zerofill. */
 static u8* macho_sec_writable(Compiler* c, MSec* m) {
   if (m->patch_bytes || !m->obj_bytes) return m->patch_bytes;
   u32 sz = m->obj_bytes->total;
   u8* p = (u8*)arena_alloc(c->scratch, sz ? sz : 1, _Alignof(u64));
   if (sz) buf_flatten(m->obj_bytes, p);
   m->patch_bytes = p;
   return p;
 }
 
 /* Write a `length`-encoded little-endian field (length 0/1/2/3 → 1/2/4/8 B). */
 static void macho_write_field(u8* at, u32 length, i64 v) {
   switch (length) {
     case 0: *at = (u8)v; break;
     case 1: wr_u16_le(at, (u16)v); break;
     case 2: wr_u32_le(at, (u32)v); break;
     default: wr_u64_le(at, (u64)v); break;
   }
 }
 
 static u32 section_flags_for(u16 sec_kind, u16 sec_flags, const char* sectname,
                              u32 sect_len) {
   u32 f = 0;
   if (sec_kind == SEC_TEXT || (sec_flags & SF_EXEC)) {
     f |= S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS;
   }
   if (sec_flags & SF_TLS) {
     /* Mach-O distinguishes three TLV section types by sectname:
      *   __thread_data  → S_THREAD_LOCAL_REGULAR (initial data)
      *   __thread_bss   → S_THREAD_LOCAL_ZEROFILL (zero-init data)
      *   __thread_vars  → S_THREAD_LOCAL_VARIABLES (descriptor records)
      * dyld dispatches its TLV-bootstrap pass off the S_TYPE; the
      * S_ATTR_* bits don't carry TLV semantics so we just emit the type. */
     if (sect_len >= 13 && memcmp(sectname, "__thread_vars", 13) == 0)
       return S_THREAD_LOCAL_VARIABLES;
     if (sec_kind == SEC_BSS) return S_THREAD_LOCAL_ZEROFILL;
     return S_THREAD_LOCAL_REGULAR;
   }
   if (sec_kind == SEC_BSS ||
       (sect_len >= 5 && memcmp(sectname, "__bss", 5) == 0)) {
     f |= S_ZEROFILL;
   }
   if (sec_flags & SF_STRINGS) {
     f = (f & ~SECTION_TYPE) | S_CSTRING_LITERALS;
   }
   if (sec_flags & SF_RETAIN) {
     f |= S_ATTR_NO_DEAD_STRIP;
   }
   /* Default S_REGULAR (0) for all others. */
   return f;
 }
 
 /* ---- symbol partition ---- */
 
 typedef struct MSym {
   ObjSymId obj_id;
   u32 strx; /* offset in string table */
   u8 n_type;
   u8 n_sect;
   u16 n_desc;
   u64 n_value;
 } MSym;
 
 static int sym_is_undef(const ObjSym* s) {
   return s->section_id == OBJ_SEC_NONE && s->kind != SK_ABS &&
          s->kind != SK_COMMON;
 }
 
 static int sym_is_extdef(const ObjSym* s) {
   if (sym_is_undef(s)) return 0;
   return s->bind == SB_GLOBAL || s->bind == SB_WEAK;
 }
 
 /* ---- string table ----
  *
  * Mach-O strtab: leading zero byte at offset 0 represents the empty
  * string.  Entries are NUL-terminated; we don't dedupe (small symbol
  * counts in v1; matches the simplest llvm output).  The "_" prefix on
  * C symbols is added inline in the writer below. */
 
 void emit_macho(Compiler* c, ObjBuilder* ob, Writer* w) {
   Heap* h = (Heap*)c->ctx->heap;
 
   /* Tombstone sweep first — strip/objcopy mutations and the historical
    * UNDEF prune are both expressed via Section.removed / ObjSym.removed
    * post-sweep. See obj_sweep_dead. */
   obj_sweep_dead(ob);
 
   /* ---- target validation ---------------------------------------- */
   const ObjFormatImpl* fmt = obj_format_lookup(KIT_OBJ_MACHO);
   const ObjMachoArchOps* macho =
       fmt && fmt->macho_arch ? fmt->macho_arch(c->target.arch) : NULL;
   u32 cputype, cpusubtype;
   u32 (*reloc_to)(u32);
   u32 (*reloc_pcrel)(u32);
   u32 (*reloc_length)(u32);
   if (!macho || !macho->reloc_to || !macho->reloc_pcrel ||
       !macho->reloc_length) {
     compiler_panic(c, SRCLOC_NONE, "emit_macho: unsupported target arch %u",
                    (u32)c->target.arch);
   }
   cputype = macho->cputype;
   cpusubtype = macho->cpusubtype;
   reloc_to = macho->reloc_to;
   reloc_pcrel = macho->reloc_pcrel;
   reloc_length = macho->reloc_length;
   if (c->target.big_endian) {
     compiler_panic(c, SRCLOC_NONE, "emit_macho: big-endian not supported");
   }
   if (c->target.ptr_size != 8) {
     compiler_panic(c, SRCLOC_NONE, "emit_macho: ptr_size %u (expected 8)",
                    (u32)c->target.ptr_size);
   }
 
   /* ---- pass 1: plan Mach-O sections ----------------------------- */
   u32 nobjsec = obj_section_count(ob);
   MSec* secs = arena_zarray(c->scratch, MSec, nobjsec ? nobjsec : 1);
   u32* obj_to_msec = arena_zarray(c->scratch, u32, nobjsec ? nobjsec : 1);
   u32 nsecs = 0;
   int has_explicit_atoms = obj_atom_count(ob) > 1u;
 
   for (u32 i = 1; i < nobjsec; ++i) {
     const Section* s = obj_section_get(ob, i);
     if (s->removed) continue; /* see obj_sweep_dead */
     /* Skip ELF-style synthetic sections that read_elf would have
      * filtered: SYMTAB / STRTAB / RELA / GROUP have no Mach-O
      * representation as data sections. */
     if (s->sem == SSEM_SYMTAB || s->sem == SSEM_STRTAB || s->sem == SSEM_RELA ||
         s->sem == SSEM_REL || s->sem == SSEM_GROUP) {
       continue;
     }
     Slice nm_s = pool_slice(c->global, s->name);
     const char* nm = nm_s.s;
     size_t nlen = nm_s.len;
     MSec* m = &secs[nsecs];
     name_to_seg_sect(nm ? nm : "", (u32)nlen, s->kind, &m->ns);
     m->obj_sec = i;
     m->align = s->align ? s->align : 1;
     m->entsize = s->entsize;
     /* Mach-O reader stashes the raw section.flags (S_TYPE | S_ATTR_*)
      * in Section.ext_type when reading a Mach-O input.  Use it
      * verbatim so attribute bits like S_ATTR_NO_DEAD_STRIP /
      * S_ATTR_LIVE_SUPPORT round-trip.  Fall back to the kind-derived
      * default for sections originating from non-Mach-O readers (e.g.
      * kit codegen). */
     if (s->ext_kind == OBJ_EXT_MACHO && s->ext_type) {
       m->flags = s->ext_type;
     } else {
       m->flags =
           section_flags_for(s->kind, s->flags, m->ns.sectname, m->ns.sect_len);
     }
     if (s->sem == SSEM_NOBITS || s->kind == SEC_BSS) {
       m->is_zerofill = 1;
       m->size = s->bss_size;
       m->obj_bytes = NULL;
       /* Preserve S_THREAD_LOCAL_ZEROFILL when SF_TLS routed us there;
        * a regular BSS section gets the plain S_ZEROFILL type. */
       u32 stype = m->flags & SECTION_TYPE;
       if (stype != S_THREAD_LOCAL_ZEROFILL)
         m->flags = (m->flags & ~SECTION_TYPE) | S_ZEROFILL;
     } else {
       m->is_zerofill = 0;
       m->size = s->bytes.total;
       m->obj_bytes = &s->bytes;
     }
     obj_to_msec[i] = nsecs + 1; /* 1-based: matches Mach-O n_sect. */
     nsecs++;
   }
   if (nsecs > 255u) {
     compiler_panic(c, SRCLOC_NONE,
                    "emit_macho: too many physical sections for Mach-O "
                    "symbol n_sect ordinals (%u > 255); use atom splitting "
                    "instead of physical split sections",
                    nsecs);
   }
 
   /* ---- pass 2: assign vmaddrs (segment-relative) and per-section
    *              flat-layout addresses.  MH_OBJECT keeps everything in
    *              one segment with vmaddr=0; section addr fields are
    *              relative offsets within the segment.
    *
    * Two-pass to match the conventional Mach-O `MH_OBJECT` layout:
    * non-zerofill sections come first in vmaddr order, then zerofill
    * sections at the tail.  Apple `as` and clang `-c` both lay out
    * this way, and roundtripping must reproduce it so symbol n_values
    * (which are segment-relative addresses) compare equal. */
   u64 cur_addr = 0;
   for (u32 i = 0; i < nsecs; ++i) {
     MSec* m = &secs[i];
     if (m->is_zerofill) continue;
     cur_addr = ALIGN_UP(cur_addr, (u64)m->align);
     m->addr = cur_addr;
     cur_addr += m->size;
   }
   for (u32 i = 0; i < nsecs; ++i) {
     MSec* m = &secs[i];
     if (!m->is_zerofill) continue;
     cur_addr = ALIGN_UP(cur_addr, (u64)m->align);
     m->addr = cur_addr;
     cur_addr += m->size;
   }
   u64 segment_vmsize = cur_addr;
 
   /* ---- pass 3: partition symbols (locals, extdefs, undefs) ------ */
   u32 nobjsym = 0;
   {
     ObjSymIter* it = obj_symiter_new(ob);
     ObjSymEntry e;
     while (obj_symiter_next(it, &e)) ++nobjsym;
     obj_symiter_free(it);
   }
 
   MSym* msyms = arena_zarray(c->scratch, MSym, nobjsym + 1);
   u32 nmsyms = 0;
   u32* sym_obj_to_macho =
       arena_zarray(c->scratch, u32, nobjsym + 2); /* obj_id -> mach idx */
 
   /* Shared deduping string-table builder (obj.h). Mach-O previously appended
    * names without dedup; one shared policy across formats both unifies the code
    * and shrinks the table (repeated names share one copy) at O(n) cost. */
   ObjStrtab strtab;
   obj_strtab_init(&strtab, h, /*dedup=*/1);
   /* Mach-O strtab convention: the first byte is " " (space) or NUL —
    * llvm/Apple emit a single NUL.  We start with NUL for offset 0. */
   {
     u8 z = 0;
     obj_strtab_put_raw(&strtab, &z, 1);
   }
 
   /* Emit in three passes so n_type/sect ordering matches LC_DYSYMTAB
    * (locals, then extdefs, then undefs).  The pass index IS the on-disk
    * class, so the per-pass emit counts ARE the LC_DYSYMTAB partition
    * sizes — count them inline instead of re-walking the symbols. */
   u32 nlocals = 0, nextdefs = 0, nundefs = 0;
   for (int pass = 0; pass < 3; ++pass) {
     ObjSymIter* it = obj_symiter_new(ob);
     ObjSymEntry e;
     while (obj_symiter_next(it, &e)) {
       const ObjSym* s = e.sym;
       if (s->removed) continue; /* spurious-UNDEF prune + explicit removal */
       int undef = sym_is_undef(s);
       int extdef = sym_is_extdef(s);
       int local = !undef && !extdef;
       int want =
           (pass == 0 && local) || (pass == 1 && extdef) || (pass == 2 && undef);
       if (!want) continue;
       MSym* ms = &msyms[nmsyms];
       ms->obj_id = e.id;
 
       Slice nm_s = pool_slice(c->global, s->name);
       const char* nm = nm_s.s;
       size_t nlen = nm_s.len;
       /* Mach-O symbol names are stored on disk verbatim — including
        * the leading `_` Apple toolchains use for C-source-level
        * symbols ("_main" for `int main()`).  kit treats the prefix
        * as part of the on-disk name, not a transform applied at emit.
        * Name-canonicalization for API callers (kit_jit_lookup,
        * link_set_entry) lives one layer up at the linker boundary
        * (link.c), so emit/read stay byte-for-byte stable. */
       ms->strx = (nlen && nm) ? obj_strtab_add(&strtab, nm, (u32)nlen) : 0;
 
       u8 type = 0;
       if (extdef) type |= N_EXT;
       if (s->vis == SV_HIDDEN || s->vis == SV_INTERNAL) {
         /* Mach-O encodes hidden externals as N_PEXT|N_EXT. */
         type |= N_PEXT;
       }
       u8 n_sect = NO_SECT;
       u16 n_desc = 0;
       u64 value = s->value;
 
       if (undef) {
         type |= N_UNDF;
         /* Undefined symbols with non-LOCAL bind are external references
          * (the common case — every `extern int x;`).  Setting N_EXT
          * matches what clang emits and what Apple `ld` expects. */
         if (s->bind == SB_GLOBAL || s->bind == SB_WEAK) type |= N_EXT;
         if (s->bind == SB_WEAK) n_desc |= N_WEAK_REF;
         value = 0;
       } else if (s->kind == SK_ABS) {
         type |= N_ABS;
       } else if (s->kind == SK_COMMON) {
         /* Mach-O common symbols are N_UNDF|N_EXT with n_value=size and
          * n_desc carrying log2(align) in the GET_COMM_ALIGN bits. */
         type = N_UNDF | N_EXT;
         value = s->size;
         u32 a = s->common_align ? (u32)s->common_align : 1;
         n_desc = (u16)(log2_align(a) << 8); /* GET_COMM_ALIGN field */
       } else {
         type |= N_SECT;
         u32 ms_idx = (s->section_id < nobjsec) ? obj_to_msec[s->section_id] : 0;
         if (ms_idx > 255u) {
           compiler_panic(c, SRCLOC_NONE,
                          "emit_macho: symbol section ordinal %u exceeds "
                          "Mach-O n_sect range",
                          ms_idx);
         }
         n_sect = (u8)ms_idx;
         if (n_sect && ms_idx <= nsecs) {
           value = secs[ms_idx - 1].addr + s->value;
         }
         if (s->bind == SB_WEAK) n_desc |= N_WEAK_DEF;
       }
 
       /* OR in any pass-through n_desc bits the reader stashed in
        * sym->flags (N_NO_DEAD_STRIP, etc.). The bits we already
        * compute (N_WEAK_DEF / N_WEAK_REF and the common-alignment
        * field) are already excluded by read_macho before stashing,
        * so a plain OR can't double-count. */
       n_desc |= s->flags;
       if (s->atom_subordinate && (type & N_TYPE) == N_SECT)
         n_desc |= N_ALT_ENTRY;
       {
         ObjAtomId aid = obj_atom_find_symbol(ob, e.id);
         const ObjAtom* atom = obj_atom_get(ob, aid);
         if (atom && atom->signature == e.id && (atom->flags & OBJ_ATOM_RETAIN))
           n_desc |= N_NO_DEAD_STRIP;
       }
 
       ms->n_type = type;
       ms->n_sect = n_sect;
       ms->n_desc = n_desc;
       ms->n_value = value;
 
       sym_obj_to_macho[e.id] = nmsyms + 1; /* 1-based index, 0 = none. */
       nmsyms++;
       if (pass == 0)
         ++nlocals;
       else if (pass == 1)
         ++nextdefs;
       else
         ++nundefs;
     }
     obj_symiter_free(it);
   }
 
   /* ---- pass 4: build per-section relocation tables -------------- */
   u32 total_relocs = obj_reloc_total(ob);
   for (u32 i = 0; i < nsecs; ++i) {
     MSec* m = &secs[i];
     u32 nr;
     const u32* rix = obj_reloc_section(ob, m->obj_sec, &nr);
     if (!nr) continue;
     /* Worst case: each reloc may be preceded by an ARM64_RELOC_ADDEND
      * pair entry.  We size the buffer for that upper bound. */
     u8* buf = (u8*)arena_alloc(c->scratch, (size_t)MACHO_RELOC_SIZE * nr * 2,
                                _Alignof(u32));
     u32 j = 0;
     /* rix[] lists this section's live relocs in ascending global order, so
      * each is in-section and non-removed by construction. The symdiff
      * pairing below still peeks the *global* next (ri+1) exactly as before. */
     for (u32 k = 0; k < nr; ++k) {
       u32 ri = rix[k];
       const Reloc* r = obj_reloc_at(ob, ri);
       if ((r->kind == R_ADD8 || r->kind == R_ADD16 || r->kind == R_ADD32 ||
            r->kind == R_ADD64) &&
           ri + 1u < total_relocs) {
         const Reloc* sub = obj_reloc_at(ob, ri + 1u);
         int paired = sub && sub->section_id == r->section_id &&
                      sub->offset == r->offset &&
                      ((r->kind == R_ADD8 && sub->kind == R_SUB8) ||
                       (r->kind == R_ADD16 && sub->kind == R_SUB16) ||
                       (r->kind == R_ADD32 && sub->kind == R_SUB32) ||
                       (r->kind == R_ADD64 && sub->kind == R_SUB64));
         if (paired) {
           u32 length = (r->kind == R_ADD64)   ? 3u
                        : (r->kind == R_ADD32) ? 2u
                        : (r->kind == R_ADD16) ? 1u
                                               : 0u;
           u32 add_idx;
           u32 sub_idx;
           u32 sub_type = c->target.arch == KIT_ARCH_ARM_64
                              ? ARM64_RELOC_SUBTRACTOR
                              : X86_64_RELOC_SUBTRACTOR;
           u32 unsigned_type = c->target.arch == KIT_ARCH_ARM_64
                                   ? ARM64_RELOC_UNSIGNED
                                   : X86_64_RELOC_UNSIGNED;
           if (r->sym == OBJ_SYM_NONE || sub->sym == OBJ_SYM_NONE) {
             compiler_panic(c, SRCLOC_NONE,
                            "emit_macho: symdiff reloc without symbol");
           }
           add_idx = sym_obj_to_macho[r->sym];
           sub_idx = sym_obj_to_macho[sub->sym];
           if (add_idx == 0 || sub_idx == 0) {
             compiler_panic(c, SRCLOC_NONE,
                            "emit_macho: symdiff reloc target not in symtab");
           }
           {
             u8* slot = buf + (size_t)j * MACHO_RELOC_SIZE;
             wr_u32_le(slot + 0, (u32)r->offset);
             wr_u32_le(slot + 4, ((sub_idx - 1u) & 0x00ffffffu) |
                                     (length << 25) | (1u << 27) |
                                     ((sub_type & 0xfu) << 28));
             ++j;
           }
           {
             u8* slot = buf + (size_t)j * MACHO_RELOC_SIZE;
             wr_u32_le(slot + 0, (u32)r->offset);
             wr_u32_le(slot + 4, ((add_idx - 1u) & 0x00ffffffu) |
                                     (length << 25) | (1u << 27) |
                                     ((unsigned_type & 0xfu) << 28));
             ++j;
           }
           /* Skip the SUB partner (global ri+1) — it is this section's next
            * live reloc iff it is globally adjacent in the bucket. */
           if (k + 1u < nr && rix[k + 1u] == ri + 1u) ++k;
           continue;
         }
       }
       u32 mtype = reloc_to(r->kind);
       if (mtype == (u32)-1) {
         compiler_panic(c, SRCLOC_NONE,
                        "emit_macho: unsupported reloc kind %u for arch %u",
                        (u32)r->kind, (u32)c->target.arch);
       }
       u32 pcrel = reloc_pcrel(r->kind);
       u32 length = reloc_length(r->kind);
 
       /* Resolve target — extern always 1 in our model (every Reloc has
        * an ObjSymId).  Skip relocs without a symbol — they would map to
        * a section-relative reloc which the v1 cgtarget never emits. */
       if (r->sym == OBJ_SYM_NONE) {
         compiler_panic(c, SRCLOC_NONE,
                        "emit_macho: reloc without symbol not supported "
                        "(sec=%u offset=%u kind=%u)",
                        (u32)r->section_id, (u32)r->offset, (u32)r->kind);
       }
       u32 mach_sym_idx = sym_obj_to_macho[r->sym];
       if (mach_sym_idx == 0) {
         compiler_panic(c, SRCLOC_NONE,
                        "emit_macho: reloc target sym %u not in symtab",
                        (u32)r->sym);
       }
       u32 r_symbolnum = mach_sym_idx - 1; /* Mach-O uses 0-based. */
 
       /* Non-zero addend (UNSIGNED carries its addend inline on both arches,
        * so its enum value 0 — shared by ARM64_RELOC_UNSIGNED and
        * X86_64_RELOC_UNSIGNED — is excluded here). The two arches diverge:
        *   AArch64 has no inline addend field for the PC-relative/GOT kinds,
        *     so a leading ARM64_RELOC_ADDEND pseudo-reloc carries it.
        *   x86_64 has no X86_64_RELOC_ADDEND; the relocated field holds the
        *     symbol-relative addend inline and the linker applies the PC bias.
        *     kit's addend is ELF-style (symrel − field_width for these
        *     PC-relative kinds), so bake symrel = addend + width back in. */
       if (r->addend != 0 && mtype != ARM64_RELOC_UNSIGNED) {
         if (c->target.arch == KIT_ARCH_ARM_64) {
           u8* slot = buf + (size_t)j * MACHO_RELOC_SIZE;
           wr_u32_le(slot + 0, (u32)r->offset);
           /* ARM64_RELOC_ADDEND stores a signed 24-bit immediate in
            * r_symbolnum.  It is not a symbol-table reference; setting
            * r_extern would make readers interpret the addend as a symbol
            * index. */
           u32 packed = ((u32)(i64)r->addend & 0x00ffffffu) | (0u << 24) |
                        (length << 25) | (ARM64_RELOC_ADDEND << 28);
           wr_u32_le(slot + 4, packed);
           ++j;
         } else {
           u8* data = macho_sec_writable(c, m);
           if (data) {
             i64 symrel = r->addend + (pcrel ? (i64)(1u << length) : 0);
             macho_write_field(data + r->offset, length, symrel);
           }
         }
       }
 
       u8* slot = buf + (size_t)j * MACHO_RELOC_SIZE;
       wr_u32_le(slot + 0, (u32)r->offset);
       u32 packed = (r_symbolnum & 0x00ffffffu) | ((pcrel & 1u) << 24) |
                    ((length & 3u) << 25) | (1u << 27) /*extern*/ |
                    ((mtype & 0xfu) << 28);
       wr_u32_le(slot + 4, packed);
       ++j;
     }
     m->relocs = buf;
     m->nreloc = j;
   }
 
   /* ---- pass 5: assign file offsets ------------------------------ */
   /* Layout after the load-command block:
    *   section bytes (in order, respecting align)
    *   relocation tables (per section, 4-aligned)
    *   symbol table (8-aligned)
    *   string table */
   u32 nload_cmds =
       4; /* LC_SEGMENT_64 + LC_BUILD_VERSION + LC_SYMTAB + LC_DYSYMTAB */
   u32 segcmd_size = MACHO_SEGCMD64_SIZE + nsecs * MACHO_SECT64_SIZE;
   u32 build_version_size =
       24; /* fixed: cmd+cmdsize+platform+minos+sdk+ntools(0) */
   u32 sizeofcmds = segcmd_size + build_version_size + MACHO_SYMTAB_CMD_SIZE +
                    MACHO_DYSYMTAB_CMD_SIZE;
 
   u64 cur = MACHO_HDR64_SIZE + sizeofcmds;
   u32 fileoff_first = (u32)cur;
   for (u32 i = 0; i < nsecs; ++i) {
     MSec* m = &secs[i];
     if (m->is_zerofill) {
       m->fileoff = 0;
       continue;
     }
     cur = ALIGN_UP(cur, (u64)m->align);
     m->fileoff = (u32)cur;
     cur += m->size;
   }
 
   /* Reloc tables. */
   for (u32 i = 0; i < nsecs; ++i) {
     MSec* m = &secs[i];
     if (!m->nreloc) {
       m->reloff = 0;
       continue;
     }
     cur = ALIGN_UP(cur, (u64)4);
     m->reloff = (u32)cur;
     cur += (u64)m->nreloc * MACHO_RELOC_SIZE;
   }
 
   cur = ALIGN_UP(cur, (u64)8);
   u64 symoff = cur;
   cur += (u64)nmsyms * MACHO_NLIST64_SIZE;
   u64 stroff = cur;
   u32 strtab_size = obj_strtab_size(&strtab);
   cur += strtab_size;
 
   /* ---- pass 6: write the file ------------------------------------ */
   kit_writer_seek(w, 0);
 
   /* mach_header_64 */
   wr_u32(w, MH_MAGIC_64);
   wr_u32(w, cputype);
   wr_u32(w, cpusubtype);
   wr_u32(w, MH_OBJECT);
   wr_u32(w, nload_cmds);
   wr_u32(w, sizeofcmds);
   wr_u32(w, has_explicit_atoms ? MH_SUBSECTIONS_VIA_SYMBOLS : 0);
   wr_u32(w, 0); /* reserved */
 
   /* LC_SEGMENT_64 (anonymous, contains everything) */
   wr_u32(w, LC_SEGMENT_64);
   wr_u32(w, segcmd_size);
   wr_name16(w, "", 0);       /* segname: empty for MH_OBJECT */
   wr_u64(w, 0);              /* vmaddr */
   wr_u64(w, segment_vmsize); /* vmsize */
   wr_u64(w, fileoff_first);  /* fileoff */
   /* filesize = bytes covered by non-zerofill sections (post-section
    * file offset minus the start). */
   u64 filesize = 0;
   for (u32 i = 0; i < nsecs; ++i) {
     MSec* m = &secs[i];
     if (m->is_zerofill) continue;
     u64 end = (u64)m->fileoff + m->size;
     u64 begin = m->fileoff;
     if (end > filesize + fileoff_first) filesize = end - fileoff_first;
     (void)begin;
   }
   wr_u64(w, filesize);
   /* maxprot/initprot — VM_PROT_READ|WRITE|EXECUTE = 7 for object segs. */
   wr_u32(w, 7);
   wr_u32(w, 7);
   wr_u32(w, nsecs);
   wr_u32(w, 0); /* flags */
 
   /* sections inline within the segment command */
   for (u32 i = 0; i < nsecs; ++i) {
     MSec* m = &secs[i];
     wr_name16(w, m->ns.sectname, m->ns.sect_len);
     wr_name16(w, m->ns.segname, m->ns.seg_len);
     wr_u64(w, m->addr);
     wr_u64(w, m->size);
     wr_u32(w, m->fileoff);
     wr_u32(w, log2_align(m->align));
     wr_u32(w, m->reloff);
     wr_u32(w, m->nreloc);
     wr_u32(w, m->flags);
     wr_u32(w, 0);          /* reserved1 */
     wr_u32(w, m->entsize); /* reserved2 */
     wr_u32(w, 0);          /* reserved3 */
   }
 
   /* LC_BUILD_VERSION — platform follows the target OS, minos/sdk=14.0.0,
    * ntools=0.  The exact min-version isn't load-bearing for MH_OBJECT,
    * but Apple's `ld` warns when it's missing. */
   wr_u32(w, LC_BUILD_VERSION);
   wr_u32(w, build_version_size);
   wr_u32(w, macho_platform_for_target(c->target));
   wr_u32(w, (14u << 16) | 0); /* minos: 14.0.0 */
   wr_u32(w, (14u << 16) | 0); /* sdk:   14.0.0 */
   wr_u32(w, 0);               /* ntools */
 
   /* LC_SYMTAB */
   wr_u32(w, LC_SYMTAB);
   wr_u32(w, MACHO_SYMTAB_CMD_SIZE);
   wr_u32(w, (u32)symoff);
   wr_u32(w, nmsyms);
   wr_u32(w, (u32)stroff);
   wr_u32(w, strtab_size);
 
   /* LC_DYSYMTAB */
   wr_u32(w, LC_DYSYMTAB);
   wr_u32(w, MACHO_DYSYMTAB_CMD_SIZE);
   wr_u32(w, 0); /* ilocalsym */
   wr_u32(w, nlocals);
   wr_u32(w, nlocals);
   wr_u32(w, nextdefs);
   wr_u32(w, nlocals + nextdefs);
   wr_u32(w, nundefs);
   wr_u32(w, 0);
   wr_u32(w, 0); /* tocoff, ntoc */
   wr_u32(w, 0);
   wr_u32(w, 0); /* modtaboff, nmodtab */
   wr_u32(w, 0);
   wr_u32(w, 0); /* extrefsymoff, nextrefsyms */
   wr_u32(w, 0);
   wr_u32(w, 0); /* indirectsymoff, nindirectsyms */
   wr_u32(w, 0);
   wr_u32(w, 0); /* extreloff, nextrel */
   wr_u32(w, 0);
   wr_u32(w, 0); /* locreloff, nlocrel */
 
   /* section bytes */
   for (u32 i = 0; i < nsecs; ++i) {
     MSec* m = &secs[i];
     if (m->is_zerofill || !m->size) continue;
     kit_writer_seek(w, m->fileoff);
     if (m->obj_bytes) {
       u32 sz = m->obj_bytes->total;
       if (m->patch_bytes) {
         kit_writer_write(w, m->patch_bytes, sz);
       } else {
         u8* tmp = (u8*)h->alloc(h, sz ? sz : 1, 1);
         if (sz) buf_flatten(m->obj_bytes, tmp);
         kit_writer_write(w, tmp, sz);
         h->free(h, tmp, sz ? sz : 1);
       }
     }
   }
 
   /* reloc tables */
   for (u32 i = 0; i < nsecs; ++i) {
     MSec* m = &secs[i];
     if (!m->nreloc) continue;
     kit_writer_seek(w, m->reloff);
     kit_writer_write(w, m->relocs, (size_t)m->nreloc * MACHO_RELOC_SIZE);
   }
 
   /* symtab */
   kit_writer_seek(w, symoff);
   for (u32 i = 0; i < nmsyms; ++i) {
     const MSym* ms = &msyms[i];
     u8 entry[MACHO_NLIST64_SIZE];
     wr_u32_le(entry + 0, ms->strx);
     entry[4] = ms->n_type;
     entry[5] = ms->n_sect;
     wr_u16_le(entry + 6, ms->n_desc);
     wr_u64_le(entry + 8, ms->n_value);
     kit_writer_write(w, entry, MACHO_NLIST64_SIZE);
   }
 
   /* strtab — kit_writer_write consumes synchronously and nothing
    * appends to the strtab after this point, so write its contiguous
    * buffer directly (no flatten copy) and free it afterwards. */
   kit_writer_seek(w, stroff);
   if (strtab_size) kit_writer_write(w, obj_strtab_data(&strtab), strtab_size);
   obj_strtab_fini(&strtab);
 }