kit

asm.c (57362B)

---

 /* GNU-as compatible assembler driver — arch-agnostic.
  *
  * Reads tokens from an AsmLexer, dispatches directives, manages labels and
  * section state, and forwards mnemonic lines to the per-arch instruction
  * parser.  Output goes through MCEmitter against an ObjBuilder.
  *
  * AsmLexer quirks worked around here:
  *   - `#` is both the immediate marker in asm and the token used for
  *     preprocessed-assembler line markers.
  *     `#` at BOL is a cpp linemarker → skip to next newline; elsewhere
  *     the per-arch parser treats it as the immediate prefix.
  *   - composite mnemonics (`b.eq`, `b.ne`, ...) arrive as IDENT '.' IDENT
  *     and are reassembled before dispatch.
  *   - `.text` etc. arrive as PUNCT('.') + IDENT and are stitched here.
  *
  * Symbol bookkeeping: a Sym→ObjSymId map records the symbols introduced
  * by labels, `.globl`, and operand references so a forward reference
  * (`b foo` before `foo:`) shares one symbol with its later definition.
  * A second Sym→AsmEqu map carries `.set`/`.equ` constants. */
 
 #include "asm/asm.h"
 
 #include <stdarg.h>
 #include <string.h>
 
 #include "arch/arch.h"
 #include "asm/asm_helpers.h"
 #include "asm/asm_lex.h"
 #include "core/arena.h"
 #include "core/hashmap.h"
 #include "core/heap.h"
 #include "core/pool.h"
 #include "core/slice.h"
 #include "core/vec.h"
 #include "obj/obj.h"
 #include "obj/reloc_apply.h"
 
 HASHMAP_DEFINE(SymSecMap, Sym, ObjSecId, hash_u32);
 HASHMAP_DEFINE(SymSymMap, Sym, ObjSymId, hash_u32);
 HASHMAP_DEFINE(SymU8Map, Sym, u8, hash_u32);
 
 typedef struct AsmEqu {
   i64 value;
   ObjSymId sym; /* nonzero when value is `sym + offset` */
   u8 has_sym;
   u8 pad[3];
 } AsmEqu;
 HASHMAP_DEFINE(SymEquMap, Sym, AsmEqu, hash_u32);
 
 /* A `sym1 - sym2` data difference (e.g. `.quad _end - _start`) recorded at
  * emit time and resolved after the parse, once every label is defined. The
  * field at <section,offset> already holds the net constant addend. */
 typedef struct AsmDiff {
   ObjSecId section; /* fixup site section */
   u32 offset;       /* fixup site offset within `section` */
   u32 width;        /* 1/2/4/8 — the data width */
   ObjSymId minuend;    /* sym1 */
   ObjSymId subtrahend; /* sym2 */
   i64 addend;          /* net constant addend already written into the field */
   SrcLoc loc;          /* the directive's location, for late diagnostics */
 } AsmDiff;
 
 struct AsmDriver {
   Compiler* c;
   AsmLexer* lex;
   MCEmitter* mc;
   ObjBuilder* ob;
   Pool* pool;
   Heap* heap;
 
   AsmTok cur;
   int has_cur;
 
   /* OBJ_SEC_NONE until first emit / explicit `.text` etc. */
   ObjSecId cur_sec;
 
   SymSecMap sec_map;
   SymSymMap sym_map;
   SymU8Map thumb_func_map;
   SymEquMap equ_map;
 
   /* Deferred `sym1 - sym2` data differences (resolve_sym_diffs). */
   AsmDiff* diffs;
   u32 ndiffs;
   u32 diffs_cap;
 
   Sym n_text, n_data, n_rodata, n_bss;
   u8 pending_thumb_func;
 
   ArchAsm* arch_asm;
 };
 
 /* ---- token plumbing ---- */
 
 static AsmTok d_peek(AsmDriver* d) {
   if (!d->has_cur) {
     d->cur = asm_lex_next(d->lex);
     d->has_cur = 1;
   }
   return d->cur;
 }
 
 static AsmTok d_next(AsmDriver* d) {
   AsmTok t = d_peek(d);
   d->has_cur = 0;
   return t;
 }
 
 static int d_is_eol(AsmDriver* d) {
   AsmTok t = d_peek(d);
   return t.kind == ASM_TOK_NEWLINE || t.kind == ASM_TOK_EOF;
 }
 
 static void d_skip_to_eol(AsmDriver* d) {
   while (!d_is_eol(d)) (void)d_next(d);
 }
 
 static void d_eat_eol(AsmDriver* d) {
   AsmTok t = d_peek(d);
   if (t.kind == ASM_TOK_NEWLINE) (void)d_next(d);
 }
 
 static SrcLoc d_loc(AsmDriver* d) {
   if (d->has_cur) return d->cur.loc;
   return asm_lex_loc(d->lex);
 }
 
 _Noreturn static void d_panicf(AsmDriver* d, const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   compiler_panicv(d->c, d_loc(d), fmt, ap);
   /* unreachable; va_end omitted because compiler_panicv is _Noreturn */
 }
 
 /* ---- spelling helpers ---- */
 
 static const char* asm_str(AsmDriver* d, Sym s, size_t* nout) {
   Slice sl = pool_slice(d->pool, s);
   if (nout) *nout = sl.len;
   return sl.s;
 }
 
 static int sym_eq(AsmDriver* d, Sym s, const char* lit) {
   size_t n = 0;
   const char* p = asm_str(d, s, &n);
   size_t i;
   if (!p) return 0;
   for (i = 0; i < n; ++i) {
     if (!lit[i] || p[i] != lit[i]) return 0;
   }
   return lit[n] == '\0';
 }
 
 static int starts_with(AsmDriver* d, Sym s, const char* prefix) {
   size_t n = 0;
   const char* p = asm_str(d, s, &n);
   size_t i;
   if (!p) return 0;
   for (i = 0; prefix[i]; ++i) {
     if (i >= n || p[i] != prefix[i]) return 0;
   }
   return 1;
 }
 
 /* ---- section management ---- */
 
 static ObjSecId ensure_section_ex(AsmDriver* d, Sym name, SecKind kind, u16 sem,
                                   u16 flags, u32 align) {
   ObjSecId* hit = SymSecMap_get(&d->sec_map, name);
   ObjSecId id;
   if (hit) return *hit;
   id = obj_section_ex(d->ob, name, kind, sem, flags, align, 0, OBJ_SEC_NONE, 0);
   SymSecMap_set(&d->sec_map, name, id);
   return id;
 }
 
 static ObjSecId ensure_section(AsmDriver* d, Sym name, SecKind kind, u16 flags,
                                u32 align) {
   /* A .bss section is NOBITS: it stores no bytes, only a size. Create it that
    * way (codegen does the same via obj_section_ex) so the ELF emitter writes
    * SHT_NOBITS and `.zero`/labels track bss_size, not a byte buffer — matching
    * `cc -c` so the round-tripped object isn't a writable-but-loaded .bss. */
   return ensure_section_ex(d, name, kind,
                            kind == SEC_BSS ? SSEM_NOBITS : SSEM_PROGBITS, flags,
                            align);
 }
 
 static void set_section(AsmDriver* d, Sym name, SecKind kind, u16 flags,
                         u32 align) {
   ObjSecId id = ensure_section(d, name, kind, flags, align);
   d->cur_sec = id;
   mc_set_section(d->mc, id);
 }
 
 /* ---- symbol management ---- */
 
 static ObjSymId intern_sym(AsmDriver* d, Sym name) {
   ObjSymId* hit = SymSymMap_get(&d->sym_map, name);
   if (hit) return *hit;
   ObjSymId id = obj_symbol_find(d->ob, name);
   if (id == OBJ_SYM_NONE) {
     id = obj_symbol_ex(d->ob, name, SB_LOCAL, SV_DEFAULT, SK_NOTYPE,
                        OBJ_SEC_NONE, 0, 0, 0);
   }
   SymSymMap_set(&d->sym_map, name, id);
   return id;
 }
 
 static ObjSym* sym_mut(AsmDriver* d, ObjSymId id) {
   /* obj.h gives us a const view via obj_symbol_get; the underlying
    * record lives in the builder's arena and is safe to mutate
    * pre-finalize.  Wrapping the cast keeps the const-stripping in
    * one place. */
   return (ObjSym*)obj_symbol_get(d->ob, id);
 }
 
 /* 1 if the active arch tags function symbols with a Thumb (LSB) ISA-state
  * bit. Replaces the former `target.arch == KIT_ARCH_ARM_32` identity check:
  * the behavior now hangs off the arch's ArchAsmOps vtable (set only on arm32),
  * so generic assembler code stops switching on arch identity. */
 static int asm_thumb_func_syms(const AsmDriver* d) {
   const ArchImpl* a = d->c ? arch_for_compiler(d->c) : NULL;
   return a && a->asm_ops && a->asm_ops->thumb_function_symbols;
 }
 
 static int asm_sym_is_thumb_func(AsmDriver* d, Sym name) {
   u8* hit = SymU8Map_get(&d->thumb_func_map, name);
   return hit && *hit;
 }
 
 static void mark_thumb_func(AsmDriver* d, Sym name) {
   ObjSymId id;
   ObjSym* s;
   if (!asm_thumb_func_syms(d)) return;
   (void)SymU8Map_set(&d->thumb_func_map, name, 1u);
   id = intern_sym(d, name);
   s = sym_mut(d, id);
   if (!s) return;
   s->kind = (u16)SK_FUNC;
   if (s->section_id != OBJ_SEC_NONE) s->value |= 1u;
 }
 
 /* GNU `as` makes any symbol that is referenced but neither defined nor
  * declared `.local` an undefined *global* (a local UNDEF is meaningless
  * in ELF and won't pull a member out of an archive at link time).
  * intern_sym mints every new symbol SB_LOCAL/SK_NOTYPE, so after the
  * parse we promote the ones that stayed undefined to global SK_UNDEF.
  * Defined locals (labels), `.local` decls, and absolute/common symbols
  * are left untouched. */
 static void promote_undef_externs(AsmDriver* d) {
   ObjSymIter* it = obj_symiter_new(d->ob);
   ObjSymEntry e;
   while (obj_symiter_next(it, &e)) {
     /* The iterator visits tombstoned slots too (see obj.h). Deferred
      * anonymous const-data / jump-table symbols (obj_symbol_defer) sit as
      * LOCAL/SK_OBJ/no-section tombstones until opt_whole_module_finalize
      * materializes them — which, when a file-scope `asm` block (e.g. a
      * FreeBSD header's `.symver`) replays before that finalize step, is
      * *after* this pass runs. Promoting them here would resurface them as
      * defined GLOBALs and collide at link (`duplicate definition of global
      * symbol '.Lkit_ro.0'`), so skip tombstones like every other consumer. */
     if (e.sym->removed) continue;
     if (e.sym->section_id != OBJ_SEC_NONE) continue; /* defined here */
     if (e.sym->bind != SB_LOCAL) continue;
     if (e.sym->kind == SK_ABS || e.sym->kind == SK_COMMON) continue;
     obj_symbol_set_bind(d->ob, e.id, SB_GLOBAL);
     sym_mut(d, e.id)->kind = (u16)SK_UNDEF;
   }
   obj_symiter_free(it);
 }
 
 /* ---- expression evaluator (constants + sym ± const) ---- */
 
 typedef struct AsmExpr {
   ObjSymId sym;  /* minuend, or the sole symbol */
   ObjSymId sym2; /* subtrahend: nonzero => value is `(sym - sym2) + const` */
   i64 value;
   u8 is_here; /* the location-counter token `.` (no sym, no value yet) */
   u8 pcrel;   /* `sym - .`: emit a PC-relative data reloc instead of absolute */
 } AsmExpr;
 
 static AsmExpr expr_c(i64 v) {
   AsmExpr e = {OBJ_SYM_NONE, OBJ_SYM_NONE, v, 0, 0};
   return e;
 }
 static AsmExpr expr_s(ObjSymId s, i64 v) {
   AsmExpr e = {s, OBJ_SYM_NONE, v, 0, 0};
   return e;
 }
 static AsmExpr expr_here(void) {
   AsmExpr e = {OBJ_SYM_NONE, OBJ_SYM_NONE, 0, 1, 0};
   return e;
 }
 
 static int tok_is_punct(AsmTok t, u32 p) {
   return t.kind == ASM_TOK_PUNCT && t.v.punct == p;
 }
 
 static i64 lit_to_i64(AsmDriver* d, Sym spelling) {
   size_t n = 0;
   const char* p = asm_str(d, spelling, &n);
   u64 v = 0;
   int base = 10;
   size_t i = 0;
   if (!p || !n) return 0;
   if (n >= 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
     base = 16;
     i = 2;
   } else if (n >= 2 && p[0] == '0' && (p[1] == 'b' || p[1] == 'B')) {
     base = 2;
     i = 2;
   } else if (n >= 1 && p[0] == '0') {
     base = 8;
     i = 1;
   }
   for (; i < n; ++i) {
     char c = p[i];
     u32 dv;
     if (c == 'u' || c == 'U' || c == 'l' || c == 'L') break;
     if (c >= '0' && c <= '9')
       dv = (u32)(c - '0');
     else if (c >= 'a' && c <= 'f')
       dv = 10 + (u32)(c - 'a');
     else if (c >= 'A' && c <= 'F')
       dv = 10 + (u32)(c - 'A');
     else
       d_panicf(d, "asm: bad digit in integer literal");
     if (dv >= (u32)base) d_panicf(d, "asm: digit out of base");
     v = v * (u64)base + dv;
   }
   return (i64)v;
 }
 
 static AsmExpr parse_expr(AsmDriver*);
 static AsmExpr parse_unary(AsmDriver*);
 
 static AsmExpr parse_primary(AsmDriver* d) {
   AsmTok t = d_peek(d);
   if (t.kind == ASM_TOK_NUM) {
     (void)d_next(d);
     return expr_c(lit_to_i64(d, t.spelling));
   }
   if (t.kind == ASM_TOK_IDENT) {
     (void)d_next(d);
     AsmEqu* eq = SymEquMap_get(&d->equ_map, t.v.ident);
     if (eq) {
       if (eq->has_sym) return expr_s(eq->sym, eq->value);
       return expr_c(eq->value);
     }
     return expr_s(intern_sym(d, t.v.ident), 0);
   }
   if (tok_is_punct(t, '(')) {
     (void)d_next(d);
     AsmExpr e = parse_expr(d);
     AsmTok cl = d_peek(d);
     if (!tok_is_punct(cl, ')')) d_panicf(d, "asm: expected ')'");
     (void)d_next(d);
     return e;
   }
   /* Lone `.` is the location counter (used in `sym - .` PC-relative data). */
   if (tok_is_punct(t, '.')) {
     (void)d_next(d);
     return expr_here();
   }
   d_panicf(d, "asm: expected expression");
 }
 
 static AsmExpr parse_unary(AsmDriver* d) {
   AsmTok t = d_peek(d);
   if (tok_is_punct(t, '-')) {
     (void)d_next(d);
     AsmExpr e = parse_unary(d);
     if (e.sym) d_panicf(d, "asm: unary '-' on symbol");
     /* Unsigned negate so `$-9223372036854775808` (negating INT64_MIN) is
      * well-defined 2's-complement, not signed-overflow UB. */
     return expr_c((i64)(0u - (u64)e.value));
   }
   if (tok_is_punct(t, '+')) {
     (void)d_next(d);
     return parse_unary(d);
   }
   if (tok_is_punct(t, '~')) {
     (void)d_next(d);
     AsmExpr e = parse_unary(d);
     if (e.sym) d_panicf(d, "asm: unary '~' on symbol");
     return expr_c(~e.value);
   }
   return parse_primary(d);
 }
 
 static AsmExpr parse_mul(AsmDriver* d) {
   AsmExpr a = parse_unary(d);
   for (;;) {
     AsmTok t = d_peek(d);
     if (!tok_is_punct(t, '*') && !tok_is_punct(t, '/') && !tok_is_punct(t, '%'))
       return a;
     u32 op = t.v.punct;
     (void)d_next(d);
     AsmExpr b = parse_unary(d);
     if (a.sym || b.sym || a.is_here || b.is_here)
       d_panicf(d, "asm: '*/%%' on symbolic operand");
     if (op == '*')
       a.value *= b.value;
     else if (op == '/') {
       if (!b.value) d_panicf(d, "asm: division by zero");
       a.value /= b.value;
     } else {
       if (!b.value) d_panicf(d, "asm: modulo by zero");
       a.value %= b.value;
     }
   }
 }
 
 static AsmExpr parse_add(AsmDriver* d) {
   AsmExpr a = parse_mul(d);
   for (;;) {
     AsmTok t = d_peek(d);
     if (!tok_is_punct(t, '+') && !tok_is_punct(t, '-')) return a;
     u32 op = t.v.punct;
     (void)d_next(d);
     AsmExpr b = parse_mul(d);
     /* `sym - .`: a PC-relative data reference. `.` is the location of the
      * field being emitted, so the relocation's P equals its own offset and the
      * RELA addend stays `a.value` (typically 0). */
     if (op == '-' && b.is_here) {
       if (!a.sym) d_panicf(d, "asm: '- .' requires a symbol operand");
       a.pcrel = 1;
       continue;
     }
     if (a.is_here || b.is_here)
       d_panicf(d, "asm: '.' location counter only valid as `sym - .`");
     if (op == '+') {
       if (a.sym && b.sym) d_panicf(d, "asm: cannot add two symbols");
       if (b.sym) {
         /* const + (b.sym [- b.sym2] + k): adopt b's symbol(s). */
         a.sym = b.sym;
         a.sym2 = b.sym2;
         a.value += b.value;
       } else
         a.value += b.value;
     } else {
       if (b.sym) {
         /* sym1 - sym2: a symbol difference. Resolves to a link-time constant
          * (both symbols in one section) or a relocation pair otherwise. */
         if (!a.sym) d_panicf(d, "asm: cannot subtract symbol from constant");
         if (a.sym2 || b.sym2)
           d_panicf(d, "asm: more than one symbol difference in expression");
         a.sym2 = b.sym;
         a.value -= b.value;
       } else
         a.value -= b.value;
     }
   }
 }
 
 static AsmExpr parse_shift(AsmDriver* d) {
   AsmExpr a = parse_add(d);
   for (;;) {
     AsmTok t = d_peek(d);
     if (!tok_is_punct(t, ASM_P_SHL) && !tok_is_punct(t, ASM_P_SHR)) return a;
     u32 op = t.v.punct;
     (void)d_next(d);
     AsmExpr b = parse_add(d);
     if (a.sym || b.sym) d_panicf(d, "asm: shift on symbolic operand");
     if (op == ASM_P_SHL)
       a.value = (i64)((u64)a.value << (b.value & 63));
     else
       a.value = a.value >> (b.value & 63);
   }
 }
 
 static AsmExpr parse_band(AsmDriver* d) {
   AsmExpr a = parse_shift(d);
   for (;;) {
     AsmTok t = d_peek(d);
     if (!tok_is_punct(t, '&')) return a;
     (void)d_next(d);
     AsmExpr b = parse_shift(d);
     if (a.sym || b.sym) d_panicf(d, "asm: '&' on symbolic operand");
     a.value &= b.value;
   }
 }
 
 static AsmExpr parse_bxor(AsmDriver* d) {
   AsmExpr a = parse_band(d);
   for (;;) {
     AsmTok t = d_peek(d);
     if (!tok_is_punct(t, '^')) return a;
     (void)d_next(d);
     AsmExpr b = parse_band(d);
     if (a.sym || b.sym) d_panicf(d, "asm: '^' on symbolic operand");
     a.value ^= b.value;
   }
 }
 
 static AsmExpr parse_bor(AsmDriver* d) {
   AsmExpr a = parse_bxor(d);
   for (;;) {
     AsmTok t = d_peek(d);
     if (!tok_is_punct(t, '|')) return a;
     (void)d_next(d);
     AsmExpr b = parse_bxor(d);
     if (a.sym || b.sym) d_panicf(d, "asm: '|' on symbolic operand");
     a.value |= b.value;
   }
 }
 
 static AsmExpr parse_expr(AsmDriver* d) { return parse_bor(d); }
 
 /* ---- public helpers exposed to per-arch parser ---- */
 
 AsmTok asm_driver_peek(AsmDriver* d) { return d_peek(d); }
 AsmTok asm_driver_next(AsmDriver* d) { return d_next(d); }
 int asm_driver_at_eol(AsmDriver* d) { return d_is_eol(d); }
 SrcLoc asm_driver_loc(AsmDriver* d) { return d_loc(d); }
 MCEmitter* asm_driver_mc(AsmDriver* d) { return d->mc; }
 ObjBuilder* asm_driver_ob(AsmDriver* d) { return d->ob; }
 Compiler* asm_driver_compiler(AsmDriver* d) { return d->c; }
 Pool* asm_driver_pool(AsmDriver* d) { return d->pool; }
 
 _Noreturn void asm_driver_panic(AsmDriver* d, const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   compiler_panicv(d->c, d_loc(d), fmt, ap);
 }
 
 ObjSymId asm_driver_intern_sym(AsmDriver* d, Sym name) {
   return intern_sym(d, name);
 }
 
 ObjSecId asm_driver_cur_section(AsmDriver* d) {
   if (d->cur_sec == OBJ_SEC_NONE) {
     if (!d->n_text) d->n_text = pool_intern_slice(d->pool, SLICE_LIT(".text"));
     d->cur_sec =
         ensure_section(d, d->n_text, SEC_TEXT, (u16)(SF_ALLOC | SF_EXEC), 4);
     mc_set_section(d->mc, d->cur_sec);
   }
   return d->cur_sec;
 }
 
 int asm_driver_eat_comma(AsmDriver* d) {
   AsmTok t = d_peek(d);
   if (tok_is_punct(t, ',')) {
     (void)d_next(d);
     return 1;
   }
   return 0;
 }
 
 int asm_driver_eat_punct(AsmDriver* d, u32 p) {
   AsmTok t = d_peek(d);
   if (tok_is_punct(t, p)) {
     (void)d_next(d);
     return 1;
   }
   /* `#` arrives as ASM_TOK_HASH from the C lexer; accept it as the
    * immediate-prefix punctuator here. */
   if (p == '#' && t.kind == ASM_TOK_HASH) {
     (void)d_next(d);
     return 1;
   }
   return 0;
 }
 
 void asm_driver_expect_punct(AsmDriver* d, u32 p, const char* what) {
   if (!asm_driver_eat_punct(d, p)) {
     /* Single-char punctuators (incl. '#') carry their ASCII value in `p`;
      * print it directly. Multi-char puncts fall back to the description. */
     char ch = (char)p;
     if (p >= 0x20 && p < 0x7f)
       d_panicf(d, "asm: expected '%c' (%.*s)", ch,
                SLICE_ARG(slice_from_cstr(what)));
     d_panicf(d, "asm: expected punctuator (%.*s)",
              SLICE_ARG(slice_from_cstr(what)));
   }
 }
 
 i64 asm_driver_parse_const(AsmDriver* d) {
   AsmExpr e = parse_expr(d);
   if (e.sym) d_panicf(d, "asm: constant expression expected");
   return e.value;
 }
 
 void asm_driver_parse_sym_expr(AsmDriver* d, ObjSymId* sym_out, i64* off_out) {
   AsmExpr e = parse_expr(d);
   *sym_out = e.sym;
   *off_out = e.value;
 }
 
 int asm_driver_tok_is_punct(AsmTok t, u32 p) {
   if (tok_is_punct(t, p)) return 1;
   /* `#` arrives as ASM_TOK_HASH from the C lexer. */
   if (p == '#' && t.kind == ASM_TOK_HASH) return 1;
   return 0;
 }
 
 /* ---- string-literal decoding ---- */
 
 /* Decode a string literal's spelling into raw bytes. *out is the heap buffer
  * (allocated with size *cap_out, which the caller must pass back to free —
  * the decoded length *nout <= *cap_out once escapes collapse). */
 static void decode_string(AsmDriver* d, Sym spelling, u8** out, u32* nout,
                           size_t* cap_out) {
   size_t n = 0;
   const char* p = asm_str(d, spelling, &n);
   /* Skip any encoding prefix (L/u/u8/U). */
   while (n && (*p == 'L' || *p == 'u' || *p == 'U' || *p == '8')) {
     ++p;
     --n;
   }
   if (n < 2 || p[0] != '"' || p[n - 1] != '"')
     d_panicf(d, "asm: malformed string literal");
   size_t cap = n ? n : 1;
   u8* buf = (u8*)d->heap->alloc(d->heap, cap, 1);
   u32 k = 0;
   for (size_t i = 1; i + 1 < n; ++i) {
     char c = p[i];
     if (c != '\\') {
       buf[k++] = (u8)c;
       continue;
     }
     ++i;
     if (i + 1 >= n) break;
     char e = p[i];
     switch (e) {
       case 'n':
         buf[k++] = '\n';
         break;
       case 't':
         buf[k++] = '\t';
         break;
       case 'r':
         buf[k++] = '\r';
         break;
       case '\\':
         buf[k++] = '\\';
         break;
       case '"':
         buf[k++] = '"';
         break;
       case '\'':
         buf[k++] = '\'';
         break;
       case '0':
         buf[k++] = 0;
         break;
       case 'b':
         buf[k++] = 8;
         break;
       case 'f':
         buf[k++] = 12;
         break;
       case 'v':
         buf[k++] = 11;
         break;
       case 'a':
         buf[k++] = 7;
         break;
       case 'x': {
         u32 v = 0;
         int dn = 0;
         while (i + 2 < n) {
           char h = p[i + 1];
           int dv;
           if (h >= '0' && h <= '9')
             dv = h - '0';
           else if (h >= 'a' && h <= 'f')
             dv = 10 + (h - 'a');
           else if (h >= 'A' && h <= 'F')
             dv = 10 + (h - 'A');
           else
             break;
           v = v * 16 + (u32)dv;
           ++i;
           if (++dn >= 2) break;
         }
         buf[k++] = (u8)v;
         break;
       }
       default:
         if (e >= '0' && e <= '7') {
           u32 v = (u32)(e - '0');
           int dn = 1;
           while (dn < 3 && i + 2 < n) {
             char h = p[i + 1];
             if (h < '0' || h > '7') break;
             v = v * 8 + (u32)(h - '0');
             ++i;
             ++dn;
           }
           buf[k++] = (u8)v;
         } else {
           buf[k++] = (u8)e;
         }
         break;
     }
   }
   *out = buf;
   *nout = k;
   *cap_out = cap;
 }
 
 /* ---- directives ---- */
 
 static Sym expect_ident(AsmDriver* d, const char* what) {
   AsmTok t = d_peek(d);
   if (t.kind != ASM_TOK_IDENT)
     d_panicf(d, "asm: %.*s: expected identifier",
              SLICE_ARG(slice_from_cstr(what)));
   (void)d_next(d);
   return t.v.ident;
 }
 
 static void emit_le(AsmDriver* d, u64 v, u32 width) {
   u8 buf[8];
   for (u32 i = 0; i < width; ++i) buf[i] = (u8)(v >> (8 * i));
   (void)asm_driver_cur_section(d);
   mc_emit_bytes(d->mc, buf, width);
 }
 
 /* Record a `sym1 - sym2` data difference for resolution after the parse,
  * once every label is defined. The field already holds the net addend. */
 static void record_sym_diff(AsmDriver* d, ObjSecId sec, u32 ofs, u32 width,
                             ObjSymId minuend, ObjSymId subtrahend, i64 addend) {
   if (VEC_GROW(d->heap, d->diffs, d->diffs_cap, d->ndiffs + 1))
     d_panicf(d, "asm: out of memory recording symbol difference");
   AsmDiff* df = &d->diffs[d->ndiffs++];
   df->section = sec;
   df->offset = ofs;
   df->width = width;
   df->minuend = minuend;
   df->subtrahend = subtrahend;
   df->addend = addend;
   df->loc = d_loc(d);
 }
 
 static void emit_int_directive(AsmDriver* d, u32 width) {
   for (;;) {
     AsmExpr e = parse_expr(d);
     if (e.sym && e.sym2) {
       /* `sym1 - sym2` difference: emit the net addend as a placeholder and
        * defer resolution until all labels are defined (a forward-referenced
        * minuend like `_end` is still undefined here). */
       (void)asm_driver_cur_section(d);
       u32 ofs = mc_pos(d->mc);
       emit_le(d, (u64)e.value, width);
       record_sym_diff(d, d->cur_sec, ofs, width, e.sym, e.sym2, e.value);
     } else if (e.sym) {
       RelocKind k;
       if (e.pcrel) {
         /* `sym - .`: PC-relative data. Only the 32/64-bit widths codegen
          * emits via kit_cg_data_pcrel are supported. */
         if (width == 4)
           k = R_PC32;
         else if (width == 8)
           k = R_PC64;
         else
           d_panicf(d, "asm: PC-relative `sym - .` needs .long/.quad");
       } else if (width == 4)
         k = R_ABS32;
       else if (width == 8)
         k = R_ABS64;
       else
         d_panicf(d, "asm: symbolic .byte/.hword not supported");
       (void)asm_driver_cur_section(d);
       u32 ofs = mc_pos(d->mc);
       /* Write the addend into the data field, not zero. Mach-O relocations
        * carry the addend implicitly in the relocated field (REL form); writing
        * zero loses it (every `.quad sym+N` would resolve to sym+0 — a switch
        * jump table dispatching into hyperspace). codegen pre-writes the addend
        * the same way. On ELF (RELA) the linker overwrites the field with S+A,
        * so the pre-written value is harmless there. */
       emit_le(d, (u64)e.value, width);
       mc_emit_reloc_at(d->mc, d->cur_sec, ofs, k, e.sym, e.value, 1, 0);
     } else {
       emit_le(d, (u64)e.value, width);
     }
     if (!asm_driver_eat_comma(d)) break;
   }
 }
 
 static void do_directive(AsmDriver* d, Sym name) {
   if (sym_eq(d, name, "text")) {
     if (!d->n_text) d->n_text = pool_intern_slice(d->pool, SLICE_LIT(".text"));
     set_section(d, d->n_text, SEC_TEXT, (u16)(SF_ALLOC | SF_EXEC), 4);
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "data")) {
     if (!d->n_data) d->n_data = pool_intern_slice(d->pool, SLICE_LIT(".data"));
     set_section(d, d->n_data, SEC_DATA, (u16)(SF_ALLOC | SF_WRITE), 8);
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "rodata")) {
     if (!d->n_rodata)
       d->n_rodata = pool_intern_slice(d->pool, SLICE_LIT(".rodata"));
     set_section(d, d->n_rodata, SEC_RODATA, (u16)SF_ALLOC, 8);
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "bss")) {
     if (!d->n_bss) d->n_bss = pool_intern_slice(d->pool, SLICE_LIT(".bss"));
     set_section(d, d->n_bss, SEC_BSS, (u16)(SF_ALLOC | SF_WRITE), 8);
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "section")) {
     Sym sname = 0;
     AsmTok t = d_peek(d);
     if (t.kind == ASM_TOK_STR) {
       size_t n = 0;
       const char* p = asm_str(d, t.spelling, &n);
       if (n >= 2 && p[0] == '"')
         sname = pool_intern_slice(d->pool, (Slice){.s = p + 1, .len = n - 2});
       (void)d_next(d);
     } else if (t.kind == ASM_TOK_IDENT || tok_is_punct(t, '.')) {
       /* A bare section name. The lexer breaks a dotted name like
        * `.rodata.toy.merge` into PUNCT('.')+IDENT segments (the `.`+digit
        * identifier rule does not glue `.`+letter), so reassemble the full
        * dotted spelling by consuming each adjacent `.segment`. Stops at the
        * `, "flags"` operands (the next token is then a comma). */
       char buf[128];
       size_t bn = 0;
       int leading_dot = tok_is_punct(t, '.');
       if (leading_dot) {
         (void)d_next(d);
         buf[bn++] = '.';
       }
       AsmTok id = d_next(d);
       if (id.kind != ASM_TOK_IDENT) d_panicf(d, "asm: .section: bad name");
       for (;;) {
         size_t ni = 0;
         const char* nm = asm_str(d, id.spelling, &ni);
         if (bn + ni >= sizeof buf) d_panicf(d, "asm: .section: name too long");
         for (size_t i = 0; i < ni; ++i) buf[bn++] = nm[i];
         /* Glue a following `.<ident>` (or `.<num>`) segment, no whitespace. */
         if (!tok_is_punct(d_peek(d), '.')) break;
         (void)d_next(d); /* '.' */
         AsmTok seg = d_peek(d);
         if (seg.kind != ASM_TOK_IDENT && seg.kind != ASM_TOK_NUM) {
           /* A lone trailing '.' is not part of the name; put it back is not
            * supported, but section names never end in '.', so this is a
            * malformed directive. */
           d_panicf(d, "asm: .section: bad name");
         }
         if (bn + 1 >= sizeof buf) d_panicf(d, "asm: .section: name too long");
         buf[bn++] = '.';
         id = d_next(d);
       }
       sname = pool_intern_slice(d->pool, (Slice){.s = buf, .len = bn});
     } else {
       d_panicf(d, "asm: .section: expected name");
     }
     SecKind kind = SEC_OTHER;
     u16 sem = SSEM_PROGBITS;
     u16 flags = 0;
     u32 entsize = 0;
     int have_flags = 0;
     int macho_2pos = 0;
 
     /* Mach-O `.section segname,sectname[,type[,attrs]]`: the token after the
      * first comma is a bare sectname IDENT (vs GNU's "flags" STRING). kit as
      * parses the dialect of its target only (no hybrid), so this branch is
      * gated on the Mach-O object format. Rebuild the comma-joined "seg,sect"
      * name that the Mach-O writer's name_to_seg_sect splits back. */
     if (d->c->target.obj == KIT_OBJ_MACHO && tok_is_punct(d_peek(d), ',')) {
       (void)d_next(d); /* eat ',' */
       AsmTok sect = d_next(d);
       size_t sgn = 0, scn = 0;
       const char* sgp;
       const char* scp;
       char buf[128];
       if (sect.kind != ASM_TOK_IDENT)
         d_panicf(d, "asm: .section: expected Mach-O sectname after ','");
       sgp = asm_str(d, sname, &sgn);
       scp = asm_str(d, sect.v.ident, &scn);
       if (sgn + 1 + scn >= sizeof buf)
         d_panicf(d, "asm: .section: name too long");
       memcpy(buf, sgp, sgn);
       buf[sgn] = ',';
       memcpy(buf + sgn + 1, scp, scn);
       sname =
           pool_intern_slice(d->pool, (Slice){.s = buf, .len = sgn + 1 + scn});
       macho_2pos = 1;
       /* Optional trailing Mach-O type/attribute fields (regular,
        * cstring_literals, …): accept and consume; map the few affecting
        * flags. */
       while (asm_driver_eat_comma(d)) {
         AsmTok ty = d_peek(d);
         if (ty.kind == ASM_TOK_IDENT) {
           size_t tn = 0;
           const char* tp = asm_str(d, ty.v.ident, &tn);
           if (tn == 16 && memcmp(tp, "cstring_literals", 16) == 0)
             flags |= SF_STRINGS;
           (void)d_next(d);
         } else if (ty.kind == ASM_TOK_NUM) {
           (void)d_next(d);
         } else {
           break;
         }
       }
     }
 
     /* Optional GNU-as operands: , "flags" [, @type [, entsize]]. The emitter
      * (src/api/asm_emit.c) writes these for SEC_OTHER named sections; parse
      * them back so a global's section flags/entsize round-trip faithfully. */
     if (!macho_2pos && asm_driver_eat_comma(d)) {
       AsmTok ft = d_peek(d);
       if (ft.kind == ASM_TOK_STR) {
         size_t fn = 0;
         const char* fp = asm_str(d, ft.spelling, &fn);
         size_t fi;
         for (fi = 0; fp && fi < fn; ++fi) {
           switch (fp[fi]) {
             case 'a':
               flags |= SF_ALLOC;
               break;
             case 'w':
               flags |= SF_WRITE;
               break;
             case 'x':
               flags |= SF_EXEC;
               break;
             case 'M':
               flags |= SF_MERGE;
               break;
             case 'S':
               flags |= SF_STRINGS;
               break;
             case 'T':
               flags |= SF_TLS;
               break;
             case 'R':
               flags |= SF_RETAIN;
               break;
             default:
               break; /* surrounding quotes / unknown letters */
           }
         }
         have_flags = 1;
         (void)d_next(d);
         if (asm_driver_eat_comma(d)) {
           AsmTok ty = d_peek(d);
           Sym tag = 0;
           if (tok_is_punct(ty, '@')) {
             (void)d_next(d);
             AsmTok ti = d_next(d); /* the @type ident (progbits/nobits/note) */
             if (ti.kind == ASM_TOK_IDENT) tag = ti.v.ident;
           } else if (ty.kind == ASM_TOK_IDENT) {
             tag = d_next(d).v.ident;
           }
           if (tag) {
             if (sym_eq(d, tag, "note")) {
               sem = SSEM_NOTE;
             } else if (sym_eq(d, tag, "nobits")) {
               sem = SSEM_NOBITS;
             } else if (sym_eq(d, tag, "init_array")) {
               sem = SSEM_INIT_ARRAY;
             } else if (sym_eq(d, tag, "fini_array")) {
               sem = SSEM_FINI_ARRAY;
             } else if (sym_eq(d, tag, "preinit_array")) {
               sem = SSEM_PREINIT_ARRAY;
             }
           }
           if (asm_driver_eat_comma(d)) {
             AsmTok es = d_peek(d);
             if (es.kind == ASM_TOK_NUM) {
               entsize = (u32)lit_to_i64(d, es.spelling);
               (void)d_next(d);
             }
           }
         }
       }
     }
 
     {
       size_t nn = 0;
       const char* p = asm_str(d, sname, &nn);
       if (macho_2pos) {
         /* Canonical Apple seg,sect → SecKind via the shared inverse of the
          * writer's name_to_seg_sect; unrecognized spellings (e.g.
          * __TEXT,__eh_frame) fall back to SEC_OTHER. Flags are derived from the
          * resolved kind: every Mach-O section is allocated (so SEC_OTHER keeps
          * SF_ALLOC), and __TEXT,__cstring additionally carries SF_STRINGS. The
          * comma name is preserved so the writer round-trips seg/sect verbatim.
          */
         if (!obj_macho_seckind_for_secname(p, nn, &kind)) kind = SEC_OTHER;
         switch (kind) {
           case SEC_TEXT:
             flags |= (u16)(SF_ALLOC | SF_EXEC);
             break;
           case SEC_RODATA:
             flags |= (u16)SF_ALLOC;
             if (nn == 16 && memcmp(p, "__TEXT,__cstring", 16) == 0)
               flags |= (u16)SF_STRINGS;
             break;
           case SEC_DATA:
           case SEC_BSS:
             flags |= (u16)(SF_ALLOC | SF_WRITE);
             break;
           case SEC_DEBUG:
             break;
           default:
             flags |= (u16)SF_ALLOC;
             break;
         }
       } else if (have_flags) {
         /* Explicit flags: a canonical name keeps its kind; any other name is a
          * SEC_OTHER named section (matching codegen for section(...) globals).
          */
         if (p && nn == 5 && memcmp(p, ".text", 5) == 0)
           kind = SEC_TEXT;
         else if (p && nn == 7 && memcmp(p, ".rodata", 7) == 0)
           kind = SEC_RODATA;
         else if (p && nn == 5 && memcmp(p, ".data", 5) == 0)
           kind = SEC_DATA;
         else if (p && nn == 4 && memcmp(p, ".bss", 4) == 0)
           kind = SEC_BSS;
         else
           kind = SEC_OTHER;
       } else if (p) {
         /* No flag string: infer kind+flags from a canonical name prefix. */
         if (nn >= 5 && memcmp(p, ".text", 5) == 0) {
           kind = SEC_TEXT;
           flags = (u16)(SF_ALLOC | SF_EXEC);
         } else if (nn >= 7 && memcmp(p, ".rodata", 7) == 0) {
           kind = SEC_RODATA;
           flags = (u16)SF_ALLOC;
         } else if (nn >= 5 && memcmp(p, ".data", 5) == 0) {
           kind = SEC_DATA;
           flags = (u16)(SF_ALLOC | SF_WRITE);
         } else if (nn >= 4 && memcmp(p, ".bss", 4) == 0) {
           kind = SEC_BSS;
           flags = (u16)(SF_ALLOC | SF_WRITE);
         }
       }
     }
     if (kind == SEC_BSS) sem = SSEM_NOBITS;
     if (sem == SSEM_NOTE) kind = SEC_OTHER;
 
     /* Consume any remaining operands (e.g. ,unique,N or group fields). */
     d_skip_to_eol(d);
     {
       ObjSecId sid = ensure_section_ex(d, sname, kind, sem, flags, 1);
       if (entsize) obj_section_set_entsize(d->ob, sid, entsize);
       d->cur_sec = sid;
       mc_set_section(d->mc, sid);
     }
     return;
   }
   if (sym_eq(d, name, "globl") || sym_eq(d, name, "global")) {
     Sym n = expect_ident(d, ".globl");
     sym_mut(d, intern_sym(d, n))->bind = (u16)SB_GLOBAL;
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "local")) {
     Sym n = expect_ident(d, ".local");
     sym_mut(d, intern_sym(d, n))->bind = (u16)SB_LOCAL;
     d_skip_to_eol(d);
     return;
   }
   /* `.weak_definition` is the Mach-O spelling for a weak *defined* symbol
    * (clang rejects GNU `.weak` on Mach-O). It pairs with a `.globl`; kit
    * collapses both to SB_WEAK, which the Mach-O emitter turns into
    * N_EXT|N_WEAK_DEF and ELF into STB_WEAK. */
   if (sym_eq(d, name, "weak") || sym_eq(d, name, "weak_definition")) {
     Sym n = expect_ident(d, ".weak");
     sym_mut(d, intern_sym(d, n))->bind = (u16)SB_WEAK;
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "hidden")) {
     Sym n = expect_ident(d, ".hidden");
     sym_mut(d, intern_sym(d, n))->vis = (u8)SV_HIDDEN;
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "protected")) {
     Sym n = expect_ident(d, ".protected");
     sym_mut(d, intern_sym(d, n))->vis = (u8)SV_PROTECTED;
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "internal")) {
     Sym n = expect_ident(d, ".internal");
     sym_mut(d, intern_sym(d, n))->vis = (u8)SV_INTERNAL;
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "type")) {
     Sym n = expect_ident(d, ".type");
     ObjSymId id = intern_sym(d, n);
     if (!asm_driver_eat_comma(d)) d_panicf(d, "asm: .type: expected ','");
     AsmTok t = d_next(d);
     Sym tag = 0;
     if (tok_is_punct(t, '@') || tok_is_punct(t, '%')) {
       AsmTok ti = d_next(d);
       if (ti.kind != ASM_TOK_IDENT) d_panicf(d, "asm: .type: tag");
       tag = ti.v.ident;
     } else if (t.kind == ASM_TOK_IDENT) {
       tag = t.v.ident;
     } else if (t.kind == ASM_TOK_STR) {
       size_t sn = 0;
       const char* sp = asm_str(d, t.spelling, &sn);
       if (sn >= 2 && sp[0] == '"' && sp[sn - 1] == '"')
         tag = pool_intern_slice(d->pool, (Slice){.s = sp + 1, .len = sn - 2});
     } else {
       d_panicf(d, "asm: .type: tag");
     }
     if (tag && sym_eq(d, tag, "function")) {
       sym_mut(d, id)->kind = (u16)SK_FUNC;
       if (asm_sym_is_thumb_func(d, n)) sym_mut(d, id)->value |= 1u;
     } else if (tag && sym_eq(d, tag, "object"))
       sym_mut(d, id)->kind = (u16)SK_OBJ;
     else if (tag && sym_eq(d, tag, "tls_object"))
       sym_mut(d, id)->kind = (u16)SK_TLS;
     else if (tag && sym_eq(d, tag, "gnu_indirect_function"))
       sym_mut(d, id)->kind = (u16)SK_IFUNC;
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "thumb_func")) {
     if (asm_thumb_func_syms(d) && !d_is_eol(d)) {
       mark_thumb_func(d, expect_ident(d, ".thumb_func"));
     } else if (asm_thumb_func_syms(d)) {
       d->pending_thumb_func = 1;
     }
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "size")) {
     Sym n = expect_ident(d, ".size");
     ObjSymId id = intern_sym(d, n);
     if (!asm_driver_eat_comma(d)) d_panicf(d, "asm: .size: expected ','");
     /* Recognize `. - NAME`. */
     AsmTok t = d_peek(d);
     i64 sz = 0;
     if (tok_is_punct(t, '.')) {
       (void)d_next(d);
       if (tok_is_punct(d_peek(d), '-')) {
         (void)d_next(d);
         AsmTok rid = d_peek(d);
         if (rid.kind == ASM_TOK_IDENT && rid.v.ident == n) {
           (void)d_next(d);
           const ObjSym* os = obj_symbol_get(d->ob, id);
           if (os && os->section_id == d->cur_sec) {
             u64 start = os->value;
             if (asm_thumb_func_syms(d) && os->kind == SK_FUNC)
               start &= ~(u64)1;
             sz = (i64)mc_pos(d->mc) - (i64)start;
           }
         }
       }
     } else {
       AsmExpr e = parse_expr(d);
       if (!e.sym) sz = e.value;
     }
     if (sz < 0) sz = 0;
     sym_mut(d, id)->size = (u64)sz;
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "byte")) {
     emit_int_directive(d, 1);
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "hword") || sym_eq(d, name, "short") ||
       sym_eq(d, name, "2byte")) {
     emit_int_directive(d, 2);
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "word") || sym_eq(d, name, "long") ||
       sym_eq(d, name, "int") || sym_eq(d, name, "4byte")) {
     emit_int_directive(d, 4);
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "quad") || sym_eq(d, name, "8byte") ||
       sym_eq(d, name, "dword") || sym_eq(d, name, "xword")) {
     emit_int_directive(d, 8);
     d_skip_to_eol(d);
     return;
   }
   /* .inst WORD[, WORD...] — emit raw 32-bit instruction word(s), little-endian
    * (AArch64/RISC-V are fixed 4-byte). This is how `cc -S` round-trips an
    * instruction the disassembler can't decode yet (`.inst 0x<word>`); silently
    * dropping it — the old behavior — deletes the instruction and miscompiles.
    * Matches GNU as / llvm-mc, which emit the word. */
   if (sym_eq(d, name, "inst")) {
     (void)asm_driver_cur_section(d);
     for (;;) {
       i64 v = asm_driver_parse_const(d);
       emit_le(d, (u64)v, 4);
       if (!asm_driver_eat_comma(d)) break;
     }
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "ascii") || sym_eq(d, name, "asciz") ||
       sym_eq(d, name, "string")) {
     int term = !sym_eq(d, name, "ascii");
     for (;;) {
       AsmTok t = d_peek(d);
       if (t.kind != ASM_TOK_STR)
         d_panicf(d, "asm: .ascii/.string: expected string");
       (void)d_next(d);
       u8* buf = NULL;
       u32 n = 0;
       size_t cap = 0;
       decode_string(d, t.spelling, &buf, &n, &cap);
       (void)asm_driver_cur_section(d);
       mc_emit_bytes(d->mc, buf, n);
       if (term) emit_le(d, 0, 1);
       d->heap->free(d->heap, buf, cap);
       if (!asm_driver_eat_comma(d)) break;
     }
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "zero") || sym_eq(d, name, "skip") ||
       sym_eq(d, name, "space")) {
     i64 n = asm_driver_parse_const(d);
     i64 fill = 0;
     if (asm_driver_eat_comma(d)) fill = asm_driver_parse_const(d);
     if (n > 0) {
       (void)asm_driver_cur_section(d);
       mc_emit_fill(d->mc, (size_t)n, (u8)fill);
     }
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "fill")) {
     i64 n = asm_driver_parse_const(d);
     i64 size = 1, val = 0;
     if (asm_driver_eat_comma(d)) size = asm_driver_parse_const(d);
     if (asm_driver_eat_comma(d)) val = asm_driver_parse_const(d);
     if (size < 1 || size > 8) d_panicf(d, "asm: .fill: size out of range");
     (void)asm_driver_cur_section(d);
     for (i64 i = 0; i < n; ++i) emit_le(d, (u64)val, (u32)size);
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "align") || sym_eq(d, name, "balign")) {
     i64 a = asm_driver_parse_const(d);
     i64 fill = 0;
     if (asm_driver_eat_comma(d)) fill = asm_driver_parse_const(d);
     if (a <= 0 || (a & (a - 1))) d_panicf(d, "asm: .align: not a power of 2");
     (void)asm_driver_cur_section(d);
     mc_emit_align(d->mc, (u32)a, (u8)fill);
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "p2align")) {
     i64 lg = asm_driver_parse_const(d);
     i64 fill = 0;
     if (asm_driver_eat_comma(d)) fill = asm_driver_parse_const(d);
     if (lg < 0 || lg > 16) d_panicf(d, "asm: .p2align: out of range");
     (void)asm_driver_cur_section(d);
     mc_emit_align(d->mc, 1u << (u32)lg, (u8)fill);
     d_skip_to_eol(d);
     return;
   }
   if (sym_eq(d, name, "set") || sym_eq(d, name, "equ")) {
     Sym n = expect_ident(d, ".set");
     if (!asm_driver_eat_comma(d)) d_panicf(d, "asm: .set: expected ','");
     AsmExpr e = parse_expr(d);
     AsmEqu eq;
     eq.value = e.value;
     eq.sym = e.sym;
     eq.has_sym = e.sym ? 1 : 0;
     eq.pad[0] = eq.pad[1] = eq.pad[2] = 0;
     SymEquMap_set(&d->equ_map, n, eq);
     d_skip_to_eol(d);
     return;
   }
 
   /* .comm/.lcomm NAME, SIZE[, ALIGN] — declare a common symbol. Previously
    * skipped, which silently produced no symbol and reserved no space. Model
    * both as SK_COMMON (the linker allocates .bss space); .comm is global,
    * .lcomm local. */
   if (sym_eq(d, name, "comm") || sym_eq(d, name, "lcomm")) {
     int is_local = sym_eq(d, name, "lcomm");
     Sym nm = expect_ident(d, ".comm");
     i64 size = 0, align = 1;
     if (!asm_driver_eat_comma(d)) d_panicf(d, "asm: .comm: expected ','");
     size = asm_driver_parse_const(d);
     if (asm_driver_eat_comma(d)) align = asm_driver_parse_const(d);
     if (size < 0) size = 0;
     if (align < 1) align = 1;
     {
       ObjSym* s = sym_mut(d, intern_sym(d, nm));
       s->kind = (u16)SK_COMMON;
       s->bind = (u16)(is_local ? SB_LOCAL : SB_GLOBAL);
       s->size = (u64)size;
       s->common_align = (u64)align;
     }
     d_skip_to_eol(d);
     return;
   }
   /* .uleb128/.sleb128 VALUE[, VALUE...] — emit LEB128-encoded bytes.
    * Previously skipped, which emitted nothing and corrupted any hand-written
    * DWARF / exception tables that follow. */
   if (sym_eq(d, name, "uleb128") || sym_eq(d, name, "sleb128")) {
     int sgn = sym_eq(d, name, "sleb128");
     (void)asm_driver_cur_section(d);
     for (;;) {
       i64 v = asm_driver_parse_const(d);
       u8 buf[16];
       u32 n = 0;
       if (sgn) {
         int more = 1;
         while (more) {
           u8 b = (u8)((u64)v & 0x7fu);
           v >>= 7; /* arithmetic right shift keeps the sign */
           if ((v == 0 && !(b & 0x40u)) || (v == -1 && (b & 0x40u)))
             more = 0;
           else
             b |= 0x80u;
           buf[n++] = b;
         }
       } else {
         u64 uv = (u64)v;
         do {
           u8 b = (u8)(uv & 0x7fu);
           uv >>= 7;
           if (uv) b |= 0x80u;
           buf[n++] = b;
         } while (uv);
       }
       mc_emit_bytes(d->mc, buf, n);
       if (!asm_driver_eat_comma(d)) break;
     }
     d_skip_to_eol(d);
     return;
   }
 
   /* CFI block + accepted-but-ignored directives.  Keep parser
    * forward-progress without aborting the whole TU. */
   if (starts_with(d, name, "cfi_") || sym_eq(d, name, "file") ||
       sym_eq(d, name, "loc") || sym_eq(d, name, "ident") ||
       sym_eq(d, name, "popsection") || sym_eq(d, name, "pushsection") ||
       sym_eq(d, name, "previous") ||
       sym_eq(d, name, "subsections_via_symbols") || sym_eq(d, name, "macro") ||
       sym_eq(d, name, "endm") || sym_eq(d, name, "if") ||
       sym_eq(d, name, "endif") || sym_eq(d, name, "else") ||
       sym_eq(d, name, "include") ||
       /* RISC-V `.option rvc/norvc/relax/norelax/push/pop/...`: kit's own
        * cc -S emits `.option norvc`/`.option norelax` to pin its fixed
        * instruction layout (see rv64_file_prologue). kit-as never compresses
        * or relaxes, so it already honors these implicitly — accept and ignore
        * rather than treat as an unknown directive. */
       sym_eq(d, name, "option")) {
     d_skip_to_eol(d);
     return;
   }
 
   /* Unknown directive — recover. */
   d_skip_to_eol(d);
 }
 
 /* ---- deferred symbol-difference resolution ----
  *
  * `.quad sym1 - sym2` (and the narrower data widths) is recorded at emit time
  * and lowered here, once the parse has defined every label. Three outcomes,
  * matching GNU as:
  *
  *   (a) Both symbols defined in one section — the difference is a pure
  *       assembly-time constant (the section base cancels). Fold it into the
  *       field; no relocation. Works for any width.
  *   (b) The subtrahend is defined in the fixup's own section (the minuend may
  *       be anywhere, including undefined / linker-script-provided like `_end`).
  *       Reduce to a PC-relative relocation against the minuend: at the fixup
  *       site P, `M + A' - P` with `A' = addend + offset - sym2.value` equals
  *       `M - sym2` because `P - offset` is the section base and
  *       `base + sym2.value == sym2`. This is the arm64/riscv kernel
  *       `image_size = _end - _start` case. Needs .long/.quad.
  *   (c) Otherwise (cross-section, or an undefined subtrahend) — an R_ADD/R_SUB
  *       relocation pair the linker applies additively to the field (which holds
  *       the net addend): `field += minuend; field -= subtrahend`. Emitted
  *       adjacently so the Mach-O writer fuses them into a SUBTRACTOR pair and
  *       RISC-V ELF maps each to the R_RISCV_ADD / R_RISCV_SUB families. */
 static void patch_le(AsmDriver* d, ObjSecId sec, u32 ofs, u64 v, u32 width) {
   u8 buf[8];
   for (u32 i = 0; i < width; ++i) buf[i] = (u8)(v >> (8 * i));
   obj_patch(d->ob, sec, ofs, buf, width);
 }
 
 static void resolve_sym_diffs(AsmDriver* d) {
   for (u32 i = 0; i < d->ndiffs; ++i) {
     AsmDiff* df = &d->diffs[i];
     const ObjSym* m = obj_symbol_get(d->ob, df->minuend);
     const ObjSym* s = obj_symbol_get(d->ob, df->subtrahend);
     int m_def = m && m->section_id != OBJ_SEC_NONE;
     int s_def = s && s->section_id != OBJ_SEC_NONE;
 
     /* (a) constant fold */
     if (m_def && s_def && m->section_id == s->section_id) {
       i64 c = (i64)m->value - (i64)s->value + df->addend;
       patch_le(d, df->section, df->offset, (u64)c, df->width);
       continue;
     }
 
     /* (b) subtrahend in the fixup's section -> PC-relative reloc on minuend */
     if (s_def && s->section_id == df->section) {
       RelocKind k;
       if (df->width == 8)
         k = R_PC64;
       else if (df->width == 4)
         k = R_PC32;
       else
         compiler_panic(d->c, df->loc,
                        "asm: PC-relative symbol difference needs .long/.quad");
       i64 ad = df->addend + (i64)df->offset - (i64)s->value;
       patch_le(d, df->section, df->offset, (u64)ad, df->width);
       mc_emit_reloc_at(d->mc, df->section, df->offset, k, df->minuend, ad, 1, 0);
       continue;
     }
 
     /* (c) general difference -> R_ADD/R_SUB pair */
     {
       RelocKind ka, ks;
       switch (df->width) {
         case 1:
           ka = R_ADD8;
           ks = R_SUB8;
           break;
         case 2:
           ka = R_ADD16;
           ks = R_SUB16;
           break;
         case 4:
           ka = R_ADD32;
           ks = R_SUB32;
           break;
         case 8:
           ka = R_ADD64;
           ks = R_SUB64;
           break;
         default:
           compiler_panic(d->c, df->loc, "asm: bad symbol-difference width %u",
                          (unsigned)df->width);
       }
       mc_emit_reloc_at(d->mc, df->section, df->offset, ka, df->minuend, 0, 1, 0);
       mc_emit_reloc_at(d->mc, df->section, df->offset, ks, df->subtrahend, 0, 1,
                        0);
     }
   }
 }
 
 /* ---- same-section branch relaxation ----
  *
  * The per-arch parser emits a relocation for every symbolic branch target,
  * even one that resolves within the current section (a forward reference like
  * `b .Lfoo` is only known to be local once `.Lfoo:` is seen). GNU as / llvm-mc
  * — and kit's own codegen — instead resolve such intra-section branches at
  * assembly time: compute the displacement, patch the instruction, and emit no
  * relocation. Matching that is what makes `cc -S | as` reproduce `cc -c`'s
  * .text relocation table for control-flow-bearing code (the L1 round-trip
  * lane; see doc/TESTING.md).
  *
  * We relax only PC-relative *branch* relocations (never CALL26 — a call keeps
  * its relocation on both sides) whose target is a symbol defined in the same
  * section, with local binding, and not a function entry. The "local" guard
  * matches GNU as (a global symbol may be interposed, so its branch keeps the
  * relocation); the "not a function" guard matches kit codegen, which keeps
  * the relocation for an intra-file call/tail-call to a function symbol while
  * resolving branches to internal labels.
  *
  * Restricted to the AArch64 branch kinds for now — the round-trip vertical
  * slice is aa64; rv64/x64 keep their current behavior. */
 static int is_relaxable_branch_kind(u16 kind) {
   switch (kind) {
     case R_AARCH64_JUMP26:
     case R_AARCH64_CONDBR19:
     case R_AARCH64_TSTBR14:
     case R_AARCH64_ADR_PREL_LO21: /* adr to a local code label (&&label) */
       return 1;
     default:
       return 0;
   }
 }
 
 static void relax_local_branches(AsmDriver* d) {
   u32 total = obj_reloc_total(d->ob), i;
   for (i = 0; i < total; ++i) {
     const Reloc* r = obj_reloc_at(d->ob, i);
     const ObjSym* tgt;
     const Section* sec;
     u8 insn[4];
     if (!r || r->removed) continue;
     if (!is_relaxable_branch_kind(r->kind)) continue;
     tgt = obj_symbol_get(d->ob, r->sym);
     if (!tgt) continue;
     if (tgt->section_id != r->section_id) continue; /* cross-section / undef */
     if (tgt->bind != SB_LOCAL) continue;            /* preemptible; keep */
     if (tgt->kind == SK_FUNC) continue;             /* call/tail-call; keep */
     /* Read-only access to the in-progress section is fine via the const
      * accessor; the byte write goes back through obj_patch so we don't reach
      * into Section internals. */
     sec = obj_section_get(d->ob, r->section_id);
     if (!sec) continue;
     if ((u64)r->offset + 4 > sec->bytes.total) continue;
     buf_read(&sec->bytes, r->offset, insn, 4);
     /* Section-relative S and P make the base cancel: disp = S + A - P. */
     link_reloc_apply(d->c, (RelocKind)r->kind, insn, tgt->value, r->addend,
                      r->offset);
     obj_patch(d->ob, r->section_id, r->offset, insn, 4);
     /* No public per-reloc tombstone setter exists on ObjBuilder; the const
      * cast mutates the still-private in-progress object we own outright (we
      * built every reloc in this builder). Tolerated until obj exposes an
      * obj_reloc_remove() mutator alongside obj_section/symbol_remove. */
     ((Reloc*)r)->removed = 1;
   }
 }
 
 /* ---- driver loop ---- */
 
 static void process_label(AsmDriver* d, Sym name) {
   ObjSymId id = intern_sym(d, name);
   int is_thumb_func = 0;
   (void)asm_driver_cur_section(d);
   const ObjSym* os = obj_symbol_get(d->ob, id);
   if (os && os->section_id != OBJ_SEC_NONE)
     d_panicf(d, "asm: symbol defined twice");
   if (asm_thumb_func_syms(d)) {
     is_thumb_func = d->pending_thumb_func || asm_sym_is_thumb_func(d, name);
     d->pending_thumb_func = 0;
   }
   obj_symbol_define(d->ob, id, d->cur_sec,
                     (u64)mc_pos(d->mc) | (is_thumb_func ? 1u : 0u), 0);
   /* Promote SK_UNDEF (forward ref via reloc) to SK_NOTYPE so it's a
    * real defined symbol; explicit `.type SYM, @function` will refine. */
   if (is_thumb_func)
     sym_mut(d, id)->kind = (u16)SK_FUNC;
   else if (os && os->kind == SK_UNDEF)
     sym_mut(d, id)->kind = (u16)SK_NOTYPE;
 }
 
 static Sym maybe_compose_mnemonic(AsmDriver* d, Sym head) {
   /* Loops to accept multi-dot mnemonics like RISC-V's `fcvt.w.s` /
    * `amoadd.d` — peel one `.ident` per pass, intern the joined token,
    * and stop when the next token isn't a touching dot. */
   for (;;) {
     AsmTok t = d_peek(d);
     if (!tok_is_punct(t, '.')) return head;
     if (t.flags & ASM_TF_HAS_SPACE) return head;
     (void)d_next(d);
     AsmTok rest = d_next(d);
     if (rest.kind != ASM_TOK_IDENT)
       d_panicf(d, "asm: composite mnemonic: expected ident");
     size_t hn = 0, rn = 0;
     const char* hp = asm_str(d, head, &hn);
     const char* rp = asm_str(d, rest.v.ident, &rn);
     size_t n = hn + 1 + rn;
     if (n >= 64) d_panicf(d, "asm: mnemonic too long");
     char buf[64];
     for (size_t i = 0; i < hn; ++i) buf[i] = hp[i];
     buf[hn] = '.';
     for (size_t i = 0; i < rn; ++i) buf[hn + 1 + i] = rp[i];
     head = pool_intern_slice(d->pool, (Slice){.s = buf, .len = n});
   }
 }
 
 /* ---- inline-asm driver constructor ----
  *
  * Inline-asm template walkers (per-arch) re-lex pre-substituted source
  * text through the same per-mnemonic parsers used by the standalone .s
  * driver.  This constructor builds a minimally-initialized AsmDriver
  * around a caller-supplied memory-backed AsmLexer + MCEmitter.
  *
  * The driver does not own the AsmLexer or MCEmitter, does not allocate a
  * default section (inline asm emits into whatever section the wrapping
  * cg has selected on its MCEmitter), and skips the standalone driver's
  * per-arch handle (`d->arch_asm`) — the caller has already opened its own
  * arch asm handle to thread per-block bound state through. */
 AsmDriver* asm_driver_open_inline(Compiler* c, MCEmitter* mc, AsmLexer* lex) {
   Heap* heap = (Heap*)c->ctx->heap;
   AsmDriver* d = (AsmDriver*)heap->alloc(heap, sizeof *d, _Alignof(AsmDriver));
   memset(d, 0, sizeof *d);
   d->c = c;
   d->lex = lex;
   d->mc = mc;
   d->ob = mc->obj;
   d->pool = c->global;
   d->heap = heap;
   /* The MCEmitter's section is whatever cg has set; do not override it.
    * cur_sec == OBJ_SEC_NONE means "ask the MCEmitter on demand" — we use
    * mc->section_id directly via asm_driver_cur_section's lazy init for
    * standalone, but inline asm should never reach that path because the
    * MCEmitter already has its section. Pre-seed cur_sec from the
    * MCEmitter so emit_reloc_at calls get the right section id. */
   d->cur_sec = mc->section_id;
   SymSecMap_init(&d->sec_map, heap);
   SymSymMap_init(&d->sym_map, heap);
   SymU8Map_init(&d->thumb_func_map, heap);
   SymEquMap_init(&d->equ_map, heap);
   d->arch_asm = NULL; /* caller owns its own arch asm handle */
   return d;
 }
 
 void asm_driver_close_inline(AsmDriver* d) {
   if (!d) return;
   SymSecMap_fini(&d->sec_map);
   SymSymMap_fini(&d->sym_map);
   SymU8Map_fini(&d->thumb_func_map);
   SymEquMap_fini(&d->equ_map);
   if (d->diffs) d->heap->free(d->heap, d->diffs, sizeof(AsmDiff) * d->diffs_cap);
   Heap* heap = d->heap;
   heap->free(heap, d, sizeof *d);
 }
 
 void asm_parse(Compiler* c, AsmLexer* l, MCEmitter* mc) {
   AsmDriver d;
   memset(&d, 0, sizeof d);
   d.c = c;
   d.lex = l;
   d.mc = mc;
   d.ob = mc->obj;
   d.pool = c->global;
   d.heap = (Heap*)c->ctx->heap;
   d.cur_sec = OBJ_SEC_NONE;
   SymSecMap_init(&d.sec_map, d.heap);
   SymSymMap_init(&d.sym_map, d.heap);
   SymU8Map_init(&d.thumb_func_map, d.heap);
   SymEquMap_init(&d.equ_map, d.heap);
   {
     const ArchImpl* arch = arch_for_compiler(c);
     if (!arch || !arch->asm_new) {
       SrcLoc loc = asm_lex_loc(l);
       compiler_panic(c, loc, "asm_parse: unsupported target arch %d",
                      (int)c->target.arch);
     }
     d.arch_asm = arch->asm_new(c);
   }
 
   for (;;) {
     AsmTok t = d_peek(&d);
     if (t.kind == ASM_TOK_EOF) break;
     if (t.kind == ASM_TOK_NEWLINE) {
       (void)d_next(&d);
       continue;
     }
     if (t.kind == ASM_TOK_HASH) {
       /* cpp-style linemarker; skip the whole line. */
       d_skip_to_eol(&d);
       continue;
     }
     if (tok_is_punct(t, '.')) {
       (void)d_next(&d);
       AsmTok id = d_next(&d);
       if (id.kind != ASM_TOK_IDENT)
         d_panicf(&d, "asm: expected directive name after '.'");
       do_directive(&d, id.v.ident);
       d_eat_eol(&d);
       continue;
     }
     if (t.kind == ASM_TOK_IDENT) {
       Sym head = t.v.ident;
       (void)d_next(&d);
       AsmTok nxt = d_peek(&d);
       if (tok_is_punct(nxt, ':')) {
         (void)d_next(&d);
         process_label(&d, head);
         continue;
       }
       Sym mnemonic = maybe_compose_mnemonic(&d, head);
       d.arch_asm->insn(d.arch_asm, &d, mnemonic);
       d_skip_to_eol(&d);
       continue;
     }
     /* Anything else: recover by skipping the line. */
     d_skip_to_eol(&d);
   }
 
   resolve_sym_diffs(&d);
   promote_undef_externs(&d);
   relax_local_branches(&d);
 
   if (d.arch_asm && d.arch_asm->destroy) d.arch_asm->destroy(d.arch_asm);
   SymSecMap_fini(&d.sec_map);
   SymSymMap_fini(&d.sym_map);
   SymU8Map_fini(&d.thumb_func_map);
   SymEquMap_fini(&d.equ_map);
   if (d.diffs) d.heap->free(d.heap, d.diffs, sizeof(AsmDiff) * d.diffs_cap);
 }