kit

debug_emit.c (46851B)

---

 /* Linearize accumulated Debug state into ObjBuilder .debug_* sections.
  *
  * Wire-format choices made here are documented in DWARF.md / the agent
  * report. Highlights:
  *
  *   - DWARF 5 only.
  *   - 32-bit (DWARF32) section length form.
  *   - DW_FORM_strx4 used uniformly for string refs from .debug_info.
  *   - DW_FORM_line_strp for line program file/dir paths.
  *   - DW_FORM_ref4 for intra-CU DIE refs (CU-relative offset).
  *   - DW_AT_low_pc encoded as DW_FORM_addr with an address-width reloc against
  *     the function symbol; DW_AT_high_pc is DW_FORM_data4 holding func size.
  *   - DW_AT_frame_base is exprloc { DW_OP_call_frame_cfa }.
  *   - Abbrev codes are assigned in first-use order, starting at 1.
  *   - File 0 in .debug_line is the CU primary file (DW5 convention). */
 
 #include <string.h>
 
 #include "arch/arch.h"
 #include "core/buf.h"
 #include "core/core.h"
 #include "core/heap.h"
 #include "core/pool.h"
 #include "core/slice.h"
 #include "core/vec.h"
 #include "debug/debug_internal.h"
 
 void abbrev_fini_heap(DebugAbbrevPool* p, Heap* h);
 
 /* ---------------------------------------------------------------- */
 /* String tables. */
 
 typedef struct StrTab {
   Buf buf;
   SymToU32 by_sym;     /* Sym → byte offset within buf */
   SymToU32 idx_by_sym; /* Sym → insertion index (== DW_FORM_strx value) */
   /* Insertion order — used to populate .debug_str_offsets. */
   Sym* syms;
   u32 nsyms;
   u32 syms_cap;
 } StrTab;
 
 static void str_init(StrTab* s, Heap* h) {
   buf_init(&s->buf, h);
   SymToU32_init(&s->by_sym, h);
   SymToU32_init(&s->idx_by_sym, h);
   s->syms = NULL;
   s->nsyms = 0;
   s->syms_cap = 0;
 }
 
 static void str_fini(StrTab* s, Heap* h) {
   buf_fini(&s->buf);
   SymToU32_fini(&s->by_sym);
   SymToU32_fini(&s->idx_by_sym);
   if (s->syms) h->free(h, s->syms, sizeof(Sym) * s->syms_cap);
   s->syms = NULL;
   s->nsyms = 0;
   s->syms_cap = 0;
 }
 
 static u32 str_intern(StrTab* s, Heap* h, Pool* pool, Sym sym) {
   u32* found;
   u32 ofs;
   size_t len;
   const char* str;
   if (sym == 0) sym = pool_intern_slice(pool, SLICE_LIT(""));
   found = SymToU32_get(&s->by_sym, sym);
   if (found) return *found;
   ofs = buf_pos(&s->buf);
   {
     Slice sl = pool_slice(pool, sym);
     str = sl.s;
     len = sl.len;
   }
   if (str && len) buf_write(&s->buf, str, len);
   {
     u8 nul = 0;
     buf_write(&s->buf, &nul, 1);
   }
   SymToU32_set(&s->by_sym, sym, ofs);
   if (VEC_GROW(h, s->syms, s->syms_cap, s->nsyms + 1)) return ofs;
   SymToU32_set(&s->idx_by_sym, sym, s->nsyms);
   s->syms[s->nsyms++] = sym;
   return ofs;
 }
 
 static u32 str_index_of(StrTab* s, Sym sym) {
   u32* idx = SymToU32_get(&s->idx_by_sym, sym);
   return idx ? *idx : 0;
 }
 
 /* ---------------------------------------------------------------- */
 /* DIE forward refs and address relocs. */
 
 typedef struct DieFixup {
   u32 buf_offset; /* offset within EmitCtx.info_body */
   DebugTypeId target;
 } DieFixup;
 
 typedef struct AddrReloc {
   u32 buf_offset; /* offset within the section (assigned at flush) */
   ObjSymId sym;
   ObjSecId section; /* set on flush */
 } AddrReloc;
 
 typedef struct EmitCtx {
   Debug* d;
   Heap* heap;
   Pool* pool;
   ObjBuilder* ob;
 
   StrTab str;      /* .debug_str */
   StrTab line_str; /* .debug_line_str */
 
   DebugAbbrevPool abbr;
 
   /* Pre-resolved abbrev codes */
   u32 abbr_cu;
   u32 abbr_base;
   u32 abbr_ptr;
   u32 abbr_typedef;
   u32 abbr_qual_const;
   u32 abbr_qual_volatile;
   u32 abbr_qual_restrict;
   u32 abbr_array;
   u32 abbr_array_subrange;
   u32 abbr_array_subrange_unbounded;
   u32 abbr_func_type;
   u32 abbr_func_type_param;
   u32 abbr_struct;
   u32 abbr_union;
   u32 abbr_member;
   u32 abbr_member_bitfield;
   u32 abbr_enum;
   u32 abbr_enum_val;
   u32 abbr_subprogram;
   u32 abbr_param;
   u32 abbr_var;
   u32 abbr_var_external;
   u32 abbr_lexical_block;
 
   /* CU body (post-CU-header DIE bytes). */
   Buf info_body;
 
   /* Forward type-ref fixups (info_body-relative). */
   DieFixup* fixups;
   u32 nfixups;
   u32 fixups_cap;
 
   /* low_pc relocs in .debug_info (info_body-relative offset). */
   AddrReloc* info_relocs;
   u32 ninfo_relocs;
   u32 info_relocs_cap;
 
   /* line-program address relocs (.debug_line offset within program region). */
   AddrReloc* line_relocs;
   u32 nline_relocs;
   u32 line_relocs_cap;
 
   /* aranges relocs (section-relative once we know offsets). */
   AddrReloc* aranges_relocs;
   u32 naranges_relocs;
   u32 aranges_relocs_cap;
 
   /* rnglists relocs. */
   AddrReloc* rng_relocs;
   u32 nrng_relocs;
   u32 nrng_relocs_cap;
 
   /* Section ids (pre-created up front so cross-section relocs can name
    * their target before its bytes are written). */
   ObjSecId sec_str;
   ObjSecId sec_line_str;
   ObjSecId sec_str_off;
   ObjSecId sec_abbrev;
   ObjSecId sec_info;
   ObjSecId sec_line;
   ObjSecId sec_aranges;
   ObjSecId sec_rnglists;
 
   /* SK_SECTION ObjSyms over the same sections.  They exist so the CU
    * header + root DIE can encode cross-section offsets (debug_abbrev_offset,
    * stmt_list, str_offsets_base, ranges) and the line / str-offsets
    * payloads can encode their .debug_line_str / .debug_str references
    * as relocations.  The on-disk u32 stays zero; the relocation's addend
    * carries the in-section offset.  In a normal `.o` emit the linker
    * applies R_ABS32 with S=section_vaddr=0 (debug sections are not laid
    * out), so the written value equals the addend — byte-identical to the
    * pre-reloc behaviour.  In the JIT view, link_jit applies the same
    * reloc against the section's accumulated prefix in the merged view,
    * so concatenated multi-input debug bytes resolve to the right slot. */
   ObjSymId ssym_str;
   ObjSymId ssym_line_str;
   ObjSymId ssym_str_off;
   ObjSymId ssym_abbrev;
   ObjSymId ssym_line;
   ObjSymId ssym_rnglists;
   ObjSymId ssym_info;
 
   /* Body-relative offsets of the three CU-root-DIE attributes whose
    * payloads are cross-section offsets.  Captured at the call sites in
    * debug_emit() and consumed by emit_section_info() to emit R_ABS32
    * relocs at cu_header_size + <at>. */
   u32 root_stmt_list_at;
   u32 root_ranges_at;
   u32 root_str_off_base_at;
 } EmitCtx;
 
 /* ---------------------------------------------------------------- */
 
 static void add_fixup(EmitCtx* e, u32 buf_offset, DebugTypeId target) {
   DieFixup* fx;
   if (VEC_GROW(e->heap, e->fixups, e->fixups_cap, e->nfixups + 1)) return;
   fx = &e->fixups[e->nfixups++];
   fx->buf_offset = buf_offset;
   fx->target = target;
 }
 
 /* Append a symbol-relative address reloc to one of the per-section AddrReloc
  * arrays (info/line/aranges/rng). The arrays share an identical element
  * layout and growth policy; only the backing array + count/cap differ. */
 static void add_addr_reloc(EmitCtx* e, AddrReloc** arr, u32* n, u32* cap,
                            u32 buf_offset, ObjSymId sym) {
   AddrReloc* r;
   if (VEC_GROW(e->heap, *arr, *cap, *n + 1)) return;
   r = &(*arr)[(*n)++];
   r->buf_offset = buf_offset;
   r->sym = sym;
   r->section = OBJ_SEC_NONE;
 }
 
 static RelocKind debug_addr_reloc_kind(const Debug* d) {
   return d && d->c && d->c->target.ptr_size == 4 ? R_ABS32 : R_ABS64;
 }
 
 /* ---------------------------------------------------------------- */
 /* String emit shortcuts. */
 
 static void emit_strx4(EmitCtx* e, Buf* b, Sym name) {
   str_intern(&e->str, e->heap, e->pool, name);
   {
     Sym key = name ? name : pool_intern_slice(e->pool, SLICE_LIT(""));
     u32 idx = str_index_of(&e->str, key);
     form_u32(b, idx);
   }
 }
 
 static u32 line_str_offset(EmitCtx* e, Sym sym) {
   return str_intern(&e->line_str, e->heap, e->pool, sym);
 }
 
 /* ---------------------------------------------------------------- */
 /* Abbrev resolution. */
 
 static u32 abbr_intern(EmitCtx* e, u16 tag, u8 has_children,
                        const DebugAbbrevAttr* attrs, u32 nattrs) {
   return abbrev_intern(&e->abbr, e->heap, tag, has_children, attrs, nattrs);
 }
 
 static void resolve_abbrevs(EmitCtx* e) {
   /* Order of intern == order of code assignment. */
   {
     DebugAbbrevAttr a[] = {
         {DW_AT_producer, DW_FORM_strx4, 0},
         {DW_AT_language, DW_FORM_data2, 0},
         {DW_AT_name, DW_FORM_strx4, 0},
         {DW_AT_comp_dir, DW_FORM_strx4, 0},
         {DW_AT_stmt_list, DW_FORM_sec_offset, 0},
         {DW_AT_low_pc, DW_FORM_addr, 0},
         {DW_AT_ranges, DW_FORM_sec_offset, 0},
         {DW_AT_str_offsets_base, DW_FORM_sec_offset, 0},
     };
     e->abbr_cu = abbr_intern(e, DW_TAG_compile_unit, DW_CHILDREN_yes, a,
                              (u32)(sizeof(a) / sizeof(a[0])));
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_name, DW_FORM_strx4, 0},
                            {DW_AT_encoding, DW_FORM_data1, 0},
                            {DW_AT_byte_size, DW_FORM_data1, 0}};
     e->abbr_base = abbr_intern(e, DW_TAG_base_type, DW_CHILDREN_no, a, 3);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_byte_size, DW_FORM_data1, 0},
                            {DW_AT_type, DW_FORM_ref4, 0}};
     e->abbr_ptr = abbr_intern(e, DW_TAG_pointer_type, DW_CHILDREN_no, a, 2);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_name, DW_FORM_strx4, 0},
                            {DW_AT_type, DW_FORM_ref4, 0}};
     e->abbr_typedef = abbr_intern(e, DW_TAG_typedef, DW_CHILDREN_no, a, 2);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_type, DW_FORM_ref4, 0}};
     e->abbr_qual_const =
         abbr_intern(e, DW_TAG_const_type, DW_CHILDREN_no, a, 1);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_type, DW_FORM_ref4, 0}};
     e->abbr_qual_volatile =
         abbr_intern(e, DW_TAG_volatile_type, DW_CHILDREN_no, a, 1);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_type, DW_FORM_ref4, 0}};
     e->abbr_qual_restrict =
         abbr_intern(e, DW_TAG_restrict_type, DW_CHILDREN_no, a, 1);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_type, DW_FORM_ref4, 0}};
     e->abbr_array = abbr_intern(e, DW_TAG_array_type, DW_CHILDREN_yes, a, 1);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_count, DW_FORM_udata, 0}};
     e->abbr_array_subrange =
         abbr_intern(e, DW_TAG_subrange_type, DW_CHILDREN_no, a, 1);
   }
   {
     e->abbr_array_subrange_unbounded =
         abbr_intern(e, DW_TAG_subrange_type, DW_CHILDREN_no, NULL, 0);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_type, DW_FORM_ref4, 0},
                            {DW_AT_prototyped, DW_FORM_flag_present, 0}};
     e->abbr_func_type =
         abbr_intern(e, DW_TAG_subroutine_type, DW_CHILDREN_yes, a, 2);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_type, DW_FORM_ref4, 0}};
     e->abbr_func_type_param =
         abbr_intern(e, DW_TAG_formal_parameter, DW_CHILDREN_no, a, 1);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_name, DW_FORM_strx4, 0},
                            {DW_AT_byte_size, DW_FORM_udata, 0}};
     e->abbr_struct =
         abbr_intern(e, DW_TAG_structure_type, DW_CHILDREN_yes, a, 2);
     e->abbr_union = abbr_intern(e, DW_TAG_union_type, DW_CHILDREN_yes, a, 2);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_name, DW_FORM_strx4, 0},
                            {DW_AT_type, DW_FORM_ref4, 0},
                            {DW_AT_data_member_location, DW_FORM_udata, 0}};
     e->abbr_member = abbr_intern(e, DW_TAG_member, DW_CHILDREN_no, a, 3);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_name, DW_FORM_strx4, 0},
                            {DW_AT_type, DW_FORM_ref4, 0},
                            {DW_AT_data_member_location, DW_FORM_udata, 0},
                            {DW_AT_data_bit_offset, DW_FORM_udata, 0},
                            {DW_AT_bit_size, DW_FORM_udata, 0}};
     e->abbr_member_bitfield =
         abbr_intern(e, DW_TAG_member, DW_CHILDREN_no, a, 5);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_name, DW_FORM_strx4, 0},
                            {DW_AT_type, DW_FORM_ref4, 0},
                            {DW_AT_byte_size, DW_FORM_udata, 0}};
     e->abbr_enum =
         abbr_intern(e, DW_TAG_enumeration_type, DW_CHILDREN_yes, a, 3);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_name, DW_FORM_strx4, 0},
                            {DW_AT_const_value, DW_FORM_sdata, 0}};
     e->abbr_enum_val = abbr_intern(e, DW_TAG_enumerator, DW_CHILDREN_no, a, 2);
   }
   {
     /* Subprogram. We use a single abbrev with DW_AT_type even when
      * return is void; emit_subprogram_die emits ref4=0 in that case
      * (which the consumer interprets as void). */
     DebugAbbrevAttr a[] = {{DW_AT_external, DW_FORM_flag_present, 0},
                            {DW_AT_name, DW_FORM_strx4, 0},
                            {DW_AT_decl_file, DW_FORM_udata, 0},
                            {DW_AT_decl_line, DW_FORM_udata, 0},
                            {DW_AT_type, DW_FORM_ref4, 0},
                            {DW_AT_low_pc, DW_FORM_addr, 0},
                            {DW_AT_high_pc, DW_FORM_data4, 0},
                            {DW_AT_frame_base, DW_FORM_exprloc, 0}};
     e->abbr_subprogram =
         abbr_intern(e, DW_TAG_subprogram, DW_CHILDREN_yes, a, 8);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_name, DW_FORM_strx4, 0},
                            {DW_AT_decl_file, DW_FORM_udata, 0},
                            {DW_AT_decl_line, DW_FORM_udata, 0},
                            {DW_AT_type, DW_FORM_ref4, 0},
                            {DW_AT_location, DW_FORM_exprloc, 0}};
     e->abbr_param =
         abbr_intern(e, DW_TAG_formal_parameter, DW_CHILDREN_no, a, 5);
     e->abbr_var = abbr_intern(e, DW_TAG_variable, DW_CHILDREN_no, a, 5);
   }
   {
     DebugAbbrevAttr a[] = {{DW_AT_external, DW_FORM_flag_present, 0},
                            {DW_AT_name, DW_FORM_strx4, 0},
                            {DW_AT_decl_file, DW_FORM_udata, 0},
                            {DW_AT_decl_line, DW_FORM_udata, 0},
                            {DW_AT_type, DW_FORM_ref4, 0},
                            {DW_AT_location, DW_FORM_exprloc, 0}};
     e->abbr_var_external =
         abbr_intern(e, DW_TAG_variable, DW_CHILDREN_no, a, 6);
   }
   {
     e->abbr_lexical_block =
         abbr_intern(e, DW_TAG_lexical_block, DW_CHILDREN_yes, NULL, 0);
   }
 }
 
 /* ---------------------------------------------------------------- */
 /* Per-type DIE emission. */
 
 static void emit_type_die(EmitCtx* e, DebugTypeId id);
 
 static void emit_type_ref(EmitCtx* e, DebugTypeId tid) {
   u32 ofs = buf_pos(&e->info_body);
   u32 placeholder = 0;
   buf_write(&e->info_body, &placeholder, 4);
   if (tid != DEBUG_TYPE_NONE) {
     add_fixup(e, ofs, tid);
   }
 }
 
 static u8 base_enc(DebugBaseEncoding enc) {
   switch (enc) {
     case DEBUG_BE_BOOL:
       return DW_ATE_boolean;
     case DEBUG_BE_SIGNED:
       return DW_ATE_signed;
     case DEBUG_BE_UNSIGNED:
       return DW_ATE_unsigned;
     case DEBUG_BE_SIGNED_CHAR:
       return DW_ATE_signed_char;
     case DEBUG_BE_UNSIGNED_CHAR:
       return DW_ATE_unsigned_char;
     case DEBUG_BE_FLOAT:
       return DW_ATE_float;
     case DEBUG_BE_UTF:
       return DW_ATE_UTF;
     case DEBUG_BE_ADDRESS:
       return DW_ATE_address;
   }
   return DW_ATE_signed;
 }
 
 static void emit_type_die(EmitCtx* e, DebugTypeId id) {
   DebugType* t;
   Debug* d = e->d;
   if (id == DEBUG_TYPE_NONE || id > d->ntypes) return;
   t = &d->types[id - 1];
   if (t->die_offset != 0) return;
   switch ((DebugTypeKind)t->kind) {
     case DTK_VOID:
       /* No DIE — t->die_offset stays 0; refs will encode as 0 (consumer
        * interprets as void). */
       return;
     case DTK_BASE:
       t->die_offset = buf_pos(&e->info_body);
       form_uleb(&e->info_body, e->abbr_base);
       emit_strx4(e, &e->info_body, t->name);
       form_u8(&e->info_body, base_enc((DebugBaseEncoding)t->base_encoding));
       form_u8(&e->info_body, (u8)t->byte_size);
       return;
     case DTK_PTR:
       t->die_offset = buf_pos(&e->info_body);
       form_uleb(&e->info_body, e->abbr_ptr);
       form_u8(&e->info_body, (u8)t->byte_size);
       emit_type_ref(e, t->inner);
       return;
     case DTK_TYPEDEF:
       t->die_offset = buf_pos(&e->info_body);
       form_uleb(&e->info_body, e->abbr_typedef);
       emit_strx4(e, &e->info_body, t->name);
       emit_type_ref(e, t->inner);
       return;
     case DTK_CONST:
       t->die_offset = buf_pos(&e->info_body);
       form_uleb(&e->info_body, e->abbr_qual_const);
       emit_type_ref(e, t->inner);
       return;
     case DTK_VOLATILE:
       t->die_offset = buf_pos(&e->info_body);
       form_uleb(&e->info_body, e->abbr_qual_volatile);
       emit_type_ref(e, t->inner);
       return;
     case DTK_RESTRICT:
       t->die_offset = buf_pos(&e->info_body);
       form_uleb(&e->info_body, e->abbr_qual_restrict);
       emit_type_ref(e, t->inner);
       return;
     case DTK_ARRAY:
       t->die_offset = buf_pos(&e->info_body);
       form_uleb(&e->info_body, e->abbr_array);
       emit_type_ref(e, t->inner);
       if (t->array_count) {
         form_uleb(&e->info_body, e->abbr_array_subrange);
         form_uleb(&e->info_body, t->array_count);
       } else {
         form_uleb(&e->info_body, e->abbr_array_subrange_unbounded);
       }
       form_uleb(&e->info_body, 0);
       return;
     case DTK_FUNC: {
       u32 i;
       t->die_offset = buf_pos(&e->info_body);
       form_uleb(&e->info_body, e->abbr_func_type);
       emit_type_ref(e, t->inner);
       /* DW_AT_prototyped flag_present has no body */
       for (i = 0; i < t->nparams; ++i) {
         form_uleb(&e->info_body, e->abbr_func_type_param);
         emit_type_ref(e, t->params[i]);
       }
       form_uleb(&e->info_body, 0);
       return;
     }
     case DTK_RECORD: {
       u32 i;
       t->die_offset = buf_pos(&e->info_body);
       form_uleb(&e->info_body, t->is_union ? e->abbr_union : e->abbr_struct);
       emit_strx4(e, &e->info_body, t->name);
       form_uleb(&e->info_body, t->byte_size);
       for (i = 0; i < t->nfields; ++i) {
         DebugRecField* f = &t->fields[i];
         form_uleb(&e->info_body,
                   f->bit_width ? e->abbr_member_bitfield : e->abbr_member);
         emit_strx4(e, &e->info_body, f->name);
         emit_type_ref(e, f->type);
         form_uleb(&e->info_body, f->byte_offset);
         if (f->bit_width) {
           form_uleb(&e->info_body, f->bit_offset);
           form_uleb(&e->info_body, f->bit_width);
         }
       }
       form_uleb(&e->info_body, 0);
       return;
     }
     case DTK_ENUM: {
       u32 i;
       DebugType* base;
       t->die_offset = buf_pos(&e->info_body);
       form_uleb(&e->info_body, e->abbr_enum);
       emit_strx4(e, &e->info_body, t->name);
       emit_type_ref(e, t->inner);
       base = (t->inner != DEBUG_TYPE_NONE && t->inner <= e->d->ntypes)
                  ? &e->d->types[t->inner - 1]
                  : NULL;
       form_uleb(&e->info_body, base ? base->byte_size : 4);
       for (i = 0; i < t->nenums; ++i) {
         form_uleb(&e->info_body, e->abbr_enum_val);
         emit_strx4(e, &e->info_body, t->enum_vals[i].name);
         form_sleb(&e->info_body, t->enum_vals[i].value);
       }
       form_uleb(&e->info_body, 0);
       return;
     }
   }
 }
 
 /* ---------------------------------------------------------------- */
 /* Variable / scope emission. */
 
 static void emit_var_loc_exprloc(EmitCtx* e, Buf* b, DebugVarLoc loc) {
   u8 expr[32];
   u32 n = 0;
   u32 addr_payload_off = UINT32_MAX;
   switch ((DebugVarLocKind)loc.kind) {
     case DVL_REG:
       if (loc.v.reg < 32) {
         expr[n++] = (u8)(DW_OP_reg0 + loc.v.reg);
       } else {
         expr[n++] = DW_OP_regx;
         n += form_uleb_inline(&expr[n], loc.v.reg);
       }
       break;
     case DVL_FRAME:
       expr[n++] = DW_OP_fbreg;
       n += form_sleb_inline(&expr[n], loc.v.frame_ofs);
       break;
     case DVL_GLOBAL: {
       u32 i;
       expr[n++] = DW_OP_addr;
       addr_payload_off = n;
       for (i = 0; i < e->d->c->target.ptr_size; ++i) expr[n++] = 0;
       break;
     }
   }
   form_uleb(b, n);
   {
     u32 expr_start = buf_pos(b);
     buf_write(b, expr, n);
     if (loc.kind == DVL_GLOBAL && addr_payload_off != UINT32_MAX) {
       add_addr_reloc(e, &e->info_relocs, &e->ninfo_relocs, &e->info_relocs_cap,
                      expr_start + addr_payload_off, loc.v.global);
     }
   }
 }
 
 static void emit_var_die(EmitCtx* e, DebugVarDIE* v) {
   u32 abbrev = v->is_param ? e->abbr_param
                            : (v->external ? e->abbr_var_external : e->abbr_var);
   v->die_offset = buf_pos(&e->info_body);
   form_uleb(&e->info_body, abbrev);
   /* DW_AT_external is flag_present and carries no body. */
   emit_strx4(e, &e->info_body, v->name);
   form_uleb(&e->info_body, debug_file(e->d, v->decl.file_id));
   form_uleb(&e->info_body, v->decl.line);
   emit_type_ref(e, v->type);
   emit_var_loc_exprloc(e, &e->info_body, v->loc);
 }
 
 static void emit_scope_subtree(EmitCtx* e, DebugFunc* f, i32 scope_idx);
 
 static void emit_vars_in_scope(EmitCtx* e, DebugFunc* f, i32 scope_idx) {
   u32 i;
   for (i = 0; i < f->nvars; ++i) {
     DebugVarDIE* v = &f->vars[i];
     if (v->is_param) continue;
     if (v->scope_idx == scope_idx) emit_var_die(e, v);
   }
   {
     u32 s;
     for (s = 0; s < f->nscopes; ++s) {
       if (f->scopes[s].parent_idx == scope_idx) {
         emit_scope_subtree(e, f, (i32)s);
       }
     }
   }
 }
 
 static void emit_scope_subtree(EmitCtx* e, DebugFunc* f, i32 scope_idx) {
   f->scopes[scope_idx].die_offset = buf_pos(&e->info_body);
   form_uleb(&e->info_body, e->abbr_lexical_block);
   emit_vars_in_scope(e, f, scope_idx);
   form_uleb(&e->info_body, 0);
 }
 
 static void emit_subprogram_die(EmitCtx* e, DebugFunc* f) {
   const ObjSym* osym = obj_symbol_get(e->ob, f->sym);
   Sym name = osym ? osym->name : 0;
   u32 reloc_off;
   u32 fn_size;
   DebugTypeId ret_type = DEBUG_TYPE_NONE;
   if (f->fn_type != DEBUG_TYPE_NONE && f->fn_type <= e->d->ntypes) {
     DebugType* tt = &e->d->types[f->fn_type - 1];
     if (tt->kind == DTK_FUNC) ret_type = tt->inner;
   }
   f->die_offset = buf_pos(&e->info_body);
   form_uleb(&e->info_body, e->abbr_subprogram);
   /* DW_AT_external (flag_present, no body) */
   emit_strx4(e, &e->info_body, name);
   form_uleb(&e->info_body, debug_file(e->d, f->decl.file_id));
   form_uleb(&e->info_body, f->decl.line);
   emit_type_ref(e, ret_type);
   reloc_off = buf_pos(&e->info_body);
   {
     u8 zero8[8] = {0};
     buf_write(&e->info_body, zero8, e->d->c->target.ptr_size);
   }
   add_addr_reloc(e, &e->info_relocs, &e->ninfo_relocs, &e->info_relocs_cap,
                  reloc_off, f->sym);
   fn_size = f->has_pc_range ? (f->end_ofs - f->begin_ofs) : 0;
   form_u32(&e->info_body, fn_size);
   {
     u8 frame_expr[1] = {DW_OP_call_frame_cfa};
     form_uleb(&e->info_body, sizeof(frame_expr));
     buf_write(&e->info_body, frame_expr, sizeof(frame_expr));
   }
   /* Children: params first, then top-level locals/scopes. */
   {
     u32 i;
     u32 emitted_params = 0;
     for (i = 0; i < f->nvars; ++i) {
       if (f->vars[i].is_param) {
         emit_var_die(e, &f->vars[i]);
         emitted_params++;
       }
     }
     if (!emitted_params && f->fn_type != DEBUG_TYPE_NONE &&
         f->fn_type <= e->d->ntypes) {
       DebugType* tt = &e->d->types[f->fn_type - 1];
       if (tt->kind == DTK_FUNC) {
         for (i = 0; i < tt->nparams; ++i) {
           form_uleb(&e->info_body, e->abbr_func_type_param);
           emit_type_ref(e, tt->params[i]);
         }
       }
     }
     emit_vars_in_scope(e, f, -1);
     form_uleb(&e->info_body, 0);
   }
 }
 
 /* ---------------------------------------------------------------- */
 /* Section flushing. */
 
 static ObjSecId mk_section(EmitCtx* e, const char* name) {
   Sym n = pool_intern_slice(e->pool, slice_from_cstr(name));
   return obj_section(e->ob, n, SEC_DEBUG, 0, 1);
 }
 
 /* Pre-create one SK_SECTION ObjSym pointing at `sec`. Section symbols are
  * nameless (Sym 0); identity is the section_id they reference. SB_LOCAL
  * because section symbols are always local in ELF/Mach-O. */
 static ObjSymId mk_section_sym(EmitCtx* e, ObjSecId sec) {
   return obj_symbol(e->ob, 0, SB_LOCAL, SK_SECTION, sec, 0, 0);
 }
 
 static void flatten_to_section(EmitCtx* e, ObjSecId sec, const Buf* src) {
   u32 total = buf_pos(src);
   if (total == 0) return;
   {
     u8* dst = obj_reserve(e->ob, sec, total);
     if (!dst) return;
     buf_flatten(src, dst);
   }
 }
 
 static void emit_section_str(EmitCtx* e) {
   flatten_to_section(e, e->sec_str, &e->str.buf);
 }
 
 static void emit_section_line_str(EmitCtx* e) {
   flatten_to_section(e, e->sec_line_str, &e->line_str.buf);
 }
 
 static void emit_section_str_offsets(EmitCtx* e) {
   Buf b;
   u32 i;
   u32 unit_length;
   u32 entries_off; /* byte offset of first entry within the section */
   buf_init(&b, e->heap);
   unit_length = 4 + e->str.nsyms * 4; /* version+pad + N*4 */
   form_u32(&b, unit_length);
   form_u16(&b, 5);
   form_u16(&b, 0);
   entries_off = buf_pos(&b);
   for (i = 0; i < e->str.nsyms; ++i) {
     /* Write the literal offset (so a bare-`.o` reader that doesn't apply
      * relocs still sees the correct value), and *also* emit an R_ABS32
      * reloc against .debug_str with addend = same literal.  When the
      * linker or JIT view-builder applies the reloc it overwrites the
      * slot with S + addend; for a normal `.o` (debug sections not laid
      * out) S=0 so the value is unchanged, and for the concatenated JIT
      * view S = view-prefix into .debug_str so the slot picks up the
      * right per-input offset. */
     u32* ofs = SymToU32_get(&e->str.by_sym, e->str.syms[i]);
     form_u32(&b, ofs ? *ofs : 0);
   }
   flatten_to_section(e, e->sec_str_off, &b);
   for (i = 0; i < e->str.nsyms; ++i) {
     u32* ofs = SymToU32_get(&e->str.by_sym, e->str.syms[i]);
     obj_reloc(e->ob, e->sec_str_off, entries_off + i * 4u, R_ABS32, e->ssym_str,
               (i64)(ofs ? *ofs : 0));
   }
   buf_fini(&b);
 }
 
 static void emit_section_abbrev(EmitCtx* e) {
   Buf b;
   buf_init(&b, e->heap);
   abbrev_encode(&e->abbr, &b);
   flatten_to_section(e, e->sec_abbrev, &b);
   buf_fini(&b);
 }
 
 static ArchDwarfOps debug_dwarf_ops(const Debug* d) {
   const ArchImpl* arch = arch_for_compiler(d ? d->c : NULL);
   ArchDwarfOps ops;
   ops.min_inst_len = 1u;
   ops.max_ops_per_inst = 1u;
   ops.pad[0] = 0;
   ops.pad[1] = 0;
   if (arch && arch->dwarf) {
     if (arch->dwarf->min_inst_len) ops.min_inst_len = arch->dwarf->min_inst_len;
     if (arch->dwarf->max_ops_per_inst)
       ops.max_ops_per_inst = arch->dwarf->max_ops_per_inst;
   }
   return ops;
 }
 
 static void line_advance_pc(Buf* prog, u32 byte_delta, u32 min_inst_len) {
   if (byte_delta == 0) return;
   if (min_inst_len == 0) min_inst_len = 1;
   if ((byte_delta % min_inst_len) == 0) {
     form_u8(prog, DW_LNS_advance_pc);
     form_uleb(prog, byte_delta / min_inst_len);
     return;
   }
 
   while (byte_delta > 0xffffu) {
     form_u8(prog, DW_LNS_fixed_advance_pc);
     form_u16(prog, 0xffffu);
     byte_delta -= 0xffffu;
   }
   form_u8(prog, DW_LNS_fixed_advance_pc);
   form_u16(prog, (u16)byte_delta);
 }
 
 /* .debug_line program emission.
  *
  * Header layout (32-bit DWARF5):
  *   unit_length         u32
  *   version             u16 = 5
  *   address_size        u8
  *   segment_selector_sz u8
  *   header_length       u32  (excludes itself + earlier header fields)
  *   ...
  *
  * We emit, then track the program-start byte offset within the section so
  * we can place address relocations. */
 static void emit_section_line(EmitCtx* e) {
   Buf prog;
   Buf hdr_body; /* header from min_inst_length onward */
   Buf out;
   Pool* pool = e->pool;
   u32 i, j;
   u32 dir_count;
   Sym* dirs = NULL;
   u32 ndirs = 0, dirs_cap = 0;
   ArchDwarfOps dwarf_ops = debug_dwarf_ops(e->d);
   const u32 min_inst_len = dwarf_ops.min_inst_len ? dwarf_ops.min_inst_len : 1u;
   const u32 max_ops_per_inst =
       dwarf_ops.max_ops_per_inst ? dwarf_ops.max_ops_per_inst : 1u;
   /* Pending line_strp relocs.  Each slot is a u32 in hdr_body at
    * `slot[k].at` with addend `slot[k].ofs` (the resolved .debug_line_str
    * offset).  Translated to section offsets and turned into R_ABS32
    * relocs against e->ssym_line_str after we know hdr_body's location
    * within the section. */
   struct LineStrpSlot {
     u32 at;
     u32 ofs;
   }* lsp_slots = NULL;
   u32 nlsp = 0, lsp_cap = 0;
 
   buf_init(&prog, e->heap);
   buf_init(&hdr_body, e->heap);
   buf_init(&out, e->heap);
 
   /* Build the program first (so we know its length). */
   for (i = 0; i < e->d->nfuncs; ++i) {
     DebugFunc* f = &e->d->funcs[i];
     LineRow* prev = NULL;
     u8 addr_size;
     if (!f->has_pc_range) continue;
     addr_size = e->d->c->target.ptr_size;
     /* DW_LNE_set_address */
     form_u8(&prog, 0);
     form_uleb(&prog, 1 + addr_size);
     form_u8(&prog, DW_LNE_set_address);
     {
       u32 buf_ofs = buf_pos(&prog);
       u8 zeros[8] = {0};
       buf_write(&prog, zeros, addr_size);
       add_addr_reloc(e, &e->line_relocs, &e->nline_relocs, &e->line_relocs_cap,
                      buf_ofs, f->sym);
     }
     for (j = 0; j < f->nrows; ++j) {
       LineRow* r = &f->rows[j];
       u32 dwfile = debug_file(e->d, r->loc.file_id);
       i64 prev_line = prev ? prev->loc.line : 1;
       u32 prev_offset = prev ? prev->offset : f->begin_ofs;
       u32 pc_delta = r->offset - prev_offset;
       i64 line_delta;
       if (!prev || prev->loc.file_id != r->loc.file_id) {
         form_u8(&prog, DW_LNS_set_file);
         form_uleb(&prog, dwfile);
       }
       if (r->loc.col != (prev ? prev->loc.col : 0)) {
         form_u8(&prog, DW_LNS_set_column);
         form_uleb(&prog, r->loc.col);
       }
       if (pc_delta != 0) {
         line_advance_pc(&prog, pc_delta, min_inst_len);
       }
       line_delta = (i64)r->loc.line - prev_line;
       if (line_delta != 0) {
         form_u8(&prog, DW_LNS_advance_line);
         form_sleb(&prog, line_delta);
       }
       form_u8(&prog, DW_LNS_copy);
       prev = r;
     }
     /* advance to function end before end_sequence */
     {
       u32 last = prev ? prev->offset : f->begin_ofs;
       u32 delta = f->end_ofs - last;
       if (delta != 0) {
         line_advance_pc(&prog, delta, min_inst_len);
       }
     }
     form_u8(&prog, 0);
     form_uleb(&prog, 1);
     form_u8(&prog, DW_LNE_end_sequence);
   }
 
   /* Build header body (from min_inst_length onward). */
   form_u8(&hdr_body, (u8)min_inst_len);     /* min_inst_length */
   form_u8(&hdr_body, (u8)max_ops_per_inst); /* max_ops_per_inst */
   form_u8(&hdr_body, 1);                    /* default_is_stmt = 1 */
   form_u8(&hdr_body, (u8)(i8)-5);           /* line_base */
   form_u8(&hdr_body, 14);                   /* line_range */
   form_u8(&hdr_body, 13); /* opcode_base = #standard ops + 1 */
   /* DWARF 5 standard_opcode_lengths for opcodes 1..12 */
   {
     u8 lens[12];
     lens[0] = 0;  /* copy */
     lens[1] = 1;  /* advance_pc */
     lens[2] = 1;  /* advance_line */
     lens[3] = 1;  /* set_file */
     lens[4] = 1;  /* set_column */
     lens[5] = 0;  /* negate_stmt */
     lens[6] = 0;  /* set_basic_block */
     lens[7] = 0;  /* const_add_pc */
     lens[8] = 1;  /* fixed_advance_pc */
     lens[9] = 0;  /* set_prologue_end */
     lens[10] = 0; /* set_epilogue_begin */
     lens[11] = 1; /* set_isa */
     buf_write(&hdr_body, lens, 12);
   }
   /* directories */
   form_u8(&hdr_body, 1);
   form_uleb(&hdr_body, DW_LNCT_path);
   form_uleb(&hdr_body, DW_FORM_line_strp);
   /* dedup directories; index 0 is primary file's dir. */
   if (e->d->nfiles > 0) {
     if (!VEC_GROW(e->heap, dirs, dirs_cap, ndirs + 1))
       dirs[ndirs++] = e->d->files[0].dir;
   } else {
     if (!VEC_GROW(e->heap, dirs, dirs_cap, ndirs + 1))
       dirs[ndirs++] = pool_intern_slice(pool, SLICE_LIT(""));
   }
   for (i = 1; i < e->d->nfiles; ++i) {
     Sym dir = e->d->files[i].dir;
     u32 di;
     int found = 0;
     for (di = 0; di < ndirs; ++di) {
       if (dirs[di] == dir) {
         found = 1;
         break;
       }
     }
     if (!found) {
       if (!VEC_GROW(e->heap, dirs, dirs_cap, ndirs + 1)) dirs[ndirs++] = dir;
     }
   }
   dir_count = ndirs;
   form_uleb(&hdr_body, dir_count);
   for (i = 0; i < dir_count; ++i) {
     u32 at = buf_pos(&hdr_body);
     u32 ofs = line_str_offset(e, dirs[i]);
     form_u32(&hdr_body, ofs); /* literal; also bound to a reloc below */
     if (!VEC_GROW(e->heap, lsp_slots, lsp_cap, nlsp + 1)) {
       lsp_slots[nlsp].at = at;
       lsp_slots[nlsp].ofs = ofs;
       nlsp++;
     }
   }
 
   /* file_name_entry_format: 2 entries */
   form_u8(&hdr_body, 2);
   form_uleb(&hdr_body, DW_LNCT_path);
   form_uleb(&hdr_body, DW_FORM_line_strp);
   form_uleb(&hdr_body, DW_LNCT_directory_index);
   form_uleb(&hdr_body, DW_FORM_udata);
 
   if (e->d->nfiles == 0) {
     u32 at;
     u32 ofs;
     form_uleb(&hdr_body, 1);
     at = buf_pos(&hdr_body);
     ofs = line_str_offset(e, pool_intern_slice(pool, SLICE_LIT("")));
     form_u32(&hdr_body, ofs);
     if (!VEC_GROW(e->heap, lsp_slots, lsp_cap, nlsp + 1)) {
       lsp_slots[nlsp].at = at;
       lsp_slots[nlsp].ofs = ofs;
       nlsp++;
     }
     form_uleb(&hdr_body, 0);
   } else {
     form_uleb(&hdr_body, e->d->nfiles);
     for (i = 0; i < e->d->nfiles; ++i) {
       DebugFile* df = &e->d->files[i];
       u32 di;
       u32 at = buf_pos(&hdr_body);
       u32 ofs = line_str_offset(e, df->base);
       form_u32(&hdr_body, ofs);
       if (!VEC_GROW(e->heap, lsp_slots, lsp_cap, nlsp + 1)) {
         lsp_slots[nlsp].at = at;
         lsp_slots[nlsp].ofs = ofs;
         nlsp++;
       }
       for (di = 0; di < ndirs; ++di) {
         if (dirs[di] == df->dir) break;
       }
       form_uleb(&hdr_body, di < ndirs ? di : 0);
     }
   }
 
   if (dirs) e->heap->free(e->heap, dirs, sizeof(Sym) * dirs_cap);
 
   /* Compose final section bytes: unit-length header + hdr_body + program. */
   {
     u32 hl = buf_pos(&hdr_body);
     u32 plen = buf_pos(&prog);
     /* unit_length = (everything after the unit_length field itself) */
     u32 unit_length = 2 + 1 + 1 + 4 + hl + plen;
     u8 addr_size = e->d->c->target.ptr_size;
     form_u32(&out, unit_length);
     form_u16(&out, 5);
     form_u8(&out, addr_size);
     form_u8(&out, 0);
     form_u32(&out, hl);
     /* Append hdr_body bytes */
     {
       u8* tmp = (u8*)e->heap->alloc(e->heap, hl ? hl : 1, 1);
       if (tmp && hl) {
         buf_flatten(&hdr_body, tmp);
         buf_write(&out, tmp, hl);
       }
       if (tmp) e->heap->free(e->heap, tmp, hl ? hl : 1);
     }
     /* Append program bytes */
     {
       u8* tmp = (u8*)e->heap->alloc(e->heap, plen ? plen : 1, 1);
       if (tmp && plen) {
         buf_flatten(&prog, tmp);
         buf_write(&out, tmp, plen);
       }
       if (tmp) e->heap->free(e->heap, tmp, plen ? plen : 1);
     }
     flatten_to_section(e, e->sec_line, &out);
     /* program-start in section bytes = 12 (unit_length+ver+addr+seg+hl) + hl.
      * hdr_body sits at section offset 12 (right after the unit header),
      * so a line_strp slot at hdr_body offset `at` is at section offset
      * `12 + at`. */
     {
       u32 prog_start = 12 + hl;
       u32 hdr_start = 12;
       u32 k;
       for (k = 0; k < e->nline_relocs; ++k) {
         obj_reloc(e->ob, e->sec_line, prog_start + e->line_relocs[k].buf_offset,
                   debug_addr_reloc_kind(e->d), e->line_relocs[k].sym, 0);
       }
       for (k = 0; k < nlsp; ++k) {
         obj_reloc(e->ob, e->sec_line, hdr_start + lsp_slots[k].at, R_ABS32,
                   e->ssym_line_str, (i64)lsp_slots[k].ofs);
       }
     }
   }
   if (lsp_slots)
     e->heap->free(e->heap, lsp_slots, sizeof(*lsp_slots) * lsp_cap);
   buf_fini(&prog);
   buf_fini(&hdr_body);
   buf_fini(&out);
 }
 
 /* .debug_aranges */
 static void emit_section_aranges(EmitCtx* e) {
   Buf b;
   u32 i;
   u32 unit_length;
   u8 addr_size = e->d->c->target.ptr_size;
   u32 body_start;
   u32 padding;
   buf_init(&b, e->heap);
   form_u32(&b, 0); /* unit_length placeholder */
   form_u16(&b, 2); /* aranges version */
   form_u32(&b, 0); /* debug_info_offset — filled by R_ABS32 reloc below */
   form_u8(&b, addr_size);
   form_u8(&b, 0);
   body_start = buf_pos(&b);
   /* Tuples are aligned to 2*addr_size from the section start. */
   {
     u32 align = (u32)addr_size * 2;
     u32 mod = body_start % align;
     padding = mod ? (align - mod) : 0;
     while (padding--) {
       u8 z = 0;
       buf_write(&b, &z, 1);
     }
   }
   for (i = 0; i < e->d->nfuncs; ++i) {
     DebugFunc* f = &e->d->funcs[i];
     if (!f->has_pc_range) continue;
     {
       u32 reloc_at = buf_pos(&b);
       u8 zeros[8] = {0};
       buf_write(&b, zeros, addr_size);
       add_addr_reloc(e, &e->aranges_relocs, &e->naranges_relocs,
                      &e->aranges_relocs_cap, reloc_at, f->sym);
     }
     {
       u32 fn_size = f->end_ofs - f->begin_ofs;
       if (addr_size == 8)
         form_u64(&b, fn_size);
       else
         form_u32(&b, fn_size);
     }
   }
   /* Terminator (zero, zero) */
   {
     u8 zeros[16] = {0};
     buf_write(&b, zeros, addr_size * 2);
   }
   unit_length = buf_pos(&b) - 4;
   {
     u8 le[4];
     le[0] = (u8)(unit_length & 0xff);
     le[1] = (u8)((unit_length >> 8) & 0xff);
     le[2] = (u8)((unit_length >> 16) & 0xff);
     le[3] = (u8)((unit_length >> 24) & 0xff);
     buf_patch(&b, 0, le, 4);
   }
   flatten_to_section(e, e->sec_aranges, &b);
   /* debug_info_offset (header byte 6) points at this CU within
    * .debug_info.  Emit it as a section-relative R_ABS32 against the
    * .debug_info section symbol (addend 0 — one CU per object at
    * offset 0) so that when the linker / JIT view concatenate multiple
    * inputs, each aranges unit is rebased to its CU's merged offset.
    * Without this every unit would keep offset 0 and addr2line would
    * map all addresses to the first input's CU. */
   obj_reloc(e->ob, e->sec_aranges, 6u, R_ABS32, e->ssym_info, 0);
   for (i = 0; i < e->naranges_relocs; ++i) {
     obj_reloc(e->ob, e->sec_aranges, e->aranges_relocs[i].buf_offset,
               debug_addr_reloc_kind(e->d), e->aranges_relocs[i].sym, 0);
   }
   buf_fini(&b);
 }
 
 /* .debug_rnglists */
 static void emit_section_rnglists(EmitCtx* e) {
   Buf b;
   u32 unit_length;
   u32 i;
   u8 addr_size = e->d->c->target.ptr_size;
   buf_init(&b, e->heap);
   form_u32(&b, 0); /* placeholder unit_length */
   form_u16(&b, 5);
   form_u8(&b, addr_size);
   form_u8(&b, 0);
   form_u32(&b, 0); /* offset_entry_count */
   for (i = 0; i < e->d->nfuncs; ++i) {
     DebugFunc* f = &e->d->funcs[i];
     if (!f->has_pc_range) continue;
     form_u8(&b, DW_RLE_start_length);
     {
       u32 reloc_at = buf_pos(&b);
       u8 zeros[8] = {0};
       buf_write(&b, zeros, addr_size);
       add_addr_reloc(e, &e->rng_relocs, &e->nrng_relocs, &e->nrng_relocs_cap,
                      reloc_at, f->sym);
     }
     form_uleb(&b, f->end_ofs - f->begin_ofs);
   }
   form_u8(&b, DW_RLE_end_of_list);
   unit_length = buf_pos(&b) - 4;
   {
     u8 le[4];
     le[0] = (u8)(unit_length & 0xff);
     le[1] = (u8)((unit_length >> 8) & 0xff);
     le[2] = (u8)((unit_length >> 16) & 0xff);
     le[3] = (u8)((unit_length >> 24) & 0xff);
     buf_patch(&b, 0, le, 4);
   }
   flatten_to_section(e, e->sec_rnglists, &b);
   for (i = 0; i < e->nrng_relocs; ++i) {
     obj_reloc(e->ob, e->sec_rnglists, e->rng_relocs[i].buf_offset,
               debug_addr_reloc_kind(e->d), e->rng_relocs[i].sym, 0);
   }
   buf_fini(&b);
 }
 
 /* .debug_info: prepend CU header, append body, apply relocs and fixups. */
 static void emit_section_info(EmitCtx* e) {
   Buf out;
   u32 cu_header_size = 12;
   u32 body_size = buf_pos(&e->info_body);
   u32 unit_length = cu_header_size - 4 + body_size;
   buf_init(&out, e->heap);
   form_u32(&out, unit_length);
   form_u16(&out, 5);
   form_u8(&out, DW_UT_compile);
   form_u8(&out, e->d->c->target.ptr_size);
   form_u32(&out, 0); /* debug_abbrev_offset — filled by R_ABS32 reloc below */
   /* Append body */
   {
     u32 plen = body_size;
     u8* tmp = (u8*)e->heap->alloc(e->heap, plen ? plen : 1, 1);
     if (tmp && plen) {
       buf_flatten(&e->info_body, tmp);
       buf_write(&out, tmp, plen);
     }
     if (tmp) e->heap->free(e->heap, tmp, plen ? plen : 1);
   }
   flatten_to_section(e, e->sec_info, &out);
   /* CU header cross-section refs: debug_abbrev_offset at byte 8.  Root
    * DIE cross-section refs (stmt_list / ranges / str_offsets_base) live
    * at body offsets captured during CU-body construction; section offset
    * is cu_header_size + body offset.  Addend carries the in-target
    * offset (0 for abbrev/stmt_list, 12 for rnglists past its header, 8
    * for str_offsets past its header). */
   obj_reloc(e->ob, e->sec_info, 8u, R_ABS32, e->ssym_abbrev, 0);
   obj_reloc(e->ob, e->sec_info, cu_header_size + e->root_stmt_list_at, R_ABS32,
             e->ssym_line, 0);
   obj_reloc(e->ob, e->sec_info, cu_header_size + e->root_ranges_at, R_ABS32,
             e->ssym_rnglists, 12);
   obj_reloc(e->ob, e->sec_info, cu_header_size + e->root_str_off_base_at,
             R_ABS32, e->ssym_str_off, 8);
   /* Apply forward DIE refs (DW_FORM_ref4 = CU-relative, where the CU
    * starts at the unit_length field. body offset 0 is at section
    * offset cu_header_size = 12 (post-header, post-unit_length). DW5
    * ref4 is unit-relative, i.e. distance from the start of the unit
    * (i.e. the unit_length field itself), so the on-disk u32 stored is
    * cu_header_size + target_body_offset. */
   {
     u32 i;
     for (i = 0; i < e->nfixups; ++i) {
       DieFixup* fx = &e->fixups[i];
       DebugType* tt =
           (fx->target != DEBUG_TYPE_NONE && fx->target <= e->d->ntypes)
               ? &e->d->types[fx->target - 1]
               : NULL;
       u32 target_body_ofs = (tt && tt->die_offset) ? tt->die_offset : 0;
       u32 cu_relative =
           target_body_ofs ? (cu_header_size + target_body_ofs) : 0;
       u8 le[4];
       le[0] = (u8)(cu_relative & 0xff);
       le[1] = (u8)((cu_relative >> 8) & 0xff);
       le[2] = (u8)((cu_relative >> 16) & 0xff);
       le[3] = (u8)((cu_relative >> 24) & 0xff);
       obj_patch(e->ob, e->sec_info, cu_header_size + fx->buf_offset, le, 4);
     }
     for (i = 0; i < e->ninfo_relocs; ++i) {
       obj_reloc(e->ob, e->sec_info,
                 cu_header_size + e->info_relocs[i].buf_offset,
                 debug_addr_reloc_kind(e->d), e->info_relocs[i].sym, 0);
     }
   }
   buf_fini(&out);
 }
 
 /* ---------------------------------------------------------------- */
 
 void debug_emit(Debug* d) {
   EmitCtx ec;
   Pool* pool = d->c->global;
   Sym producer_sym;
   Sym primary_dir = 0, primary_base = 0;
   u32 i;
 
   /* Zero out via memset on a sized chunk. Avoid forms that clang lowers
    * to bzero on this size. We zero with an explicit byte-loop fallback
    * to match the lib_deps allowlist (which forbids _bzero). */
   {
     u8* p = (u8*)&ec;
     size_t k;
     for (k = 0; k < sizeof(ec); ++k) p[k] = 0;
   }
   ec.d = d;
   ec.heap = d->heap;
   ec.pool = pool;
   ec.ob = d->ob;
   buf_init(&ec.info_body, d->heap);
   str_init(&ec.str, d->heap);
   str_init(&ec.line_str, d->heap);
   abbrev_init(&ec.abbr, d->heap);
 
   resolve_abbrevs(&ec);
 
   /* Pre-create every debug section + a paired SK_SECTION ObjSym, before
    * any DIE/program payload is emitted.  Cross-section relocations
    * (CU-header debug_abbrev_offset, root-DIE stmt_list / ranges /
    * str_offsets_base, .debug_line line_strp slots, .debug_str_offsets
    * entries) name these symbols, so they must exist by the time the
    * relocs are recorded.  Section order in the output `.o` is fixed by
    * obj_section call order and matches the previous emission. */
   ec.sec_abbrev = mk_section(&ec, ".debug_abbrev");
   ec.sec_line = mk_section(&ec, ".debug_line");
   ec.sec_aranges = mk_section(&ec, ".debug_aranges");
   ec.sec_rnglists = mk_section(&ec, ".debug_rnglists");
   ec.sec_info = mk_section(&ec, ".debug_info");
   ec.sec_str = mk_section(&ec, ".debug_str");
   ec.sec_line_str = mk_section(&ec, ".debug_line_str");
   ec.sec_str_off = mk_section(&ec, ".debug_str_offsets");
   ec.ssym_abbrev = mk_section_sym(&ec, ec.sec_abbrev);
   ec.ssym_line = mk_section_sym(&ec, ec.sec_line);
   ec.ssym_rnglists = mk_section_sym(&ec, ec.sec_rnglists);
   ec.ssym_str = mk_section_sym(&ec, ec.sec_str);
   ec.ssym_line_str = mk_section_sym(&ec, ec.sec_line_str);
   ec.ssym_str_off = mk_section_sym(&ec, ec.sec_str_off);
   ec.ssym_info = mk_section_sym(&ec, ec.sec_info);
 
   producer_sym = pool_intern_slice(pool, SLICE_LIT("kit 0.1"));
   /* Ensure the CU's primary source file occupies file-table slot 0 before
    * we read it for DW_AT_name/comp_dir. debug_file() is otherwise first
    * invoked later (child-DIE decl_file / line program), so without this the
    * CU name and comp_dir come out empty. Seed it from the first function's
    * declaration site. */
   if (d->nfiles == 0) {
     if (d->nfuncs > 0) {
       (void)debug_file(d, d->funcs[0].decl.file_id);
     } else if (d->nglobals > 0) {
       (void)debug_file(d, d->globals[0].decl.file_id);
     }
   }
   if (d->nfiles > 0) {
     primary_dir = d->files[0].dir;
     primary_base = d->files[0].base;
   } else {
     primary_dir = pool_intern_slice(pool, SLICE_LIT(""));
     primary_base = pool_intern_slice(pool, SLICE_LIT(""));
   }
 
   /* CU root DIE */
   form_uleb(&ec.info_body, ec.abbr_cu);
   emit_strx4(&ec, &ec.info_body, producer_sym);
   form_u16(&ec.info_body, DW_LANG_C11);
   emit_strx4(&ec, &ec.info_body, primary_base);
   emit_strx4(&ec, &ec.info_body, primary_dir);
   /* DW_AT_stmt_list → offset 0 in .debug_line.  Write the literal so a
    * bare-`.o` reader still sees the correct value; the paired R_ABS32
    * reloc emitted in emit_section_info() overwrites the slot in the
    * JIT view path where multiple inputs' .debug_line sections are
    * concatenated. */
   ec.root_stmt_list_at = buf_pos(&ec.info_body);
   form_u32(&ec.info_body, 0);
   {
     u8 z[8] = {0};
     buf_write(&ec.info_body, z, d->c->target.ptr_size);
   }
   /* DW_AT_ranges → 12 bytes into .debug_rnglists, post header. */
   ec.root_ranges_at = buf_pos(&ec.info_body);
   form_u32(&ec.info_body, 12);
   /* DW_AT_str_offsets_base → 8 bytes into .debug_str_offsets, post header. */
   ec.root_str_off_base_at = buf_pos(&ec.info_body);
   form_u32(&ec.info_body, 8);
 
   for (i = 0; i < d->ntypes; ++i) emit_type_die(&ec, (DebugTypeId)(i + 1));
   for (i = 0; i < d->nglobals; ++i) emit_var_die(&ec, &d->globals[i]);
   for (i = 0; i < d->nfuncs; ++i) emit_subprogram_die(&ec, &d->funcs[i]);
   form_uleb(&ec.info_body, 0); /* end of CU children */
 
   /* Order: build sections that don't depend on later ones first. The str
    * tables are populated lazily during emission, so flush them last. */
   emit_section_abbrev(&ec);
   emit_section_line(&ec);
   emit_section_aranges(&ec);
   emit_section_rnglists(&ec);
   emit_section_info(&ec);
   emit_section_str(&ec);
   emit_section_line_str(&ec);
   emit_section_str_offsets(&ec);
 
   /* Cleanup */
   buf_fini(&ec.info_body);
   str_fini(&ec.str, ec.heap);
   str_fini(&ec.line_str, ec.heap);
   abbrev_fini_heap(&ec.abbr, ec.heap);
   if (ec.fixups)
     ec.heap->free(ec.heap, ec.fixups, sizeof(DieFixup) * ec.fixups_cap);
   if (ec.info_relocs)
     ec.heap->free(ec.heap, ec.info_relocs,
                   sizeof(AddrReloc) * ec.info_relocs_cap);
   if (ec.line_relocs)
     ec.heap->free(ec.heap, ec.line_relocs,
                   sizeof(AddrReloc) * ec.line_relocs_cap);
   if (ec.aranges_relocs)
     ec.heap->free(ec.heap, ec.aranges_relocs,
                   sizeof(AddrReloc) * ec.aranges_relocs_cap);
   if (ec.rng_relocs)
     ec.heap->free(ec.heap, ec.rng_relocs,
                   sizeof(AddrReloc) * ec.nrng_relocs_cap);
 }