kit

link_script.c (26703B)

---

 /* 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"
 
 /* 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;
 } LSP;
 
 /* ---- 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;
 
 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;
 }
 
 /* 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_int(LSP* p) {
   KitLinkExpr* e;
   size_t start = p->pos;
   i64 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;
     }
   }
   e = lsp_new_expr(p);
   if (!e) return NULL;
   e->kind = KIT_LE_INT;
   e->v.int_val = v;
   return e;
 }
 
 static KitLinkExpr* parse_atom(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 == '(') {
     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 ALIGN(...) or a symbol reference */
     if (match_kw(p, "ALIGN")) {
       /* 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;
       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 = KIT_LE_ALIGN;
       e->v.align.val = val;
       e->v.align.align = aln;
       return e;
     }
     if (match_kw(p, "MAX") || match_kw(p, "MIN")) {
       lsp_errf(p, p->pos, "MAX/MIN not supported in this subset");
       return NULL;
     }
     {
       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;
 }
 
 /* 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;
   a.kind = KIT_LAS_DOT;
   a.sym = KIT_SLICE_NULL;
   a.expr = aln;
   return VEC_PUSH(p, *asns, a);
 }
 
 /* ---- output section body ---- */
 
 static int parse_input_matchers(LSP* p, VecMatch* out) {
   /* opening `*` already consumed by caller. expect `(p1 p2 ...)` */
   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;
       return 0;
     }
     if (ch < 0) {
       lsp_errf(p, p->pos, "unterminated `*(...)`");
       return 1;
     }
     /* a pattern is a section-name-like run: id-start chars plus '*'. */
     {
       size_t start;
       const char* s;
       size_t n;
       KitLinkInputMatch m;
       start = p->pos;
       while (p->pos < p->len) {
         char c = p->src[p->pos];
         if (is_id_cont((unsigned char)c) || c == '*')
           ++p->pos;
         else
           break;
       }
       n = p->pos - start;
       if (n == 0) {
         lsp_errf(p, p->pos, "expected section pattern");
         return 1;
       }
       s = p->src + start;
       m.file_pattern = KIT_SLICE_NULL;
       m.section_pattern = lsp_slice(p, s, n);
       m.keep = 0;
       if (VEC_PUSH(p, *out, m)) return 1;
     }
   }
 }
 
 static int parse_section_body(LSP* p, VecMatch* inputs, VecAsn* asns) {
   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;
       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)) 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 */
         }
         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)) {
       /* sym = expr; */
       const char* s;
       size_t n;
       KitLinkExpr* e;
       KitLinkAssignment a;
       if (match_kw(p, "PROVIDE") || match_kw(p, "KEEP")) {
         lsp_errf(p, p->pos, "PROVIDE/KEEP not supported in this subset");
         return 1;
       }
       if (lex_ident(p, &s, &n)) return 1;
       skip_ws(p);
       if (p->err) return 1;
       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, ';');
       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,
                                 VecSec* sections) {
   /* The `:` is the next non-ws char on entry. Header may carry
    * `: ALIGN(N)` then `{ body }`. */
   KitLinkOutputSection sec;
   VecMatch inputs = {0};
   VecAsn asns = {0};
   KitLinkExpr* align_n = NULL;
 
   if (expect_ch(p, ':')) return 1;
   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;
   }
   /* Reject AT>, > REGION, >REGION before the body. */
   skip_ws(p);
   if (p->err) return 1;
   if (p->pos < p->len &&
       (p->src[p->pos] == '>' || (p->src[p->pos] == 'A' && match_kw(p, "AT")))) {
     lsp_errf(p, p->pos,
              "memory-region placement (>REGION / AT>) not supported");
     return 1;
   }
 
   /* Section header alignment is encoded as the first asn — applicator
    * pulls it before processing inputs. */
   if (align_n) {
     if (push_dot_align(p, &asns, align_n)) goto fail;
   }
 
   if (parse_section_body(p, &inputs, &asns)) goto fail;
 
   /* Optional trailing `> REGION` / `AT> REGION` / `: NOLOAD` etc. — all
    * unsupported. We allow an optional trailing `;` and nothing else. */
   (void)match_ch(p, ';');
 
   /* Materialize. */
   {
     KitLinkInputMatch* arr_in = NULL;
     KitLinkAssignment* arr_as = 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);
     }
     memset(&sec, 0, sizeof(sec));
     sec.name = lsp_slice(p, name_buf, name_len);
     sec.inputs = arr_in;
     sec.ninputs = inputs.n;
     sec.asns = arr_as;
     sec.nasns = asns.n;
   }
 
   vec_free_(p, inputs.p, inputs.cap, sizeof(*inputs.p));
   vec_free_(p, asns.p, asns.cap, sizeof(*asns.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));
   return 1;
 }
 
 /* ---- SECTIONS{...} ---- */
 
 static int parse_sections_block(LSP* p, VecAsn* top_asns, VecSec* sections) {
   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;
       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, sections)) 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, ';');
           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;
       if (match_kw(p, "PROVIDE")) {
         lsp_errf(p, p->pos, "PROVIDE not supported in this subset");
         return 1;
       }
       name_off = p->pos;
       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] == ':') {
         char* nm = lsp_strdup(p, s, n);
         if (!nm) return 1;
         if (parse_output_section(p, nm, n, sections)) return 1;
         continue;
       }
       if (match_ch(p, '=')) {
         KitLinkExpr* e = parse_expr(p);
         KitLinkAssignment a;
         if (!e) return 1;
         (void)match_ch(p, ';');
         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;
   }
 }
 
 /* ---- top level ---- */
 
 static int parse_top(LSP* p, KitLinkScript* out) {
   VecAsn top_asns = {0};
   VecSec sections = {0};
   KitSlice entry_name = 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)) goto done;
         saw_sections = 1;
         continue;
       }
       if (match_kw(p, "MEMORY") || match_kw(p, "OVERLAY") ||
           match_kw(p, "INSERT") || match_kw(p, "OUTPUT_FORMAT") ||
           match_kw(p, "OUTPUT_ARCH") || match_kw(p, "INPUT") ||
           match_kw(p, "GROUP") || match_kw(p, "VERSION") ||
           match_kw(p, "PROVIDE") || 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->regions = NULL;
   out->nregions = 0;
   out->top_asns = NULL;
   out->ntop_asns = 0;
   out->sections = NULL;
   out->nsections = 0;
 
   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;
   }
   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));
   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));
 }