kit

link_script.c (52291B)

---

 /* Linker-script parser: a minimal GNU-ld-subset front end that produces
  * the structured KitLinkScript form documented in <kit/link.h>. The
  * applicator (link_layout.c) consumes the structured form; this file
  * never speaks ELF or layout.
  *
  * Subset (driven by the kernel.lds at the head of doc/DESIGN.md §13):
  *   ENTRY(symbol)
  *   SECTIONS { ... }
  *     . = expr
  *     name = expr
  *     name : [ALIGN(N)] { body }
  *     /DISCARD/ : { body }
  *   body items: *(p1 p2 ...), name = expr, . = expr
  *   exprs: int literal (dec / 0x), `.`, ident, parens,
  *          + - * / & | ^ << >>,
  *          ALIGN(align)        (1-arg: aligns `.`, GNU form)
  *          ALIGN(val, align)   (2-arg: aligns an explicit expr)
  *   slash-star comments; whitespace insensitive.
  *
  * Anything else (MEMORY, PROVIDE, KEEP, AT>, > REGION, OVERLAY, INSERT,
  * OUTPUT_FORMAT, INPUT, GROUP, MAX, MIN, line comments, quoted strings,
  * file patterns other than the implicit `*` of `*(...)`) is a parse
  * error: emits a diagnostic and returns 1, leaving *out unchanged.
  *
  * Encoding contracts the applicator relies on:
  *   - /DISCARD/ is encoded as a KitLinkOutputSection with name
  *     "/DISCARD/" (a literal sentinel, not a parsed identifier).
  *   - An output section's `: ALIGN(N)` header is encoded as the first
  *     entry in its asns[]: a dot-assignment whose expr is ALIGN(., N).
  *   - `*(p1 p2 ...)` produces one KitLinkInputMatch per pattern with
  *     file_pattern = empty slice (implicit `*`) and section_pattern set.
  *     COMMON is parsed as a literal pattern "COMMON".
  *
  * Allocation: every node and string is owned by the compiler's tu arena.
  * kit_link_script_free is therefore a no-op — the arena outlives the
  * script and is collectively freed with the compiler. During parsing we
  * grow temporary arrays on the host heap, then arena-copy at finish.
  *
  * Diagnostics: SourceManager registration of a script buffer is a future
  * cleanup; for now diagnostics carry file_id = 0 and pack the byte
  * offset into the SrcLoc.line field (col is computed inline). */
 
 #include <kit/core.h>
 #include <kit/link.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <string.h>
 
 #include "core/arena.h"
 #include "core/core.h"
 #include "core/diag.h"
 #include "core/heap.h"
 #include "core/slice.h"
 #include "core/util.h"
 
 /* The public KitLinkScript has no place to carry its backing-arena
  * pointer, so we allocate a fixed-shape owner block via heap and arena-
  * init it inline. kit_link_script_free recovers the owner by stepping
  * back from the script field to the wrapping struct. The arena's first
  * member must match struct Arena (defined in core/arena.h). */
 typedef struct ScriptOwner {
   Arena arena;
   KitLinkScript script;
 } ScriptOwner;
 
 typedef struct LSP {
   Arena* arena;
   Heap* heap;
   KitDiagSink* diag;
   const char* src;
   size_t len;
   size_t pos;
   /* one-bit error sticky: any diagnostic flips this and the parser
    * unwinds without producing partial output. */
   int err;
   /* expression-parse recursion depth (parens / unary / binop RHS); guards the
    * descent from overflowing the C stack on pathological input. */
   int expr_depth;
 } LSP;
 
 /* Maximum expression nesting depth for both parse and eval. Past this we emit
  * a clean diagnostic instead of recursing into a stack overflow. */
 #define LSP_MAX_EXPR_DEPTH 256
 
 /* ---- diagnostics ---- */
 
 static SrcLoc lsp_loc(const LSP* p, size_t off) {
   /* TODO: register the script buffer with SourceManager so diagnostics
    * carry a real file_id; until then encode the byte offset as `line`
    * and recompute a 1-based line/col on demand. */
   SrcLoc l;
   size_t i, line = 1, col = 1;
   l.file_id = 0;
   for (i = 0; i < off && i < p->len; ++i) {
     if (p->src[i] == '\n') {
       ++line;
       col = 1;
     } else {
       ++col;
     }
   }
   l.line = (u32)line;
   l.col = (u32)col;
   return l;
 }
 
 static void lsp_errf(LSP* p, size_t off, const char* fmt, ...) {
   va_list ap;
   if (!p->diag) {
     p->err = 1;
     return;
   }
   va_start(ap, fmt);
   diag_emitv(p->diag, DIAG_ERROR, lsp_loc(p, off), fmt, ap);
   va_end(ap);
   p->err = 1;
 }
 
 /* ---- arena helpers ---- */
 
 static char* lsp_strdup(LSP* p, const char* s, size_t n) {
   return arena_strdup(p->arena, s, n);
 }
 
 /* Arena-copy a span of the script text and return a KitSlice over the
  * copy. The copy is NUL-terminated (arena_strdup), so consumers that hit
  * a host boundary can use .s directly. */
 static KitSlice lsp_slice(LSP* p, const char* s, size_t n) {
   KitSlice out;
   out.s = lsp_strdup(p, s, n);
   out.len = out.s ? n : 0;
   return out;
 }
 
 static KitLinkExpr* lsp_new_expr(LSP* p) {
   return arena_znew(p->arena, KitLinkExpr);
 }
 
 /* ---- heap-backed temp vectors (copied to the arena at finish) ---- */
 
 typedef struct VecAsn {
   KitLinkAssignment* p;
   u32 n, cap;
 } VecAsn;
 typedef struct VecMatch {
   KitLinkInputMatch* p;
   u32 n, cap;
 } VecMatch;
 typedef struct VecSec {
   KitLinkOutputSection* p;
   u32 n, cap;
 } VecSec;
 typedef struct VecRegion {
   KitLinkRegion* p;
   u32 n, cap;
 } VecRegion;
 typedef struct VecPhdr {
   KitLinkPhdr* p;
   u32 n, cap;
 } VecPhdr;
 typedef struct VecAssert {
   KitLinkAssertion* p;
   u32 n, cap;
 } VecAssert;
 typedef struct VecSlice {
   KitSlice* p;
   u32 n, cap;
 } VecSlice;
 
 static int vec_reserve_(LSP* p, void** ptr, u32* cap, u32 want, size_t es) {
   u32 nc;
   void* nb;
   if (*cap >= want) return 0;
   nc = *cap ? *cap * 2 : 8;
   while (nc < want) nc *= 2;
   nb = p->heap->realloc(p->heap, *ptr, (size_t)*cap * es, (size_t)nc * es,
                         sizeof(void*));
   if (!nb) return 1;
   *ptr = nb;
   *cap = nc;
   return 0;
 }
 
 #define VEC_PUSH(p, v, val)                                               \
   (vec_reserve_((p), (void**)&(v).p, &(v).cap, (v).n + 1, sizeof(*(v).p)) \
        ? 1                                                                \
        : ((v).p[(v).n++] = (val), 0))
 
 static void vec_free_(LSP* p, void* ptr, u32 cap, size_t es) {
   if (ptr) p->heap->free(p->heap, ptr, (size_t)cap * es);
 }
 
 /* ---- lex primitives ---- */
 
 static int is_id_start(int c) {
   return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' ||
          c == '.';
 }
 static int is_id_cont(int c) {
   return is_id_start(c) || (c >= '0' && c <= '9') || c == '-';
 }
 
 static void skip_ws(LSP* p) {
   while (p->pos < p->len) {
     char ch = p->src[p->pos];
     if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') {
       ++p->pos;
       continue;
     }
     if (ch == '/' && p->pos + 1 < p->len && p->src[p->pos + 1] == '*') {
       size_t start = p->pos;
       p->pos += 2;
       while (p->pos + 1 < p->len &&
              !(p->src[p->pos] == '*' && p->src[p->pos + 1] == '/')) {
         ++p->pos;
       }
       if (p->pos + 1 >= p->len) {
         lsp_errf(p, start, "unterminated /* comment");
         return;
       }
       p->pos += 2;
       continue;
     }
     if (ch == '/' && p->pos + 1 < p->len && p->src[p->pos + 1] == '/') {
       lsp_errf(p, p->pos, "// line comments not supported");
       return;
     }
     break;
   }
 }
 
 static int peek_ch(LSP* p) {
   skip_ws(p);
   if (p->err) return -1;
   if (p->pos >= p->len) return -1;
   return (unsigned char)p->src[p->pos];
 }
 
 static int match_ch(LSP* p, char ch) {
   skip_ws(p);
   if (p->err) return 0;
   if (p->pos < p->len && p->src[p->pos] == ch) {
     ++p->pos;
     return 1;
   }
   return 0;
 }
 
 static int expect_ch(LSP* p, char ch) {
   if (match_ch(p, ch)) return 0;
   lsp_errf(p, p->pos, "expected '%c'", ch);
   return 1;
 }
 
 /* Lex an identifier-or-section-name token in place: returns a pointer
  * into p->src and length via *out_len. Section names like .text.* and
  * /DISCARD/ are handled by the section-name-aware variant below. */
 static int lex_ident(LSP* p, const char** out, size_t* out_len) {
   size_t start;
   skip_ws(p);
   if (p->err) return 1;
   if (p->pos >= p->len || !is_id_start((unsigned char)p->src[p->pos])) {
     lsp_errf(p, p->pos, "expected identifier");
     return 1;
   }
   start = p->pos;
   while (p->pos < p->len && is_id_cont((unsigned char)p->src[p->pos])) ++p->pos;
   *out = p->src + start;
   *out_len = p->pos - start;
   return 0;
 }
 
 static int lex_string(LSP* p, KitSlice* out) {
   size_t start;
   skip_ws(p);
   if (p->err) return 1;
   if (p->pos >= p->len || p->src[p->pos] != '"') {
     lsp_errf(p, p->pos, "expected string literal");
     return 1;
   }
   ++p->pos;
   start = p->pos;
   while (p->pos < p->len && p->src[p->pos] != '"') {
     if (p->src[p->pos] == '\\') {
       lsp_errf(p, p->pos, "escapes in linker-script strings not supported");
       return 1;
     }
     ++p->pos;
   }
   if (p->pos >= p->len) {
     lsp_errf(p, start, "unterminated string literal");
     return 1;
   }
   *out = lsp_slice(p, p->src + start, p->pos - start);
   ++p->pos;
   return out->s ? 0 : 1;
 }
 
 static int lex_ident_or_string(LSP* p, KitSlice* out) {
   int ch;
   skip_ws(p);
   if (p->err) return 1;
   ch = peek_ch(p);
   if (ch == '"') return lex_string(p, out);
   {
     const char* s;
     size_t n;
     if (lex_ident(p, &s, &n)) return 1;
     *out = lsp_slice(p, s, n);
     return out->s ? 0 : 1;
   }
 }
 
 /* Match a literal keyword. Caller must have already peeked. */
 static int match_kw(LSP* p, const char* kw) {
   size_t klen = slice_from_cstr(kw).len;
   size_t save;
   skip_ws(p);
   if (p->err) return 0;
   save = p->pos;
   if (p->pos + klen > p->len) return 0;
   if (memcmp(p->src + p->pos, kw, klen) != 0) return 0;
   /* must not glue to a following id-cont character */
   if (p->pos + klen < p->len &&
       is_id_cont((unsigned char)p->src[p->pos + klen]))
     return 0;
   p->pos += klen;
   (void)save;
   return 1;
 }
 
 /* ---- expression parser (precedence climbing) ----
  *
  * Levels (low -> high):
  *   0: |
  *   1: ^
  *   2: &
  *   3: << >>
  *   4: + -
  *   5: * /
  *   6: unary (none beyond parenthesized atoms here)
  *   atom: int | . | ALIGN(e,a) | ident | (expr)
  */
 
 static KitLinkExpr* parse_expr(LSP* p);
 static KitLinkExpr* parse_atom(LSP* p);
 
 static KitLinkExpr* parse_int(LSP* p) {
   KitLinkExpr* e;
   size_t start = p->pos;
   /* Accumulate unsigned: linker-script addresses routinely set the top bit
    * (e.g. 0xFFFFFFFF80000000 high-half kernels); a signed shift/multiply would
    * be UB there. The value is a bit pattern, reinterpreted into int_val below. */
   u64 v = 0;
   if (p->pos + 1 < p->len && p->src[p->pos] == '0' &&
       (p->src[p->pos + 1] == 'x' || p->src[p->pos + 1] == 'X')) {
     p->pos += 2;
     if (p->pos >= p->len) {
       lsp_errf(p, start, "malformed hex literal");
       return NULL;
     }
     while (p->pos < p->len) {
       char ch = p->src[p->pos];
       int d;
       if (ch >= '0' && ch <= '9')
         d = ch - '0';
       else if (ch >= 'a' && ch <= 'f')
         d = 10 + (ch - 'a');
       else if (ch >= 'A' && ch <= 'F')
         d = 10 + (ch - 'A');
       else
         break;
       v = (v << 4) | d;
       ++p->pos;
     }
     if (p->pos == start + 2) {
       lsp_errf(p, start, "empty hex literal");
       return NULL;
     }
   } else {
     while (p->pos < p->len && p->src[p->pos] >= '0' && p->src[p->pos] <= '9') {
       v = v * 10 + (p->src[p->pos] - '0');
       ++p->pos;
     }
     if (p->pos == start) {
       lsp_errf(p, start, "expected integer");
       return NULL;
     }
   }
   if (p->pos < p->len) {
     char suffix = p->src[p->pos];
     if (suffix == 'K' || suffix == 'k') {
       v *= 1024ull;
       ++p->pos;
     } else if (suffix == 'M' || suffix == 'm') {
       v *= 1024ull * 1024ull;
       ++p->pos;
     } else if (suffix == 'G' || suffix == 'g') {
       v *= 1024ull * 1024ull * 1024ull;
       ++p->pos;
     }
   }
   e = lsp_new_expr(p);
   if (!e) return NULL;
   e->kind = KIT_LE_INT;
   e->v.int_val = (i64)v;
   return e;
 }
 
 static KitLinkExpr* parse_atom_inner(LSP* p) {
   int ch;
   skip_ws(p);
   if (p->err) return NULL;
   ch = peek_ch(p);
   if (ch < 0) {
     lsp_errf(p, p->pos, "unexpected end of expression");
     return NULL;
   }
   if (ch == '-' || ch == '+') {
     int neg = (ch == '-');
     KitLinkExpr* val;
     KitLinkExpr* e;
     ++p->pos;
     val = parse_atom(p);
     if (!val) return NULL;
     if (!neg) return val;
     e = lsp_new_expr(p);
     if (!e) return NULL;
     e->kind = KIT_LE_NEG;
     e->v.align.val = val;
     e->v.align.align = NULL;
     return e;
   }
   if (ch == '(') {
     KitLinkExpr* e;
     ++p->pos;
     e = parse_expr(p);
     if (!e) return NULL;
     if (expect_ch(p, ')')) return NULL;
     return e;
   }
   if (ch == '.') {
     /* `.` only — bare dot, not a dotted ident. We disambiguate by
      * looking at the next char: a digit/letter/underscore/dot here is a
      * lex error in this subset (no .text in expression position). */
     size_t off = p->pos;
     ++p->pos;
     if (p->pos < p->len && is_id_cont((unsigned char)p->src[p->pos])) {
       lsp_errf(p, off, "dotted identifiers not allowed in expressions");
       return NULL;
     }
     {
       KitLinkExpr* e = lsp_new_expr(p);
       if (!e) return NULL;
       e->kind = KIT_LE_DOT;
       return e;
     }
   }
   if (ch >= '0' && ch <= '9') return parse_int(p);
   if (is_id_start(ch)) {
     /* either a built-in helper or a symbol reference */
     if (match_kw(p, "ALIGN") || match_kw(p, "BLOCK")) {
       /* Two forms, matching GNU ld:
        *   ALIGN(align)        — align the current location `.` (val defaults
        *                         to dot); the common `. = ALIGN(N)` idiom.
        *   ALIGN(val, align)   — align an explicit expression. */
       KitLinkExpr *val, *aln, *e;
       KitLinkExprKind kind =
           (memcmp(p->src + p->pos - 5, "BLOCK", 5) == 0) ? KIT_LE_BLOCK
                                                           : KIT_LE_ALIGN;
       if (expect_ch(p, '(')) return NULL;
       val = parse_expr(p);
       if (!val) return NULL;
       skip_ws(p);
       if (p->pos < p->len && p->src[p->pos] == ',') {
         ++p->pos;
         aln = parse_expr(p);
         if (!aln) return NULL;
       } else {
         /* 1-arg form: the parsed expr is the alignment; val is `.`. */
         aln = val;
         val = lsp_new_expr(p);
         if (!val) return NULL;
         val->kind = KIT_LE_DOT;
       }
       if (expect_ch(p, ')')) return NULL;
       e = lsp_new_expr(p);
       if (!e) return NULL;
       e->kind = (uint8_t)kind;
       e->v.align.val = val;
       e->v.align.align = aln;
       return e;
     }
     if (match_kw(p, "MAX") || match_kw(p, "MIN")) {
       KitLinkExprKind kind =
           (memcmp(p->src + p->pos - 3, "MIN", 3) == 0) ? KIT_LE_MIN
                                                         : KIT_LE_MAX;
       KitLinkExpr *lhs, *rhs, *e;
       if (expect_ch(p, '(')) return NULL;
       lhs = parse_expr(p);
       if (!lhs) return NULL;
       if (expect_ch(p, ',')) return NULL;
       rhs = parse_expr(p);
       if (!rhs) return NULL;
       if (expect_ch(p, ')')) return NULL;
       e = lsp_new_expr(p);
       if (!e) return NULL;
       e->kind = (uint8_t)kind;
       e->v.bin.lhs = lhs;
       e->v.bin.rhs = rhs;
       return e;
     }
     if (match_kw(p, "ORIGIN") || match_kw(p, "LENGTH") ||
         match_kw(p, "ADDR") || match_kw(p, "LOADADDR") ||
         match_kw(p, "SIZEOF") || match_kw(p, "DEFINED")) {
       size_t end = p->pos;
       size_t start = end;
       KitLinkExprKind kind;
       const char* s;
       size_t n;
       KitLinkExpr* e;
       while (start > 0 && is_id_cont((unsigned char)p->src[start - 1]))
         --start;
       if (end - start == 6 && memcmp(p->src + start, "ORIGIN", 6) == 0)
         kind = KIT_LE_REGION_ORIGIN;
       else if (end - start == 6 && memcmp(p->src + start, "LENGTH", 6) == 0)
         kind = KIT_LE_REGION_LENGTH;
       else if (end - start == 4 && memcmp(p->src + start, "ADDR", 4) == 0)
         kind = KIT_LE_ADDR;
       else if (end - start == 8 && memcmp(p->src + start, "LOADADDR", 8) == 0)
         kind = KIT_LE_LOADADDR;
       else if (end - start == 6 && memcmp(p->src + start, "SIZEOF", 6) == 0)
         kind = KIT_LE_SIZEOF;
       else
         kind = KIT_LE_DEFINED;
       if (expect_ch(p, '(')) return NULL;
       if (lex_ident(p, &s, &n)) return NULL;
       if (expect_ch(p, ')')) return NULL;
       e = lsp_new_expr(p);
       if (!e) return NULL;
       e->kind = (uint8_t)kind;
       e->v.name = lsp_slice(p, s, n);
       return e;
     }
     if (match_kw(p, "SIZEOF_HEADERS")) {
       KitLinkExpr* e;
       if (match_ch(p, '(')) {
         if (expect_ch(p, ')')) return NULL;
       }
       e = lsp_new_expr(p);
       if (!e) return NULL;
       e->kind = KIT_LE_SIZEOF_HEADERS;
       return e;
     }
     if (match_kw(p, "ABSOLUTE")) {
       KitLinkExpr *val, *e;
       if (expect_ch(p, '(')) return NULL;
       val = parse_expr(p);
       if (!val) return NULL;
       if (expect_ch(p, ')')) return NULL;
       e = lsp_new_expr(p);
       if (!e) return NULL;
       e->kind = KIT_LE_ABSOLUTE;
       e->v.align.val = val;
       e->v.align.align = NULL;
       return e;
     }
     {
       const char* s;
       size_t n;
       KitLinkExpr* e;
       if (lex_ident(p, &s, &n)) return NULL;
       e = lsp_new_expr(p);
       if (!e) return NULL;
       e->kind = KIT_LE_SYM;
       e->v.name = lsp_slice(p, s, n);
       return e;
     }
   }
   lsp_errf(p, p->pos, "unexpected '%c' in expression", (char)ch);
   return NULL;
 }
 
 /* Depth-guarded entry to atom parsing. Every nesting level (parens, unary,
  * binop RHS, helper-call argument) descends through parse_atom, so bumping the
  * counter here bounds total expression-parse recursion. */
 static KitLinkExpr* parse_atom(LSP* p) {
   KitLinkExpr* e;
   if (p->err) return NULL;
   if (++p->expr_depth > LSP_MAX_EXPR_DEPTH) {
     lsp_errf(p, p->pos, "linker-script expression nested too deeply (>%d)",
              LSP_MAX_EXPR_DEPTH);
     --p->expr_depth;
     return NULL;
   }
   e = parse_atom_inner(p);
   --p->expr_depth;
   return e;
 }
 
 /* Returns >=0 binding power for a binary operator at p->pos and
  * advances past it; -1 if no binary operator at the lookahead. */
 static int try_take_binop(LSP* p, KitLinkExprKind* out_kind) {
   int ch;
   skip_ws(p);
   if (p->err) return -1;
   if (p->pos >= p->len) return -1;
   ch = (unsigned char)p->src[p->pos];
   switch (ch) {
     case '|':
       ++p->pos;
       *out_kind = KIT_LE_OR;
       return 0;
     case '^':
       ++p->pos;
       *out_kind = KIT_LE_XOR;
       return 1;
     case '&':
       ++p->pos;
       *out_kind = KIT_LE_AND;
       return 2;
     case '<':
       if (p->pos + 1 < p->len && p->src[p->pos + 1] == '<') {
         p->pos += 2;
         *out_kind = KIT_LE_SHL;
         return 3;
       }
       return -1;
     case '>':
       if (p->pos + 1 < p->len && p->src[p->pos + 1] == '>') {
         p->pos += 2;
         *out_kind = KIT_LE_SHR;
         return 3;
       }
       return -1;
     case '+':
       ++p->pos;
       *out_kind = KIT_LE_ADD;
       return 4;
     case '-':
       ++p->pos;
       *out_kind = KIT_LE_SUB;
       return 4;
     case '*':
       ++p->pos;
       *out_kind = KIT_LE_MUL;
       return 5;
     case '/':
       /* Division. Block-comment and /DISCARD/ openers are filtered
        * elsewhere: skip_ws eats slash-star comments, and /DISCARD/ is
        * recognized by the SECTIONS-body loop before expression
        * context. */
       ++p->pos;
       *out_kind = KIT_LE_DIV;
       return 5;
     default:
       return -1;
   }
 }
 
 static KitLinkExpr* parse_binop_rhs(LSP* p, int min_bp, KitLinkExpr* lhs) {
   while (!p->err) {
     size_t save;
     KitLinkExprKind k;
     int bp;
     skip_ws(p);
     if (p->err) return NULL;
     save = p->pos;
     bp = try_take_binop(p, &k);
     if (bp < 0) return lhs;
     if (bp < min_bp) {
       p->pos = save;
       return lhs;
     }
     {
       KitLinkExpr* rhs = parse_atom(p);
       KitLinkExpr* node;
       if (!rhs) return NULL;
       rhs = parse_binop_rhs(p, bp + 1, rhs);
       if (!rhs) return NULL;
       node = lsp_new_expr(p);
       if (!node) return NULL;
       node->kind = (uint8_t)k;
       node->v.bin.lhs = lhs;
       node->v.bin.rhs = rhs;
       lhs = node;
     }
   }
   return NULL;
 }
 
 static KitLinkExpr* parse_expr(LSP* p) {
   KitLinkExpr* lhs = parse_atom(p);
   if (!lhs) return NULL;
   return parse_binop_rhs(p, 0, lhs);
 }
 
 /* ---- assignment helpers ---- */
 
 static int push_dot_align(LSP* p, VecAsn* asns, KitLinkExpr* align_n) {
   KitLinkExpr* dot;
   KitLinkExpr* aln;
   KitLinkAssignment a;
   dot = lsp_new_expr(p);
   if (!dot) return 1;
   dot->kind = KIT_LE_DOT;
   aln = lsp_new_expr(p);
   if (!aln) return 1;
   aln->kind = KIT_LE_ALIGN;
   aln->v.align.val = dot;
   aln->v.align.align = align_n;
   memset(&a, 0, sizeof(a));
   a.kind = KIT_LAS_DOT;
   a.sym = KIT_SLICE_NULL;
   a.expr = aln;
   return VEC_PUSH(p, *asns, a);
 }
 
 /* ---- output section body ---- */
 
 static int lex_pattern_token(LSP* p, const char** out, size_t* out_len) {
   size_t start;
   skip_ws(p);
   if (p->err) return 1;
   start = p->pos;
   while (p->pos < p->len) {
     char c = p->src[p->pos];
     if (c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '(' ||
         c == ')' || c == '{' || c == '}' || c == ';' || c == ':' ||
         c == ',')
       break;
     ++p->pos;
   }
   if (p->pos == start) {
     lsp_errf(p, p->pos, "expected pattern");
     return 1;
   }
   *out = p->src + start;
   *out_len = p->pos - start;
   return 0;
 }
 
 static const KitSlice* copy_slice_vec(LSP* p, const VecSlice* v) {
   KitSlice* arr;
   if (!v || !v->n) return NULL;
   arr = arena_array(p->arena, KitSlice, v->n);
   if (!arr) return NULL;
   memcpy(arr, v->p, sizeof(*arr) * v->n);
   return arr;
 }
 
 static int parse_file_excludes(LSP* p, VecSlice* excludes) {
   if (expect_ch(p, '(')) return 1;
   for (;;) {
     int ch;
     const char* s;
     size_t n;
     KitSlice sl;
     skip_ws(p);
     if (p->err) return 1;
     ch = peek_ch(p);
     if (ch == ')') {
       ++p->pos;
       return 0;
     }
     if (ch < 0) {
       lsp_errf(p, p->pos, "unterminated EXCLUDE_FILE");
       return 1;
     }
     if (lex_pattern_token(p, &s, &n)) return 1;
     sl = lsp_slice(p, s, n);
     if (!sl.s) return 1;
     if (VEC_PUSH(p, *excludes, sl)) return 1;
   }
 }
 
 static int parse_input_matchers_for_file(LSP* p, VecMatch* out,
                                          KitSlice file_pattern, int keep) {
   /* expect `(p1 p2 ...)` */
   VecSlice excludes = {0};
   if (expect_ch(p, '(')) return 1;
   for (;;) {
     int ch;
     skip_ws(p);
     if (p->err) return 1;
     ch = peek_ch(p);
     if (ch == ')') {
       ++p->pos;
       vec_free_(p, excludes.p, excludes.cap, sizeof(*excludes.p));
       return 0;
     }
     if (ch < 0) {
       lsp_errf(p, p->pos, "unterminated `*(...)`");
       goto fail;
     }
     if (match_kw(p, "EXCLUDE_FILE")) {
       if (parse_file_excludes(p, &excludes)) goto fail;
       continue;
     }
     {
       const char* s;
       size_t n;
       KitLinkInputMatch m;
       if (lex_pattern_token(p, &s, &n)) goto fail;
       if (n == 0) {
         lsp_errf(p, p->pos, "expected section pattern");
         goto fail;
       }
       memset(&m, 0, sizeof(m));
       m.file_pattern = file_pattern;
       m.section_pattern = lsp_slice(p, s, n);
       m.exclude_file_patterns = copy_slice_vec(p, &excludes);
       m.nexclude_file_patterns = excludes.n;
       m.keep = keep;
       if (excludes.n && !m.exclude_file_patterns) goto fail;
       if (VEC_PUSH(p, *out, m)) goto fail;
     }
   }
 fail:
   vec_free_(p, excludes.p, excludes.cap, sizeof(*excludes.p));
   return 1;
 }
 
 static int parse_input_matchers(LSP* p, VecMatch* out, int keep) {
   /* opening `*` already consumed by caller. */
   return parse_input_matchers_for_file(p, out, KIT_SLICE_NULL, keep);
 }
 
 static int parse_assignment_call(LSP* p, KitLinkAsnKind kind, VecAsn* asns) {
   const char* s;
   size_t n;
   KitLinkExpr* e;
   KitLinkAssignment a;
   if (expect_ch(p, '(')) return 1;
   if (lex_ident(p, &s, &n)) return 1;
   if (expect_ch(p, '=')) return 1;
   e = parse_expr(p);
   if (!e) return 1;
   if (expect_ch(p, ')')) return 1;
   (void)match_ch(p, ';');
   memset(&a, 0, sizeof(a));
   a.kind = (uint8_t)kind;
   a.sym = lsp_slice(p, s, n);
   a.expr = e;
   return VEC_PUSH(p, *asns, a);
 }
 
 static int parse_assertion(LSP* p, VecAssert* asserts) {
   KitLinkAssertion a;
   memset(&a, 0, sizeof(a));
   if (expect_ch(p, '(')) return 1;
   a.expr = parse_expr(p);
   if (!a.expr) return 1;
   if (expect_ch(p, ',')) return 1;
   if (lex_string(p, &a.message)) return 1;
   if (expect_ch(p, ')')) return 1;
   (void)match_ch(p, ';');
   return VEC_PUSH(p, *asserts, a);
 }
 
 static int parse_file_qualified_matchers(LSP* p, VecMatch* inputs,
                                          const char* file, size_t file_len,
                                          int keep) {
   KitSlice fp = lsp_slice(p, file, file_len);
   if (!fp.s) return 1;
   return parse_input_matchers_for_file(p, inputs, fp, keep);
 }
 
 static int parse_section_body(LSP* p, VecMatch* inputs, VecAsn* asns,
                               VecAssert* asserts, KitLinkExpr** fill_out,
                               u32* body_seq) {
   u32 prev_in = inputs->n;
   u32 prev_as = asns->n;
   if (expect_ch(p, '{')) return 1;
   for (;;) {
     int ch;
     /* Stamp the source-order body position onto every input match and
      * assignment pushed by the previous iteration, then bump for the next
      * command. One body command (a `*(...)`, a `sym = expr`, a `. = expr`)
      * may push several input matches (`*(.a .b .c)`) but they all belong to
      * the same command and share its body_seq. The applicator merge-walks
      * inputs+asns by body_seq to execute them in true source order. */
     while (prev_in < inputs->n) inputs->p[prev_in++].body_seq = *body_seq;
     while (prev_as < asns->n) asns->p[prev_as++].body_seq = *body_seq;
     ++*body_seq;
     skip_ws(p);
     if (p->err) return 1;
     ch = peek_ch(p);
     if (ch == '}') {
       ++p->pos;
       return 0;
     }
     if (ch < 0) {
       lsp_errf(p, p->pos, "unterminated section body");
       return 1;
     }
     if (ch == '*') {
       ++p->pos;
       if (parse_input_matchers(p, inputs, 0)) return 1;
       continue;
     }
     if (ch == '.') {
       /* `. = expr;` */
       size_t off = p->pos;
       ++p->pos;
       skip_ws(p);
       if (p->err) return 1;
       if (!match_ch(p, '=')) {
         lsp_errf(p, off, "expected `. = expr` in section body");
         return 1;
       }
       {
         KitLinkExpr* e = parse_expr(p);
         KitLinkAssignment a;
         if (!e) return 1;
         if (!match_ch(p, ';')) { /* ; is optional but encouraged */
         }
         memset(&a, 0, sizeof(a));
         a.kind = KIT_LAS_DOT;
         a.sym = KIT_SLICE_NULL;
         a.expr = e;
         if (VEC_PUSH(p, *asns, a)) return 1;
       }
       continue;
     }
     if (is_id_start(ch)) {
       if (match_kw(p, "KEEP")) {
         const char* fs;
         size_t fn;
         if (expect_ch(p, '(')) return 1;
         skip_ws(p);
         if (p->err) return 1;
         if (peek_ch(p) == '*') {
           ++p->pos;
           if (parse_input_matchers(p, inputs, 1)) return 1;
         } else {
           if (lex_pattern_token(p, &fs, &fn)) return 1;
           if (parse_file_qualified_matchers(p, inputs, fs, fn, 1)) return 1;
         }
         if (expect_ch(p, ')')) return 1;
         continue;
       }
       if (match_kw(p, "FILL")) {
         if (expect_ch(p, '(')) return 1;
         *fill_out = parse_expr(p);
         if (!*fill_out) return 1;
         if (expect_ch(p, ')')) return 1;
         (void)match_ch(p, ';');
         continue;
       }
       if (match_kw(p, "ASSERT")) {
         if (parse_assertion(p, asserts)) return 1;
         continue;
       }
       if (match_kw(p, "PROVIDE_HIDDEN")) {
         if (parse_assignment_call(p, KIT_LAS_PROVIDE_HIDDEN, asns)) return 1;
         continue;
       }
       if (match_kw(p, "PROVIDE")) {
         if (parse_assignment_call(p, KIT_LAS_PROVIDE, asns)) return 1;
         continue;
       }
       if (match_kw(p, "HIDDEN")) {
         if (parse_assignment_call(p, KIT_LAS_HIDDEN, asns)) return 1;
         continue;
       }
       /* sym = expr; or file(section-patterns) */
       const char* s;
       size_t n;
       KitLinkExpr* e;
       KitLinkAssignment a;
       if (lex_ident(p, &s, &n)) return 1;
       skip_ws(p);
       if (p->err) return 1;
       if (p->pos < p->len && p->src[p->pos] == '(') {
         if (parse_file_qualified_matchers(p, inputs, s, n, 0)) return 1;
         continue;
       }
       if (!match_ch(p, '=')) {
         lsp_errf(p, p->pos, "expected `=` after `%.*s`", (int)n, s);
         return 1;
       }
       e = parse_expr(p);
       if (!e) return 1;
       (void)match_ch(p, ';');
       memset(&a, 0, sizeof(a));
       a.kind = KIT_LAS_SYM;
       a.sym = lsp_slice(p, s, n);
       a.expr = e;
       if (VEC_PUSH(p, *asns, a)) return 1;
       continue;
     }
     lsp_errf(p, p->pos, "unexpected '%c' in section body", (char)ch);
     return 1;
   }
 }
 
 /* ---- output section header ---- */
 
 static int parse_output_section(LSP* p, const char* name_buf, size_t name_len,
                                 KitLinkExpr* vma, bool noload,
                                 VecSec* sections, VecAssert* asserts) {
   /* The `:` is the next non-ws char on entry. Header may carry
    * `: ALIGN(N)` then `{ body }`. */
   KitLinkOutputSection sec;
   VecMatch inputs = {0};
   VecAsn asns = {0};
   VecSlice phdrs = {0};
   KitLinkExpr* align_n = NULL;
   KitLinkExpr* subalign = NULL;
   KitLinkExpr* fill = NULL;
   KitLinkExpr* lma = NULL;
   KitLinkExpr* flags = NULL;
   KitSlice region = KIT_SLICE_NULL;
   KitSlice load_region = KIT_SLICE_NULL;
 
   if (expect_ch(p, ':')) return 1;
   for (;;) {
     skip_ws(p);
     if (p->err) return 1;
     if (match_kw(p, "ALIGN")) {
       if (expect_ch(p, '(')) return 1;
       align_n = parse_expr(p);
       if (!align_n) return 1;
       if (expect_ch(p, ')')) return 1;
       continue;
     }
     if (match_kw(p, "SUBALIGN")) {
       if (expect_ch(p, '(')) return 1;
       subalign = parse_expr(p);
       if (!subalign) return 1;
       if (expect_ch(p, ')')) return 1;
       continue;
     }
     if (match_kw(p, "AT")) {
       if (expect_ch(p, '(')) return 1;
       lma = parse_expr(p);
       if (!lma) return 1;
       if (expect_ch(p, ')')) return 1;
       continue;
     }
     if (match_kw(p, "FLAGS")) {
       if (expect_ch(p, '(')) return 1;
       flags = parse_expr(p);
       if (!flags) return 1;
       if (expect_ch(p, ')')) return 1;
       continue;
     }
     break;
   }
 
   /* Section header alignment is encoded as the first asn — applicator
    * pulls it before processing inputs. It runs at body_seq 0 (the section
    * base); body commands start at body_seq 1. */
   if (align_n) {
     if (push_dot_align(p, &asns, align_n)) goto fail;
     asns.p[asns.n - 1].body_seq = 0;
   }
 
   {
     u32 body_seq = 1;
     if (parse_section_body(p, &inputs, &asns, asserts, &fill, &body_seq))
       goto fail;
   }
 
   for (;;) {
     int ch;
     skip_ws(p);
     if (p->err) goto fail;
     ch = peek_ch(p);
     if (ch == ';') {
       ++p->pos;
       break;
     }
     if (ch == '>') {
       const char* s;
       size_t n;
       ++p->pos;
       if (lex_ident(p, &s, &n)) goto fail;
       region = lsp_slice(p, s, n);
       if (!region.s) goto fail;
       continue;
     }
     if (ch == ':') {
       const char* s;
       size_t n;
       KitSlice sl;
       ++p->pos;
       if (lex_ident(p, &s, &n)) goto fail;
       sl = lsp_slice(p, s, n);
       if (!sl.s) goto fail;
       if (VEC_PUSH(p, phdrs, sl)) goto fail;
       continue;
     }
     if (ch == '=') {
       ++p->pos;
       fill = parse_expr(p);
       if (!fill) goto fail;
       continue;
     }
     if (match_kw(p, "AT")) {
       const char* s;
       size_t n;
       if (match_ch(p, '>')) {
         if (lex_ident(p, &s, &n)) goto fail;
         load_region = lsp_slice(p, s, n);
         if (!load_region.s) goto fail;
         continue;
       }
       if (expect_ch(p, '(')) goto fail;
       lma = parse_expr(p);
       if (!lma) goto fail;
       if (expect_ch(p, ')')) goto fail;
       continue;
     }
     if (match_kw(p, "FILL")) {
       if (expect_ch(p, '(')) goto fail;
       fill = parse_expr(p);
       if (!fill) goto fail;
       if (expect_ch(p, ')')) goto fail;
       continue;
     }
     break;
   }
 
   /* Materialize. */
   {
     KitLinkInputMatch* arr_in = NULL;
     KitLinkAssignment* arr_as = NULL;
     KitSlice* arr_ph = NULL;
     if (inputs.n) {
       arr_in = arena_array(p->arena, KitLinkInputMatch, inputs.n);
       if (!arr_in) goto fail;
       memcpy(arr_in, inputs.p, sizeof(*arr_in) * inputs.n);
     }
     if (asns.n) {
       arr_as = arena_array(p->arena, KitLinkAssignment, asns.n);
       if (!arr_as) goto fail;
       memcpy(arr_as, asns.p, sizeof(*arr_as) * asns.n);
     }
     if (phdrs.n) {
       arr_ph = arena_array(p->arena, KitSlice, phdrs.n);
       if (!arr_ph) goto fail;
       memcpy(arr_ph, phdrs.p, sizeof(*arr_ph) * phdrs.n);
     }
     memset(&sec, 0, sizeof(sec));
     sec.name = lsp_slice(p, name_buf, name_len);
     sec.vma = vma;
     sec.lma = lma;
     sec.inputs = arr_in;
     sec.ninputs = inputs.n;
     sec.region = region;
     sec.load_region = load_region;
     sec.phdrs = arr_ph;
     sec.nphdrs = phdrs.n;
     sec.asns = arr_as;
     sec.nasns = asns.n;
     sec.subalign = subalign;
     sec.fill = fill;
     sec.flags = flags;
     sec.noload = noload;
   }
 
   vec_free_(p, inputs.p, inputs.cap, sizeof(*inputs.p));
   vec_free_(p, asns.p, asns.cap, sizeof(*asns.p));
   vec_free_(p, phdrs.p, phdrs.cap, sizeof(*phdrs.p));
 
   return VEC_PUSH(p, *sections, sec);
 
 fail:
   vec_free_(p, inputs.p, inputs.cap, sizeof(*inputs.p));
   vec_free_(p, asns.p, asns.cap, sizeof(*asns.p));
   vec_free_(p, phdrs.p, phdrs.cap, sizeof(*phdrs.p));
   return 1;
 }
 
 /* ---- SECTIONS{...} ---- */
 
 /* Stamp a monotonic textual-order sequence onto any top_asns / sections
  * pushed since the previous call. Top-level assignments and output sections
  * share one counter (*seq) so layout can interleave them in source order;
  * see KitLinkAssignment.seq / KitLinkOutputSection.seq. */
 static void stamp_seq(VecAsn* top_asns, u32* prev_as, VecSec* sections,
                       u32* prev_sec, u32* seq) {
   while (*prev_as < top_asns->n) top_asns->p[(*prev_as)++].seq = (*seq)++;
   while (*prev_sec < sections->n) sections->p[(*prev_sec)++].seq = (*seq)++;
 }
 
 static int parse_sections_block(LSP* p, VecAsn* top_asns, VecSec* sections,
                                 VecAssert* asserts) {
   u32 seq = 0;
   u32 prev_as = 0;
   u32 prev_sec = 0;
   if (expect_ch(p, '{')) return 1;
   for (;;) {
     int ch;
     /* Assign source-order seq to whatever the previous iteration pushed.
      * (A single iteration appends at most one section but may append a
      * burst of assignments via parse_assignment_call.) */
     stamp_seq(top_asns, &prev_as, sections, &prev_sec, &seq);
     skip_ws(p);
     if (p->err) return 1;
     ch = peek_ch(p);
     if (ch == '}') {
       ++p->pos;
       return 0;
     }
     if (ch < 0) {
       lsp_errf(p, p->pos, "unterminated SECTIONS block");
       return 1;
     }
     /* /DISCARD/ : { body } */
     if (ch == '/') {
       static const char kDiscard[] = "/DISCARD/";
       size_t klen = sizeof(kDiscard) - 1;
       if (p->pos + klen <= p->len &&
           memcmp(p->src + p->pos, kDiscard, klen) == 0) {
         p->pos += klen;
         if (parse_output_section(p, kDiscard, klen, NULL, false, sections,
                                  asserts))
           return 1;
         continue;
       }
       lsp_errf(p, p->pos, "expected /DISCARD/ or section header");
       return 1;
     }
     /* `. = expr;` at SECTIONS top level */
     if (ch == '.') {
       size_t off = p->pos;
       /* Distinguish bare-dot (`. =`) from `.text :` head. Bare dot has
        * no id-cont following. */
       if (p->pos + 1 < p->len &&
           is_id_cont((unsigned char)p->src[p->pos + 1])) {
         /* falls through to identifier path */
       } else {
         ++p->pos;
         skip_ws(p);
         if (p->err) return 1;
         if (!match_ch(p, '=')) {
           lsp_errf(p, off, "expected `. = expr`");
           return 1;
         }
         {
           KitLinkExpr* e = parse_expr(p);
           KitLinkAssignment a;
           if (!e) return 1;
           (void)match_ch(p, ';');
           memset(&a, 0, sizeof(a));
           a.kind = KIT_LAS_DOT;
           a.sym = KIT_SLICE_NULL;
           a.expr = e;
           if (VEC_PUSH(p, *top_asns, a)) return 1;
         }
         continue;
       }
     }
     if (is_id_start(ch)) {
       /* either `name :` (output section) or `sym = expr;` */
       const char* s;
       size_t n;
       size_t name_off;
       KitLinkExpr* vma = NULL;
       bool noload = false;
       if (match_kw(p, "ASSERT")) {
         if (parse_assertion(p, asserts)) return 1;
         continue;
       }
       if (match_kw(p, "PROVIDE_HIDDEN")) {
         if (parse_assignment_call(p, KIT_LAS_PROVIDE_HIDDEN, top_asns))
           return 1;
         continue;
       }
       if (match_kw(p, "PROVIDE")) {
         if (parse_assignment_call(p, KIT_LAS_PROVIDE, top_asns)) return 1;
         continue;
       }
       if (match_kw(p, "HIDDEN")) {
         if (parse_assignment_call(p, KIT_LAS_HIDDEN, top_asns)) return 1;
         continue;
       }
       name_off = p->pos;
       if (lex_ident(p, &s, &n)) return 1;
       skip_ws(p);
       if (p->err) return 1;
       if (match_ch(p, '(')) {
         const char* ts;
         size_t tn;
         if (lex_ident(p, &ts, &tn)) return 1;
         if (tn == 6 && memcmp(ts, "NOLOAD", 6) == 0)
           noload = true;
         else {
           lsp_errf(p, name_off, "unsupported output-section type `%.*s`",
                    (int)tn, ts);
           return 1;
         }
         if (expect_ch(p, ')')) return 1;
         skip_ws(p);
         if (p->err) return 1;
       }
       if (p->pos < p->len && p->src[p->pos] != ':' &&
           p->src[p->pos] != '=') {
         vma = parse_expr(p);
         if (!vma) return 1;
         skip_ws(p);
         if (p->err) return 1;
         if (match_ch(p, '(')) {
           const char* ts;
           size_t tn;
           if (lex_ident(p, &ts, &tn)) return 1;
           if (tn == 6 && memcmp(ts, "NOLOAD", 6) == 0)
             noload = true;
           else {
             lsp_errf(p, name_off, "unsupported output-section type `%.*s`",
                      (int)tn, ts);
             return 1;
           }
           if (expect_ch(p, ')')) return 1;
           skip_ws(p);
           if (p->err) return 1;
         }
       }
       if (p->pos < p->len && p->src[p->pos] == ':') {
         char* nm = lsp_strdup(p, s, n);
         if (!nm) return 1;
         if (parse_output_section(p, nm, n, vma, noload, sections, asserts))
           return 1;
         continue;
       }
       if (match_ch(p, '=')) {
         KitLinkExpr* e = parse_expr(p);
         KitLinkAssignment a;
         if (!e) return 1;
         (void)match_ch(p, ';');
         memset(&a, 0, sizeof(a));
         a.kind = KIT_LAS_SYM;
         a.sym = lsp_slice(p, s, n);
         a.expr = e;
         if (VEC_PUSH(p, *top_asns, a)) return 1;
         continue;
       }
       lsp_errf(p, name_off,
                "expected `:` (output section) or `=` (assignment) after "
                "`%.*s`",
                (int)n, s);
       return 1;
     }
     lsp_errf(p, p->pos, "unexpected '%c' in SECTIONS body", (char)ch);
     return 1;
   }
 }
 
 static int eval_const_expr(LSP* p, const KitLinkExpr* e, u64* out) {
   u64 a, b;
   if (!e) return 1;
   switch ((KitLinkExprKind)e->kind) {
     case KIT_LE_INT:
       *out = (u64)e->v.int_val;
       return 0;
     case KIT_LE_NEG:
       if (eval_const_expr(p, e->v.align.val, &a)) return 1;
       *out = (u64)(-(i64)a);
       return 0;
     case KIT_LE_ADD:
     case KIT_LE_SUB:
     case KIT_LE_MUL:
     case KIT_LE_DIV:
     case KIT_LE_AND:
     case KIT_LE_OR:
     case KIT_LE_XOR:
     case KIT_LE_SHL:
     case KIT_LE_SHR:
     case KIT_LE_MAX:
     case KIT_LE_MIN:
       if (eval_const_expr(p, e->v.bin.lhs, &a) ||
           eval_const_expr(p, e->v.bin.rhs, &b))
         return 1;
       switch ((KitLinkExprKind)e->kind) {
         case KIT_LE_ADD:
           *out = a + b;
           return 0;
         case KIT_LE_SUB:
           *out = a - b;
           return 0;
         case KIT_LE_MUL:
           *out = a * b;
           return 0;
         case KIT_LE_DIV:
           if (b == 0) {
             lsp_errf(p, p->pos, "division by zero in constant expression");
             return 1;
           }
           *out = a / b;
           return 0;
         case KIT_LE_AND:
           *out = a & b;
           return 0;
         case KIT_LE_OR:
           *out = a | b;
           return 0;
         case KIT_LE_XOR:
           *out = a ^ b;
           return 0;
         case KIT_LE_SHL:
           *out = a << b;
           return 0;
         case KIT_LE_SHR:
           *out = a >> b;
           return 0;
         case KIT_LE_MAX:
           *out = a > b ? a : b;
           return 0;
         case KIT_LE_MIN:
           *out = a < b ? a : b;
           return 0;
         default:
           break;
       }
       break;
     case KIT_LE_ALIGN:
     case KIT_LE_BLOCK:
       if (eval_const_expr(p, e->v.align.val, &a) ||
           eval_const_expr(p, e->v.align.align, &b))
         return 1;
       *out = b ? ALIGN_UP(a, b) : a;
       return 0;
     case KIT_LE_ABSOLUTE:
       return eval_const_expr(p, e->v.align.val, out);
     default:
       break;
   }
   lsp_errf(p, p->pos, "non-constant expression in MEMORY region");
   return 1;
 }
 
 static int parse_memory_block(LSP* p, VecRegion* regions) {
   if (expect_ch(p, '{')) return 1;
   for (;;) {
     const char* ns;
     size_t nn;
     KitLinkRegion r;
     int have_origin = 0, have_length = 0;
     skip_ws(p);
     if (p->err) return 1;
     if (peek_ch(p) == '}') {
       ++p->pos;
       return 0;
     }
     if (lex_ident(p, &ns, &nn)) return 1;
     memset(&r, 0, sizeof(r));
     r.name = lsp_slice(p, ns, nn);
     if (!r.name.s) return 1;
     skip_ws(p);
     if (match_ch(p, '(')) {
       while (!p->err && p->pos < p->len && p->src[p->pos] != ')') {
         char c = p->src[p->pos++];
         if (c == 'r' || c == 'R') r.flags |= KIT_LRF_R;
         if (c == 'w' || c == 'W') r.flags |= KIT_LRF_W;
         if (c == 'x' || c == 'X') r.flags |= KIT_LRF_X;
       }
       if (expect_ch(p, ')')) return 1;
     }
     if (expect_ch(p, ':')) return 1;
     while (!p->err) {
       const char* ks;
       size_t kn;
       KitLinkExpr* e;
       u64 v;
       skip_ws(p);
       if (p->err) return 1;
       if (peek_ch(p) == '}') break;
       if (lex_ident(p, &ks, &kn)) return 1;
       if (expect_ch(p, '=')) return 1;
       e = parse_expr(p);
       if (!e) return 1;
       if (eval_const_expr(p, e, &v)) return 1;
       if ((kn == 6 && memcmp(ks, "ORIGIN", 6) == 0) ||
           (kn == 3 && memcmp(ks, "org", 3) == 0) ||
           (kn == 1 && (ks[0] == 'o' || ks[0] == 'O'))) {
         r.origin = v;
         have_origin = 1;
       } else if ((kn == 6 && memcmp(ks, "LENGTH", 6) == 0) ||
                  (kn == 3 && memcmp(ks, "len", 3) == 0) ||
                  (kn == 1 && (ks[0] == 'l' || ks[0] == 'L'))) {
         r.length = v;
         have_length = 1;
       } else {
         lsp_errf(p, p->pos, "unknown MEMORY field `%.*s`", (int)kn, ks);
         return 1;
       }
       skip_ws(p);
       (void)match_ch(p, ',');
       if (have_origin && have_length) break;
     }
     if (!have_origin || !have_length) {
       lsp_errf(p, p->pos, "MEMORY region `%.*s` needs ORIGIN and LENGTH",
                (int)nn, ns);
       return 1;
     }
     if (VEC_PUSH(p, *regions, r)) return 1;
   }
 }
 
 static uint32_t phdr_type_from_name(const char* s, size_t n) {
   if (n == 7 && memcmp(s, "PT_NULL", 7) == 0) return 0u;
   if (n == 7 && memcmp(s, "PT_LOAD", 7) == 0) return 1u;
   if (n == 10 && memcmp(s, "PT_DYNAMIC", 10) == 0) return 2u;
   if (n == 9 && memcmp(s, "PT_INTERP", 9) == 0) return 3u;
   if (n == 7 && memcmp(s, "PT_NOTE", 7) == 0) return 4u;
   if (n == 8 && memcmp(s, "PT_SHLIB", 8) == 0) return 5u;
   if (n == 7 && memcmp(s, "PT_PHDR", 7) == 0) return 6u;
   if (n == 6 && memcmp(s, "PT_TLS", 6) == 0) return 7u;
   if (n == 12 && memcmp(s, "PT_GNU_STACK", 12) == 0) return 0x6474e551u;
   if (n == 12 && memcmp(s, "PT_GNU_RELRO", 12) == 0) return 0x6474e552u;
   return 1u;
 }
 
 static int parse_phdrs_block(LSP* p, VecPhdr* phdrs) {
   if (expect_ch(p, '{')) return 1;
   for (;;) {
     const char *ns, *ts;
     size_t nn, tn;
     KitLinkPhdr ph;
     skip_ws(p);
     if (p->err) return 1;
     if (peek_ch(p) == '}') {
       ++p->pos;
       return 0;
     }
     if (lex_ident(p, &ns, &nn)) return 1;
     if (lex_ident(p, &ts, &tn)) return 1;
     memset(&ph, 0, sizeof(ph));
     ph.name = lsp_slice(p, ns, nn);
     ph.type = phdr_type_from_name(ts, tn);
     if (!ph.name.s) return 1;
     for (;;) {
       skip_ws(p);
       if (p->err) return 1;
       if (match_ch(p, ';')) break;
       if (match_kw(p, "FILEHDR")) {
         ph.filehdr = true;
         continue;
       }
       if (match_kw(p, "PHDRS")) {
         ph.phdrs = true;
         continue;
       }
       if (match_kw(p, "FLAGS")) {
         if (expect_ch(p, '(')) return 1;
         ph.flags = parse_expr(p);
         if (!ph.flags) return 1;
         if (expect_ch(p, ')')) return 1;
         continue;
       }
       lsp_errf(p, p->pos, "expected PHDRS attribute or `;`");
       return 1;
     }
     if (VEC_PUSH(p, *phdrs, ph)) return 1;
   }
 }
 
 static int parse_extern_directive(LSP* p, VecSlice* externs) {
   if (expect_ch(p, '(')) return 1;
   for (;;) {
     int ch;
     const char* s;
     size_t n;
     KitSlice sl;
     skip_ws(p);
     if (p->err) return 1;
     ch = peek_ch(p);
     if (ch == ')') {
       ++p->pos;
       (void)match_ch(p, ';');
       return 0;
     }
     if (lex_ident(p, &s, &n)) return 1;
     sl = lsp_slice(p, s, n);
     if (!sl.s) return 1;
     if (VEC_PUSH(p, *externs, sl)) return 1;
   }
 }
 
 static int parse_output_name_directive(LSP* p, KitSlice* out) {
   if (expect_ch(p, '(')) return 1;
   if (lex_ident_or_string(p, out)) return 1;
   for (;;) {
     KitSlice ignored;
     skip_ws(p);
     if (p->err) return 1;
     if (match_ch(p, ')')) break;
     if (match_ch(p, ',')) {
       if (lex_ident_or_string(p, &ignored)) return 1;
       continue;
     }
     lsp_errf(p, p->pos, "expected `,` or `)`");
     return 1;
   }
   (void)match_ch(p, ';');
   return 0;
 }
 
 /* ---- top level ---- */
 
 static int parse_top(LSP* p, KitLinkScript* out) {
   VecAsn top_asns = {0};
   VecSec sections = {0};
   VecRegion regions = {0};
   VecPhdr phdrs = {0};
   VecAssert asserts = {0};
   VecSlice externs = {0};
   KitSlice entry_name = KIT_SLICE_NULL;
   KitSlice output_arch = KIT_SLICE_NULL;
   KitSlice output_format = KIT_SLICE_NULL;
   int saw_sections = 0;
   int rc = 1;
 
   for (;;) {
     int ch;
     skip_ws(p);
     if (p->err) goto done;
     if (p->pos >= p->len) break;
     ch = (unsigned char)p->src[p->pos];
 
     if (is_id_start(ch)) {
       if (match_kw(p, "ENTRY")) {
         const char* s;
         size_t n;
         if (expect_ch(p, '(')) goto done;
         if (lex_ident(p, &s, &n)) goto done;
         if (expect_ch(p, ')')) goto done;
         (void)match_ch(p, ';');
         entry_name = lsp_slice(p, s, n);
         if (!entry_name.s) goto done;
         continue;
       }
       if (match_kw(p, "SECTIONS")) {
         if (saw_sections) {
           lsp_errf(p, p->pos, "duplicate SECTIONS block");
           goto done;
         }
         if (parse_sections_block(p, &top_asns, &sections, &asserts))
           goto done;
         saw_sections = 1;
         continue;
       }
       if (match_kw(p, "MEMORY")) {
         if (parse_memory_block(p, &regions)) goto done;
         continue;
       }
       if (match_kw(p, "PHDRS")) {
         if (parse_phdrs_block(p, &phdrs)) goto done;
         continue;
       }
       if (match_kw(p, "EXTERN")) {
         if (parse_extern_directive(p, &externs)) goto done;
         continue;
       }
       if (match_kw(p, "ASSERT")) {
         if (parse_assertion(p, &asserts)) goto done;
         continue;
       }
       if (match_kw(p, "PROVIDE_HIDDEN")) {
         if (parse_assignment_call(p, KIT_LAS_PROVIDE_HIDDEN, &top_asns))
           goto done;
         continue;
       }
       if (match_kw(p, "PROVIDE")) {
         if (parse_assignment_call(p, KIT_LAS_PROVIDE, &top_asns)) goto done;
         continue;
       }
       if (match_kw(p, "HIDDEN")) {
         if (parse_assignment_call(p, KIT_LAS_HIDDEN, &top_asns)) goto done;
         continue;
       }
       if (match_kw(p, "OUTPUT_FORMAT")) {
         if (parse_output_name_directive(p, &output_format)) goto done;
         continue;
       }
       if (match_kw(p, "OUTPUT_ARCH")) {
         if (parse_output_name_directive(p, &output_arch)) goto done;
         continue;
       }
       if (match_kw(p, "OVERLAY") || match_kw(p, "INSERT") ||
           match_kw(p, "INPUT") || match_kw(p, "GROUP") ||
           match_kw(p, "VERSION") || match_kw(p, "STARTUP") ||
           match_kw(p, "SEARCH_DIR") || match_kw(p, "TARGET")) {
         lsp_errf(p, p->pos,
                  "directive not supported in this linker-script subset");
         goto done;
       }
       lsp_errf(p, p->pos, "unknown top-level directive");
       goto done;
     }
     lsp_errf(p, p->pos, "unexpected '%c' at top level", (char)ch);
     goto done;
   }
 
   /* Materialize. */
   out->entry = entry_name;
   out->output_arch = output_arch;
   out->output_format = output_format;
   out->regions = NULL;
   out->nregions = 0;
   out->phdrs = NULL;
   out->nphdrs = 0;
   out->top_asns = NULL;
   out->ntop_asns = 0;
   out->sections = NULL;
   out->nsections = 0;
   out->asserts = NULL;
   out->nasserts = 0;
   out->externs = NULL;
   out->nexterns = 0;
 
   if (regions.n) {
     KitLinkRegion* r = arena_array(p->arena, KitLinkRegion, regions.n);
     if (!r) goto done;
     memcpy(r, regions.p, sizeof(*r) * regions.n);
     out->regions = r;
     out->nregions = regions.n;
   }
   if (phdrs.n) {
     KitLinkPhdr* ph = arena_array(p->arena, KitLinkPhdr, phdrs.n);
     if (!ph) goto done;
     memcpy(ph, phdrs.p, sizeof(*ph) * phdrs.n);
     out->phdrs = ph;
     out->nphdrs = phdrs.n;
   }
   if (top_asns.n) {
     KitLinkAssignment* a = arena_array(p->arena, KitLinkAssignment, top_asns.n);
     if (!a) goto done;
     memcpy(a, top_asns.p, sizeof(*a) * top_asns.n);
     out->top_asns = a;
     out->ntop_asns = top_asns.n;
   }
   if (sections.n) {
     KitLinkOutputSection* s =
         arena_array(p->arena, KitLinkOutputSection, sections.n);
     if (!s) goto done;
     memcpy(s, sections.p, sizeof(*s) * sections.n);
     out->sections = s;
     out->nsections = sections.n;
   }
   if (asserts.n) {
     KitLinkAssertion* a = arena_array(p->arena, KitLinkAssertion, asserts.n);
     if (!a) goto done;
     memcpy(a, asserts.p, sizeof(*a) * asserts.n);
     out->asserts = a;
     out->nasserts = asserts.n;
   }
   if (externs.n) {
     KitSlice* e = arena_array(p->arena, KitSlice, externs.n);
     if (!e) goto done;
     memcpy(e, externs.p, sizeof(*e) * externs.n);
     out->externs = e;
     out->nexterns = externs.n;
   }
   rc = 0;
 
 done:
   vec_free_(p, top_asns.p, top_asns.cap, sizeof(*top_asns.p));
   vec_free_(p, sections.p, sections.cap, sizeof(*sections.p));
   vec_free_(p, regions.p, regions.cap, sizeof(*regions.p));
   vec_free_(p, phdrs.p, phdrs.cap, sizeof(*phdrs.p));
   vec_free_(p, asserts.p, asserts.cap, sizeof(*asserts.p));
   vec_free_(p, externs.p, externs.cap, sizeof(*externs.p));
   return rc;
 }
 
 /* ---- public API ---- */
 
 KitStatus kit_link_script_parse(const KitContext* ctx, KitSlice text,
                                 KitLinkScript** out) {
   ScriptOwner* owner;
   LSP p;
   int rc;
   Heap* h;
 
   if (!out) return KIT_INVALID;
   *out = NULL;
   if (!ctx || !ctx->heap || !text.s) return KIT_INVALID;
 
   h = ctx->heap;
   owner = (ScriptOwner*)h->alloc(h, sizeof(*owner), _Alignof(ScriptOwner));
   if (!owner) return KIT_NOMEM;
   memset(owner, 0, sizeof(*owner));
   /* 16 KiB blocks: matches the linker's tu arena defaults and is plenty
    * for the script subset we support. */
   arena_init(&owner->arena, h, 16u * 1024u);
 
   memset(&p, 0, sizeof(p));
   p.arena = &owner->arena;
   p.heap = h;
   p.diag = ctx->diag;
   p.src = text.s;
   p.len = text.len;
 
   rc = parse_top(&p, &owner->script);
   if (rc != 0 || p.err) {
     arena_fini(&owner->arena);
     h->free(h, owner, sizeof(*owner));
     return KIT_ERR;
   }
   *out = &owner->script;
   return KIT_OK;
 }
 
 void kit_link_script_free(const KitContext* ctx, KitLinkScript* s) {
   ScriptOwner* owner;
   Heap* h;
   if (!ctx || !ctx->heap || !s) return;
   owner = (ScriptOwner*)((char*)s - offsetof(ScriptOwner, script));
   h = ctx->heap;
   arena_fini(&owner->arena);
   h->free(h, owner, sizeof(*owner));
 }