kit

parse.c (71321B)

---

 /* parse.c — residual C11 parser core.
  *
  * Contains:
  *   - kw_names[] table (used by parse_c to intern keywords)
  *   - Diagnostics/token helpers (perr, advance, peek1, fetch_tok, ...)
  *   - Scope/tag operations
  *   - Type helpers (ty_int, ty_size_t)
  *   - Local-variable slot allocation (make_local, make_local_aligned)
  *   - Static-local symbol naming (mint_static_local_sym)
  *   - Declaration driver (parse_init_declarator, parse_local_decl)
  *   - TU-level driver (parse_param_list, declare_function,
  *     parse_function_body, parse_external_decl, parse_translation_unit,
  *     parse_c)
  *
  * All expression, type, initializer, and statement code lives in
  * parse_expr.c, parse_type.c, parse_init.c, and parse_stmt.c. */
 
 #include <stdarg.h>
 #include <string.h>
 
 #include "parse/parse_priv.h"
 
 /* ============================================================
  * Keywords
  * ============================================================ */
 
 static const char* const kw_names[KW_COUNT] = {
     NULL,
     "auto",
     "break",
     "case",
     "char",
     "const",
     "continue",
     "default",
     "do",
     "double",
     "else",
     "enum",
     "extern",
     "float",
     "_Float16",
     "for",
     "goto",
     "if",
     "inline",
     "int",
     "long",
     "register",
     "restrict",
     "return",
     "short",
     "signed",
     "sizeof",
     "static",
     "struct",
     "switch",
     "typedef",
     "union",
     "unsigned",
     "void",
     "volatile",
     "while",
     "_Bool",
     "_Complex",
     "_Imaginary",
     "_Alignas",
     "_Alignof",
     "_Atomic",
     "_Generic",
     "_Noreturn",
     "_Static_assert",
     "_Thread_local",
     "asm",
     "__asm__",
 };
 
 /* ============================================================
  * Diagnostics
  * ============================================================ */
 
 static SrcLoc tok_loc(Parser* p, const Tok* t) {
   return pp_materialize_loc(p->pp, t->loc);
 }
 
 _Noreturn void perr(Parser* p, const char* fmt, ...) {
   va_list ap;
   SrcLoc loc = tok_loc(p, &p->cur);
   va_start(ap, fmt);
   compiler_panicv(p->c, loc, fmt, ap);
 }
 
 void reject_general_regs_only_fp(Parser* p, const char* what) {
   if (!p->general_regs_only) return;
   perr(p, "-mgeneral-regs-only rejects %.*s",
        KIT_SLICE_ARG(kit_slice_cstr(what)));
 }
 
 /* ============================================================
  * Token helpers
  * ============================================================ */
 
 /* Width of an encoding prefix on a string-literal spelling: 0 for ordinary,
  * 1 for L/u/U, 2 for u8. */
 static size_t str_prefix_len(u16 flags) {
   if (flags & TF_STR_U8) return 2;
   if (flags & (TF_STR_WIDE | TF_STR_U16 | TF_STR_U32)) return 1;
   return 0;
 }
 
 #define STR_ENC_MASK (TF_STR_WIDE | TF_STR_U8 | TF_STR_U16 | TF_STR_U32)
 
 /* Fuse two adjacent TOK_STR tokens into one per C11 §6.4.5 ¶5. */
 static Tok fuse_string_lits(Parser* p, Tok a, Tok b) {
   u16 ae = (u16)(a.flags & STR_ENC_MASK);
   u16 be = (u16)(b.flags & STR_ENC_MASK);
   u16 fused_enc;
   KitSlice a_sl = pp_text_slice(p->pp, &a);
   KitSlice b_sl = pp_text_slice(p->pp, &b);
   size_t alen = a_sl.len, blen = b_sl.len;
   const char* as = a_sl.s;
   const char* bs = b_sl.s;
   size_t apfx, bpfx;
   size_t a_content_len, b_content_len;
   size_t out_pfx_len;
   size_t out_len;
   Heap* h = kit_compiler_context(p->c)->heap;
   char* buf;
   size_t k = 0;
   Tok out;
   if (!as || !bs) perr(p, "bad string literal in concatenation");
   if (ae != 0 && be != 0 && ae != be) {
     perr(p,
          "concatenating string literals with incompatible "
          "encoding prefixes");
   }
   fused_enc = ae ? ae : be;
   apfx = str_prefix_len(a.flags);
   bpfx = str_prefix_len(b.flags);
   if (alen < apfx + 2 || as[apfx] != '"' || as[alen - 1] != '"' ||
       blen < bpfx + 2 || bs[bpfx] != '"' || bs[blen - 1] != '"') {
     perr(p, "malformed string literal in concatenation");
   }
   a_content_len = alen - apfx - 2;
   b_content_len = blen - bpfx - 2;
   out_pfx_len = ae ? apfx : bpfx;
   out_len = out_pfx_len + 1 + a_content_len + b_content_len + 1;
   buf = (char*)h->alloc(h, out_len, 1);
   if (!buf) perr(p, "out of memory fusing string literals");
   if (out_pfx_len) {
     const char* src = ae ? as : bs;
     memcpy(buf + k, src, out_pfx_len);
     k += out_pfx_len;
   }
   buf[k++] = '"';
   if (a_content_len) {
     memcpy(buf + k, as + apfx + 1, a_content_len);
     k += a_content_len;
   }
   if (b_content_len) {
     memcpy(buf + k, bs + bpfx + 1, b_content_len);
     k += b_content_len;
   }
   buf[k++] = '"';
   out = a;
   out.text =
       text_sym_ref(kit_sym_intern(p->pool->c, (KitSlice){.s = buf, .len = k}));
   out.flags = (u16)((a.flags & ~STR_ENC_MASK) | fused_enc);
   h->free(h, buf, 0);
   return out;
 }
 
 /* Pull one logical token from pp, collapsing adjacent TOK_STR runs. */
 static Tok fetch_tok(Parser* p) {
   Tok t;
   if (p->has_pending) {
     t = p->pending;
     p->has_pending = 0;
   } else {
     pp_next_parse(p->pp, &t);
   }
   if (t.kind != TOK_STR) return t;
   for (;;) {
     Tok n;
     pp_next_parse(p->pp, &n);
     if (n.kind != TOK_STR) {
       p->pending = n;
       p->has_pending = 1;
       return t;
     }
     t = fuse_string_lits(p, t, n);
   }
 }
 
 void advance(Parser* p) {
   if (p->replay_active) {
     if (p->replay_pos < p->replay_len) {
       p->cur = p->replay[p->replay_pos++];
       return;
     }
     p->replay_active = 0;
   }
   if (p->function_replay_active) {
     if (p->function_replay_pos < p->function_replay_len) {
       p->cur = p->function_replay[p->function_replay_pos++];
       return;
     }
     p->function_replay_active = 0;
     if (p->function_replay_hold) {
       memset(&p->cur, 0, sizeof p->cur);
       p->cur.kind = TOK_EOF;
       return;
     }
   }
   if (p->has_next) {
     p->cur = p->next;
     p->has_next = 0;
   } else {
     p->cur = fetch_tok(p);
   }
 }
 
 Tok peek1(Parser* p) {
   if (p->replay_active && p->replay_pos < p->replay_len) {
     return p->replay[p->replay_pos];
   }
   if (p->function_replay_active &&
       p->function_replay_pos < p->function_replay_len) {
     return p->function_replay[p->function_replay_pos];
   }
   if (!p->has_next) {
     p->next = fetch_tok(p);
     p->has_next = 1;
   }
   return p->next;
 }
 
 void expect_punct(Parser* p, u32 punct, const char* what) {
   if (!accept_punct(p, punct)) {
     perr(p, "expected %.*s", KIT_SLICE_ARG(kit_slice_cstr(what)));
   }
 }
 
 int accept_punct(Parser* p, u32 punct) {
   if (is_punct(&p->cur, punct)) {
     advance(p);
     return 1;
   }
   return 0;
 }
 
 /* Record tokens from the current `{` through the matching `}` into the
  * parser's replay buffer. */
 void record_braced_block(Parser* p) {
   int depth = 0;
   if (!is_punct(&p->cur, '{')) perr(p, "internal: record on non-'{'");
   p->replay_len = 0;
   for (;;) {
     if (p->replay_len == p->replay_cap) {
       u32 new_cap = p->replay_cap ? p->replay_cap * 2 : 32;
       Tok* nv = arena_array(p->pool->arena, Tok, new_cap);
       if (!nv) perr(p, "out of memory in record_braced_block");
       if (p->replay && p->replay_len) {
         memcpy(nv, p->replay, p->replay_len * sizeof(Tok));
       }
       p->replay = nv;
       p->replay_cap = new_cap;
     }
     p->replay[p->replay_len++] = p->cur;
     if (is_punct(&p->cur, '{')) {
       ++depth;
     } else if (is_punct(&p->cur, '}')) {
       --depth;
       if (depth == 0) break;
     } else if (p->cur.kind == TOK_EOF) {
       perr(p, "unexpected end of file in initializer");
     }
     advance(p);
   }
 }
 
 /* After record_braced_block, rewind to replay from the start. */
 void replay_rewind(Parser* p) {
   if (p->replay_len == 0) perr(p, "internal: replay_rewind with empty buffer");
   p->cur = p->replay[0];
   p->replay_pos = 1;
   p->replay_active = 1;
   p->has_next = 0;
 }
 
 /* Buffer a whole function body without feeding its already-preprocessed tokens
  * back through pp.  The dedicated replay stream lets initializer replay nest
  * normally during each semantic pass. */
 static void record_function_body(Parser* p) {
   Tok* body = NULL;
   u32 len = 0;
   u32 cap = 0;
   int depth = 0;
   if (!is_punct(&p->cur, '{')) perr(p, "internal: function body is not '{'");
   for (;;) {
     if (len == cap) {
       u32 next_cap = cap ? cap * 2u : 128u;
       Tok* next = arena_array(p->pool->arena, Tok, next_cap);
       if (!next) perr(p, "out of memory recording function body");
       if (body && len) memcpy(next, body, sizeof(Tok) * len);
       body = next;
       cap = next_cap;
     }
     body[len++] = p->cur;
     if (is_punct(&p->cur, '{')) {
       ++depth;
     } else if (is_punct(&p->cur, '}')) {
       --depth;
       if (depth == 0) break;
     } else if (p->cur.kind == TOK_EOF) {
       perr(p, "unexpected end of file in function body");
     }
     advance(p);
   }
   p->function_replay = body;
   p->function_replay_len = len;
   p->function_replay_pos = 1;
   p->function_replay_active = 1;
   p->function_replay_hold = 1;
   p->cur = body[0];
   p->has_next = 0;
 }
 
 static void rewind_function_body(Parser* p, int hold_at_end) {
   if (!p->function_replay || !p->function_replay_len)
     perr(p, "internal: empty function body replay");
   p->cur = p->function_replay[0];
   p->function_replay_pos = 1;
   p->function_replay_active = 1;
   p->function_replay_hold = hold_at_end ? 1u : 0u;
   p->has_next = 0;
 }
 
 /* Count top-level items in a recorded brace list. */
 u32 count_recorded_top_level_items(const Tok* vec, u32 len) {
   u32 count;
   u32 i;
   int depth = 0;
   if (len < 2) return 0;
   if (len == 2) return 0; /* `{}` */
   count = 1;
   for (i = 1; i < len - 1; ++i) {
     const Tok* t = &vec[i];
     if (is_punct(t, '{') || is_punct(t, '(') || is_punct(t, '['))
       ++depth;
     else if (is_punct(t, '}') || is_punct(t, ')') || is_punct(t, ']'))
       --depth;
     else if (depth == 0 && is_punct(t, ','))
       ++count;
   }
   if (is_punct(&vec[len - 2], ',')) --count;
   return count;
 }
 
 /* ============================================================
  * Scopes
  * ============================================================ */
 
 /* A scope only builds its hashmap index once it holds more than this many
  * entries; below it the linear LIFO scan is cheaper than a hashed lookup and
  * needs no allocation. The bound is a constant, so even pre-index scopes are
  * O(1) per lookup. */
 #define SCOPE_INDEX_THRESHOLD 12u
 
 Scope* scope_new(Parser* p, Scope* parent) {
   Scope* s = arena_new(p->pool->arena, Scope);
   if (!s) perr(p, "out of memory in scope_new");
   memset(s, 0, sizeof *s);
   s->parent = parent;
   s->saved_vla_mark = p->vla_mark;
   return s;
 }
 
 void scope_push(Parser* p) { p->scope = scope_new(p, p->scope); }
 
 void scope_pop(Parser* p) {
   if (p->scope) {
     /* Unwind the binding cache: walk the popped scope's LIFO list head-first
      * (newest define first) so multiple same-scope shadows of one Sym restore
      * to the pre-scope value. e->shadowed is the binding that was current when
      * e was defined, i.e. the value bind[name] must return once this scope is
      * gone. */
     SymEntry* e;
     for (e = p->scope->entries; e; e = e->next)
       if (e->name) BindingTab_set(&p->bind, e->name, e->shadowed);
     p->vla_mark = p->scope->saved_vla_mark;
     p->scope = p->scope->parent;
   }
 }
 
 /* Build a scope's name->entry index from its existing LIFO list. Insert
  * newest-first with try_insert (which keeps the first writer) so the head — the
  * current binding a linear scan would return — wins on shadowing. */
 static void scope_entries_index_build(Parser* p, Scope* s) {
   SymEntry* e;
   SymEntryMap_init_cap(&s->emap, &p->pool->arena_heap, 64u);
   for (e = s->entries; e; e = e->next)
     if (e->name) (void)SymEntryMap_try_insert(&s->emap, e->name, e, NULL);
 }
 
 static void scope_entries_index_put(Parser* p, Scope* s, SymEntry* e) {
   if (!e->name)
     return; /* anonymous: never name-looked-up, keep off the index */
   if (s->emap.cap) {
     (void)SymEntryMap_set(&s->emap, e->name, e); /* newest define wins */
   } else if (s->nentries > SCOPE_INDEX_THRESHOLD) {
     scope_entries_index_build(p, s);
   }
 }
 
 static SymEntry* scope_entries_find(Scope* s, Sym name) {
   SymEntry* e;
   if (name && s->emap.cap) {
     SymEntry** v = SymEntryMap_get(&s->emap, name);
     return v ? *v : NULL;
   }
   for (e = s->entries; e; e = e->next)
     if (e->name == name) return e;
   return NULL;
 }
 
 SymEntry* scope_define(Parser* p, Sym name, SymEntryKind kind,
                        const Type* type) {
   SymEntry* e = arena_new(p->pool->arena, SymEntry);
   Scope* s = p->scope;
   if (!e) perr(p, "out of memory in scope_define");
   memset(e, 0, sizeof *e);
   e->name = name;
   e->kind = (u8)kind;
   e->type = type;
   if (name) e->shadowed = BindingTab_get(&p->bind, name);
   e->next = s->entries;
   s->entries = e;
   s->nentries++;
   scope_entries_index_put(p, s, e);
   if (name) BindingTab_set(&p->bind, name, e);
   return e;
 }
 
 SymEntry* scope_lookup_current(Parser* p, Sym name) {
   return p->scope ? scope_entries_find(p->scope, name) : NULL;
 }
 
 /* Walk the scope chain starting at `from` (inclusive), returning the first
  * binding for `name`. scope_lookup is the common case starting at p->scope; a
  * caller that has already probed the current scope can start at its parent. */
 static SymEntry* scope_lookup_from(Scope* from, Sym name) {
   Scope* s;
   for (s = from; s; s = s->parent) {
     SymEntry* e = scope_entries_find(s, name);
     if (e) return e;
   }
   return NULL;
 }
 
 SymEntry* scope_lookup(Parser* p, Sym name) {
   /* Sym-keyed cache: the innermost-visible binding in one load. Equivalent to
    * scope_lookup_from(p->scope, name) by construction (the cache tracks the
    * newest define per scope and unwinds on pop); no caller passes name == 0. */
   return name ? BindingTab_get(&p->bind, name) : NULL;
 }
 
 static void sym_set_decl(SymEntry* e, DeclId id, DeclStorage storage,
                          DeclLinkage linkage, u32 flags, DeclState state) {
   e->decl_id = id;
   e->storage = (u8)storage;
   e->linkage = (u8)linkage;
   e->decl_flags = flags;
   e->decl_state = (u8)state;
   e->defined = (state == DSTATE_DEFINED || state == DSTATE_FUNC_DEFINED);
 }
 
 static SymEntry* external_func_lookup(Parser* p, Sym name) {
   SymEntry** v = name ? ExternalFuncMap_get(&p->external_funcs, name) : NULL;
   return v ? *v : NULL;
 }
 
 static void external_func_remember(Parser* p, Sym name, SymEntry* entry) {
   if (!entry || !name) return;
   (void)ExternalFuncMap_set(&p->external_funcs, name, entry); /* newest wins */
 }
 
 static int is_ordinary_decl_kind(SymEntryKind k) {
   return k == SEK_LOCAL || k == SEK_GLOBAL || k == SEK_FUNC ||
          k == SEK_TYPEDEF || k == SEK_ENUM_CST;
 }
 
 /* Apply the same-scope redefinition rule against `prior` (the binding present
  * before the new entry is installed): reject an ordinary-kind redeclaration
  * unless it is a typedef of a compatible type. */
 static void reject_redef_on(Parser* p, const SymEntry* prior, SymEntryKind kind,
                             const Type* type) {
   if (!prior || !is_ordinary_decl_kind((SymEntryKind)prior->kind)) return;
   if (prior->kind == SEK_TYPEDEF && kind == SEK_TYPEDEF &&
       type_compatible(prior->type, type)) {
     return;
   }
   perr(p, "redefinition of identifier");
 }
 
 /* Fused redefinition-check + define: one hash+probe on the scope index reads
  * the prior binding (for the redef rule) AND installs the new entry, instead of
  * probing the same key twice (a get for the redef check then a set in
  * scope_define). Behavior is identical to a redef check followed by
  *   return scope_define(p, name, kind, type);
  * — the redef rule fires on the captured prior before the new entry shadows it,
  * and the LIFO list + newest-wins index semantics are preserved. Use this only
  * at the rejecting declaration sites; plain scope_define stays for the
  * non-rejecting redeclaration-merge sites. */
 static SymEntry* scope_define_checked(Parser* p, Sym name, SymEntryKind kind,
                                       const Type* type) {
   SymEntry* e = arena_new(p->pool->arena, SymEntry);
   Scope* s = p->scope;
   SymEntry* prior;
   if (!e) perr(p, "out of memory in scope_define_checked");
   memset(e, 0, sizeof *e);
   e->name = name;
   e->kind = (u8)kind;
   e->type = type;
   /* The shadowed binding is the current innermost-visible one (== bind_get),
    * not `prior`: prior is the current-scope prior (used only for the redef
    * rule) and may be NULL while an outer binding exists, which must be the
    * value restored on pop. */
   if (name) e->shadowed = BindingTab_get(&p->bind, name);
   if (name && s->emap.cap) {
     /* Active index: prepend to the LIFO list, then fold the prior-read and the
      * index install into a single probe (newest define wins). */
     SymEntry* old = NULL;
     e->next = s->entries;
     s->entries = e;
     s->nentries++;
     (void)SymEntryMap_replace(&s->emap, name, e, &old);
     prior = old;
   } else {
     /* No index yet (or anonymous): capture the prior binding before the prepend
      * shadows it, then mirror scope_entries_index_put's threshold-trip build.
      * Anonymous entries (name == 0) stay off the index, as before. */
     prior = scope_entries_find(s, name);
     e->next = s->entries;
     s->entries = e;
     s->nentries++;
     if (name && s->nentries > SCOPE_INDEX_THRESHOLD)
       scope_entries_index_build(p, s);
   }
   reject_redef_on(p, prior, kind, type);
   if (name) BindingTab_set(&p->bind, name, e);
   return e;
 }
 
 static void tag_index_build(Parser* p, Scope* s) {
   TagEntry* e;
   TagEntryMap_init_cap(&s->tmap, &p->pool->arena_heap, 64u);
   for (e = s->tags; e; e = e->next)
     if (e->name) (void)TagEntryMap_try_insert(&s->tmap, e->name, e, NULL);
 }
 
 static void tag_index_put(Parser* p, Scope* s, TagEntry* e) {
   if (!e->name) return; /* anonymous struct/union: not name-looked-up */
   if (s->tmap.cap) {
     (void)TagEntryMap_set(&s->tmap, e->name, e);
   } else if (s->ntags > SCOPE_INDEX_THRESHOLD) {
     tag_index_build(p, s);
   }
 }
 
 static TagEntry* tag_find_in(Scope* s, Sym name) {
   TagEntry* e;
   if (name && s->tmap.cap) {
     TagEntry** v = TagEntryMap_get(&s->tmap, name);
     return v ? *v : NULL;
   }
   for (e = s->tags; e; e = e->next)
     if (e->name == name) return e;
   return NULL;
 }
 
 TagEntry* tag_define(Parser* p, Sym name, TagDeclKind kind, Type* type,
                      int complete) {
   TagEntry* e = arena_new(p->pool->arena, TagEntry);
   Scope* s = p->scope;
   if (!e) perr(p, "out of memory in tag_define");
   memset(e, 0, sizeof *e);
   e->name = name;
   e->kind = (u8)kind;
   e->complete = (u8)(complete ? 1 : 0);
   e->type = type;
   e->next = s->tags;
   s->tags = e;
   s->ntags++;
   tag_index_put(p, s, e);
   return e;
 }
 
 TagEntry* tag_lookup(Parser* p, Sym name) {
   Scope* s;
   for (s = p->scope; s; s = s->parent) {
     TagEntry* e = tag_find_in(s, name);
     if (e) return e;
   }
   return NULL;
 }
 
 TagEntry* tag_lookup_local(Parser* p, Sym name) {
   return tag_find_in(p->scope, name);
 }
 
 /* ============================================================
  * Type helpers
  * ============================================================ */
 
 static const Type* ty_size_t(Parser* p) {
   return c_abi_size_type(p->abi, p->pool);
 }
 
 /* C owns conventional function selection; CG owns the guard/check lowering.
  * BASIC follows GCC's classic character-buffer threshold, STRONG covers every
  * local array (including arrays nested in records) plus address-taken locals,
  * and dynamic alloca selects either mode. */
 static int stack_type_selects(Parser* p, const Type* type, int strong) {
   u16 i;
   if (!type) return 0;
   if (type->kind == TY_ARRAY) {
     if (strong) return 1;
     if ((type->arr.elem->kind == TY_CHAR ||
          type->arr.elem->kind == TY_SCHAR ||
          type->arr.elem->kind == TY_UCHAR) &&
         !type->arr.incomplete &&
         c_abi_sizeof(p->abi, p->pool, type) >= 8u)
       return 1;
     return stack_type_selects(p, type->arr.elem, strong);
   }
   if (type->kind == TY_STRUCT || type->kind == TY_UNION) {
     for (i = 0; i < type->rec.nfields; ++i) {
       if (stack_type_selects(p, type->rec.fields[i].type, strong)) return 1;
     }
   }
   return 0;
 }
 
 void c_stack_protector_enable(Parser* p) {
   if (!p || p->stack_protector_mode == KIT_STACK_PROTECTOR_NONE)
     return;
   if (p->stack_protector_scan) {
     p->stack_protector_scan_selected = 1;
     return;
   }
   if (p->stack_protector_enabled || !p->cur_func_emits) return;
   kit_cg_stack_protector_enable(p->cg);
   p->stack_protector_enabled = 1;
 }
 
 void c_stack_protector_note_type(Parser* p, const Type* type) {
   if (!p || p->stack_protector_mode == KIT_STACK_PROTECTOR_NONE ||
       p->stack_protector_mode == KIT_STACK_PROTECTOR_ALL)
     return;
   if (stack_type_selects(
           p, type,
           p->stack_protector_mode == KIT_STACK_PROTECTOR_STRONG))
     c_stack_protector_enable(p);
 }
 
 void c_stack_protector_note_address(Parser* p) {
   if (p && p->stack_protector_mode == KIT_STACK_PROTECTOR_STRONG)
     c_stack_protector_enable(p);
 }
 
 /* ============================================================
  * Local-variable slot allocation
  * ============================================================ */
 
 FrameSlot make_local_aligned(Parser* p, Sym name, const Type* type, SrcLoc loc,
                              u32 align_override) {
   FrameSlotDesc fsd;
   FrameSlot s;
   SymEntry* e;
   u32 nat = c_abi_alignof(p->abi, p->pool, type);
   c_stack_protector_note_type(p, type);
   memset(&fsd, 0, sizeof fsd);
   fsd.type = type;
   fsd.name = name;
   fsd.loc = loc;
   fsd.size = c_abi_sizeof(p->abi, p->pool, type);
   fsd.align = (align_override > nat) ? align_override : nat;
   fsd.kind = FS_LOCAL;
   fsd.flags = FSF_NONE;
   s = c_cg_local(p, &fsd);
   e = scope_define_checked(p, name, SEK_LOCAL, type);
   e->v.slot = s;
   sym_set_decl(e, DECL_NONE, DS_AUTO, DL_NONE, DF_NONE, DSTATE_DEFINED);
   return s;
 }
 
 FrameSlot make_local(Parser* p, Sym name, const Type* type, SrcLoc loc) {
   return make_local_aligned(p, name, type, loc, 0);
 }
 
 static FrameSlot make_vla_size_slot(Parser* p) {
   FrameSlotDesc fsd;
   memset(&fsd, 0, sizeof fsd);
   fsd.type = ty_size_t(p);
   fsd.size = c_abi_sizeof(p->abi, p->pool, fsd.type);
   fsd.align = c_abi_alignof(p->abi, p->pool, fsd.type);
   fsd.kind = FS_LOCAL;
   return c_cg_local(p, &fsd);
 }
 
 static void store_top_to_size_slot(Parser* p, FrameSlot slot) {
   c_cg_push_local_typed(p, slot, ty_size_t(p));
   c_cg_swap(p);
   coerce_top_to_lvalue(p);
   c_cg_store_void(p);
 }
 
 static void reset_vla_pending(Parser* p) {
   p->vla_pending = 0;
   p->vla_pending_count_slot = FRAME_SLOT_NONE;
   p->vla_pending_count_len = 0;
 }
 
 static VLABound* add_vla_bound(Parser* p, VLABound* head, const Type* array_ty,
                                FrameSlot byte_slot, FrameSlot count_slot) {
   VLABound* b = arena_znew(p->pool->arena, VLABound);
   b->array_ty = array_ty;
   b->byte_slot = byte_slot;
   b->count_slot = count_slot;
   b->next = head;
   return b;
 }
 
 static int build_vla_size(Parser* p, const Type* ty, u32* count_idx,
                           VLABound** bounds, FrameSlot* out_slot,
                           u32* out_static_size, SrcLoc loc) {
   if (!ty || ty->kind != TY_ARRAY) {
     *out_static_size = c_abi_sizeof(p->abi, p->pool, ty);
     *out_slot = FRAME_SLOT_NONE;
     return 0;
   }
 
   FrameSlot count_slot = FRAME_SLOT_NONE;
   int count_dynamic = 0;
   if (ty->arr.incomplete) {
     if (*count_idx >= p->vla_pending_count_len) {
       perr(p, "missing VLA bound for declarator");
     }
     count_slot = p->vla_pending_count_slots[(*count_idx)++];
     count_dynamic = 1;
   }
 
   FrameSlot elem_slot = FRAME_SLOT_NONE;
   u32 elem_static_size = 0;
   int elem_dynamic = build_vla_size(p, ty->arr.elem, count_idx, bounds,
                                     &elem_slot, &elem_static_size, loc);
 
   if (count_dynamic || elem_dynamic) {
     FrameSlot byte_slot = make_vla_size_slot(p);
     c_cg_set_loc(p, loc);
     if (count_dynamic) {
       c_cg_push_local_typed(p, count_slot, ty_size_t(p));
       c_cg_load(p);
     } else {
       c_cg_push_int(p, (i64)ty->arr.count, ty_size_t(p));
     }
     if (elem_dynamic) {
       c_cg_push_local_typed(p, elem_slot, ty_size_t(p));
       c_cg_load(p);
     } else {
       c_cg_push_int(p, (i64)elem_static_size, ty_size_t(p));
     }
     c_cg_binop(p, BO_IMUL);
     store_top_to_size_slot(p, byte_slot);
     *bounds = add_vla_bound(p, *bounds, ty, byte_slot, count_slot);
     *out_slot = byte_slot;
     *out_static_size = 0;
     return 1;
   }
 
   *out_slot = FRAME_SLOT_NONE;
   *out_static_size = ty->arr.count * elem_static_size;
   return 0;
 }
 
 static FrameSlot finish_vla_layout(Parser* p, const Type* ty, SrcLoc loc,
                                    VLABound** bounds_out) {
   FrameSlot byte_slot = FRAME_SLOT_NONE;
   u32 static_size = 0;
   u32 count_idx = 0;
   *bounds_out = NULL;
   if (!build_vla_size(p, ty, &count_idx, bounds_out, &byte_slot, &static_size,
                       loc)) {
     perr(p, "VLA declarator did not produce a runtime size");
   }
   if (count_idx != p->vla_pending_count_len) {
     perr(p, "unused VLA bound in declarator");
   }
   reset_vla_pending(p);
   return byte_slot;
 }
 
 static int type_array_depth(const Type* ty) {
   int n = 0;
   while (ty && ty->kind == TY_ARRAY) {
     ++n;
     ty = ty->arr.elem;
   }
   return n;
 }
 
 static void eval_param_vla_count(Parser* p, const ParamVLABoundExpr* expr,
                                  FrameSlot slot) {
   Tok save_cur = p->cur;
   Tok save_next = p->next;
   int save_has_next = p->has_next;
   Tok* save_replay = p->replay;
   u32 save_cap = p->replay_cap;
   u32 save_len = p->replay_len;
   u32 save_pos = p->replay_pos;
   u8 save_active = p->replay_active;
   Tok* replay;
 
   if (!expr->has_expr || expr->ntoks == 0) {
     perr(p, "missing VLA parameter bound");
   }
   replay = arena_array(p->pool->arena, Tok, expr->ntoks + 1u);
   memcpy(replay, expr->toks, sizeof(Tok) * expr->ntoks);
   memset(&replay[expr->ntoks], 0, sizeof(Tok));
   replay[expr->ntoks].kind = TOK_EOF;
 
   p->cur = replay[0];
   p->next.kind = TOK_EOF;
   p->has_next = 0;
   p->replay = replay;
   p->replay_cap = expr->ntoks + 1u;
   p->replay_len = expr->ntoks + 1u;
   p->replay_pos = 1;
   p->replay_active = 1;
 
   parse_assign_expr(p);
   to_rvalue(p);
   if (p->cur.kind != TOK_EOF) {
     perr(p, "unexpected token in VLA parameter bound");
   }
   store_top_to_size_slot(p, slot);
 
   p->cur = save_cur;
   p->next = save_next;
   p->has_next = save_has_next;
   p->replay = save_replay;
   p->replay_cap = save_cap;
   p->replay_len = save_len;
   p->replay_pos = save_pos;
   p->replay_active = save_active;
 }
 
 static VLABound* build_param_vla_bounds(Parser* p, const ParamInfo* info,
                                         SrcLoc loc) {
   const Type* root = info->declared_type;
   u32 dim_skip = 0;
   u32 need;
   VLABound* bounds = NULL;
 
   if (!root || info->vla_bound_len == 0) return NULL;
   if (root->kind == TY_ARRAY) {
     dim_skip = 1;
     root = root->arr.elem;
   } else if (root->kind == TY_PTR) {
     root = root->ptr.pointee;
   }
   need = (u32)type_array_depth(root);
   if (need == 0) return NULL;
   if (dim_skip + need > info->vla_bound_len) {
     perr(p, "missing VLA parameter bound");
   }
 
   reset_vla_pending(p);
   for (u32 i = 0; i < need; ++i) {
     const ParamVLABoundExpr* expr = &info->vla_bounds[dim_skip + i];
     FrameSlot slot = make_vla_size_slot(p);
     eval_param_vla_count(p, expr, slot);
     p->vla_pending = 1;
     p->vla_pending_count_slots[p->vla_pending_count_len++] = slot;
   }
   (void)finish_vla_layout(p, root, loc, &bounds);
   return bounds;
 }
 
 /* ============================================================
  * Static-local symbol naming
  * ============================================================ */
 
 /* Mint a unique linker name for a static local: `<orig>.<counter>`. */
 Sym mint_static_local_sym(Parser* p, Sym orig) {
   KitSlice orig_sl = kit_sym_str(p->pool->c, orig);
   size_t olen = orig_sl.len;
   const char* on = orig_sl.s;
   char buf[128];
   u32 wlen = 0;
   u32 id = ++p->static_local_counter;
   if (olen > 100) olen = 100;
   for (size_t i = 0; i < olen && wlen < sizeof buf - 1; ++i) {
     buf[wlen++] = on[i];
   }
   if (wlen < sizeof buf - 1) buf[wlen++] = '.';
   {
     char digits[12];
     int dn = 0;
     if (id == 0) digits[dn++] = '0';
     while (id) {
       digits[dn++] = (char)('0' + (id % 10));
       id /= 10;
     }
     while (dn && wlen < sizeof buf - 1) buf[wlen++] = digits[--dn];
   }
   return kit_sym_intern(p->pool->c, (KitSlice){.s = buf, .len = wlen});
 }
 
 /* ============================================================
  * Declarations
  * ============================================================ */
 
 /* Parse a single init-declarator after the decl-specs have been consumed. */
 static SymEntry* declare_function(Parser* p, Sym fname, const Type* fn_ty,
                                   const DeclSpecs* specs, SrcLoc fname_loc,
                                   const Attr* dattrs, Sym asm_label,
                                   ObjSecId* out_section_id, u32* out_decl_flags,
                                   Sym* out_alias_target);
 
 static void parse_init_declarator(Parser* p, const DeclSpecs* specs) {
   SrcLoc loc;
   Sym name;
   DeclaratorInfo dinfo;
   const Type* var_ty = parse_declarator_full_info(
       p, specs->type, /*allow_abstract=*/0, &name, &loc, NULL, &dinfo);
   if ((specs->flags & DF_THREAD) && specs->storage != DS_STATIC &&
       specs->storage != DS_EXTERN) {
     perr(p, "block-scope _Thread_local requires static or extern");
   }
   validate_decl_type_constraints(p, specs, var_ty,
                                  var_ty && var_ty->kind == TY_FUNC,
                                  /*is_member=*/0);
 
   if (specs->storage == DS_TYPEDEF) {
     if (is_punct(&p->cur, '=')) {
       perr(p, "typedef declarator cannot have initializer");
     }
     {
       SymEntry* e = scope_define_checked(p, name, SEK_TYPEDEF, var_ty);
       sym_set_decl(e, DECL_NONE, DS_TYPEDEF, DL_NONE, specs->flags,
                    DSTATE_DECLARED);
       if (p->vla_pending && var_ty && var_ty->kind == TY_ARRAY) {
         VLABound* bounds = NULL;
         FrameSlot byte_slot = finish_vla_layout(p, var_ty, loc, &bounds);
         e->vla_byte_slot = byte_slot;
         e->vla_bounds = bounds;
       } else if (specs->vla_byte_slot != FRAME_SLOT_NONE) {
         e->vla_byte_slot = specs->vla_byte_slot;
         e->vla_bounds = specs->vla_bounds;
       }
     }
     (void)loc;
     return;
   }
 
   if (var_ty && var_ty->kind == TY_FUNC) {
     ObjSecId section_id;
     u32 decl_flags;
     Sym alias_target;
     if ((specs->storage == DS_AUTO && specs->storage_explicit) ||
         specs->storage == DS_REGISTER || specs->storage == DS_STATIC) {
       perr(p,
            "invalid storage-class specifier for block-scope function "
            "declaration");
     }
     if (is_punct(&p->cur, '=')) {
       perr(p, "function declarator cannot have initializer");
     }
     if (p->stack_protector_scan) {
       SymEntry* prior = scope_lookup(p, name);
       SymEntry* e = scope_lookup_current(p, name);
       if (!e) e = scope_define(p, name, SEK_FUNC, var_ty);
       e->v.sym = prior && prior->kind == SEK_FUNC ? prior->v.sym
                                                   : OBJ_SYM_NONE;
       sym_set_decl(e, prior ? prior->decl_id : DECL_NONE, DS_EXTERN,
                    prior ? (DeclLinkage)prior->linkage : DL_EXTERNAL,
                    prior ? prior->decl_flags : DF_NONE, DSTATE_DECLARED);
     } else {
       (void)declare_function(p, name, var_ty, specs, loc, NULL,
                              dinfo.asm_label, &section_id, &decl_flags,
                              &alias_target);
     }
     (void)section_id;
     (void)decl_flags;
     (void)alias_target;
     return;
   }
 
   if (specs->storage == DS_STATIC) {
     Decl decl_in;
     DeclId did;
     ObjSymId sym;
     SymEntry* e;
     Sym lname;
     int has_init;
     u32 align_eff;
     has_init = accept_punct(p, '=');
     /* Complete `T x[] = {...}` before declaring the symbol so the registered
      * (CG) type carries the real element count. Backends such as the C target
      * derive function-local label-table sizes from the symbol's type, so the
      * declared type must already be the completed array. */
     if (has_init && var_ty && var_ty->kind == TY_ARRAY &&
         var_ty->arr.incomplete) {
       var_ty = complete_incomplete_array(p, var_ty);
     }
     if (p->stack_protector_scan) {
       e = scope_define_checked(p, name, SEK_GLOBAL, var_ty);
       e->v.sym = OBJ_SYM_NONE;
       sym_set_decl(e, DECL_NONE, DS_STATIC, DL_NONE, DF_STATIC_LOCAL,
                    DSTATE_DEFINED);
       if (has_init) {
         if ((var_ty->kind == TY_ARRAY || var_ty->kind == TY_STRUCT ||
              var_ty->kind == TY_UNION) &&
             is_punct(&p->cur, '{')) {
           init_at(p, FRAME_SLOT_NONE, var_ty, 0, var_ty);
         } else {
           parse_assign_expr(p);
           c_cg_drop(p);
         }
       }
       return;
     }
     lname = mint_static_local_sym(p, name);
     memset(&decl_in, 0, sizeof decl_in);
     decl_in.name = lname;
     decl_in.asm_name = dinfo.asm_label;
     decl_in.type = var_ty;
     decl_in.loc = loc;
     decl_in.storage = DS_STATIC;
     decl_in.linkage = DL_INTERNAL;
     decl_in.visibility = SV_DEFAULT;
     decl_in.flags = DF_STATIC_LOCAL | (specs->flags & DF_THREAD);
     attr_list_to_decl(p->c, p->decls, specs->attrs, &decl_in);
     did = decl_declare(p->decls, &decl_in);
     sym = decl_obj_sym(p->decls, did);
     e = scope_define_checked(p, name, SEK_GLOBAL, var_ty);
     e->v.sym = sym;
     sym_set_decl(e, did, DS_STATIC, DL_NONE, decl_in.flags, DSTATE_DEFINED);
     align_eff = (specs->align > decl_in.align) ? specs->align : decl_in.align;
     define_static_object(p, sym, decl_in.section_id, var_ty, specs->quals,
                          has_init, loc, align_eff);
     return;
   }
 
   if (specs->storage == DS_EXTERN) {
     Decl decl_in;
     DeclId did;
     ObjSymId sym;
     SymEntry* e;
     SymEntry* prior;
     if (accept_punct(p, '=')) {
       perr(p, "block-scope extern with initializer not supported");
     }
     prior = scope_lookup(p, name);
     if (p->stack_protector_scan) {
       e = scope_lookup_current(p, name);
       if (!e) e = scope_define(p, name, SEK_GLOBAL, var_ty);
       e->v.sym = prior && prior->kind == SEK_GLOBAL ? prior->v.sym
                                                     : OBJ_SYM_NONE;
       sym_set_decl(e, prior ? prior->decl_id : DECL_NONE, DS_EXTERN,
                    prior ? (DeclLinkage)prior->linkage : DL_EXTERNAL,
                    prior ? prior->decl_flags : DF_NONE, DSTATE_DECLARED);
       return;
     }
     if (prior && prior->kind == SEK_GLOBAL) {
       SymEntry* cur = scope_lookup_current(p, name);
       const Type* composite = NULL;
       CSemCheck chk =
           c_sem_check_redeclaration(p->pool, prior->type, var_ty, &composite);
       if (!chk.ok) perr(p, "%.*s", KIT_SLICE_ARG(kit_slice_cstr(chk.message)));
       if (cur && cur->kind != SEK_GLOBAL) {
         perr(p, "redefinition of identifier");
       }
       if (cur) return;
       e = scope_define(p, name, SEK_GLOBAL, var_ty);
       e->v.sym = prior->v.sym;
       sym_set_decl(e, prior->decl_id, DS_EXTERN, (DeclLinkage)prior->linkage,
                    prior->decl_flags, (DeclState)prior->decl_state);
       return;
     }
     memset(&decl_in, 0, sizeof decl_in);
     decl_in.name = name;
     decl_in.asm_name = dinfo.asm_label;
     decl_in.type = var_ty;
     decl_in.loc = loc;
     decl_in.storage = DS_EXTERN;
     decl_in.linkage = DL_EXTERNAL;
     decl_in.visibility = p->default_visibility;
     decl_in.flags = specs->flags & DF_THREAD;
     attr_list_to_decl(p->c, p->decls, specs->attrs, &decl_in);
     did = decl_declare(p->decls, &decl_in);
     sym = decl_obj_sym(p->decls, did);
     e = scope_define_checked(p, name, SEK_GLOBAL, var_ty);
     e->v.sym = sym;
     sym_set_decl(e, did, DS_EXTERN, DL_EXTERNAL, decl_in.flags,
                  DSTATE_DECLARED);
     return;
   }
 
   if (var_ty && var_ty->kind == TY_ARRAY &&
       (p->vla_pending || specs->vla_byte_slot != FRAME_SLOT_NONE)) {
     const Type* elem_ty = var_ty->arr.elem;
     const Type* ptr_ty = type_ptr(p->pool, elem_ty);
     FrameSlot byte_slot;
     FrameSlot ptr_slot;
     SymEntry* sym_entry;
     VLABound* bounds = NULL;
     c_stack_protector_enable(p); /* VLA lowers through dynamic alloca. */
     if (p->vla_pending) {
       byte_slot = finish_vla_layout(p, var_ty, loc, &bounds);
       ++p->vla_mark;
     } else {
       byte_slot = specs->vla_byte_slot;
       bounds = specs->vla_bounds;
     }
     ptr_slot = make_local(p, name, ptr_ty, loc);
     c_cg_set_loc(p, loc);
     c_cg_push_local_typed(p, byte_slot, ty_size_t(p));
     c_cg_load(p);
     c_cg_alloca(p);
     c_cg_push_local_typed(p, ptr_slot, ptr_ty);
     c_cg_swap(p);
     c_cg_store_void(p);
     sym_entry = scope_lookup(p, name);
     if (sym_entry && sym_entry->kind == SEK_LOCAL) {
       sym_entry->vla_byte_slot = byte_slot;
       sym_entry->vla_bounds = bounds;
     }
     if (accept_punct(p, '=')) {
       perr(p, "VLA initializers are not allowed (§6.7.9 ¶3)");
     }
     return;
   }
   /* Non-VLA local. */
   {
     int has_init = is_punct(&p->cur, '=');
     FrameSlot s;
     if (has_init && var_ty && var_ty->kind == TY_ARRAY &&
         var_ty->arr.incomplete) {
       advance(p); /* '=' */
       var_ty = complete_incomplete_array(p, var_ty);
       s = make_local_aligned(p, name, var_ty, loc, specs->align);
       if (specs->storage == DS_REGISTER) {
         SymEntry* e = scope_lookup_current(p, name);
         if (e && e->kind == SEK_LOCAL) {
           e->storage = DS_REGISTER;
           e->reg_asm_name = dinfo.asm_label;
         }
       }
       c_cg_set_loc(p, loc);
       init_at(p, s, var_ty, 0, var_ty);
       return;
     }
     s = make_local_aligned(p, name, var_ty, loc, specs->align);
     if (specs->storage == DS_REGISTER) {
       SymEntry* e = scope_lookup_current(p, name);
       if (e && e->kind == SEK_LOCAL) {
         e->storage = DS_REGISTER;
         e->reg_asm_name = dinfo.asm_label;
       }
     }
     if (accept_punct(p, '=')) {
       c_cg_set_loc(p, loc);
       if ((var_ty->kind == TY_STRUCT || var_ty->kind == TY_UNION) &&
           !is_punct(&p->cur, '{')) {
         parse_assign_expr(p);
         emit_struct_copy_into_slot(p, s, var_ty, 0, var_ty);
       } else if (var_ty->kind == TY_ARRAY || var_ty->kind == TY_STRUCT ||
                  var_ty->kind == TY_UNION) {
         init_at(p, s, var_ty, 0, var_ty);
       } else {
         c_cg_push_local_typed(p, s, var_ty);
         parse_assign_expr(p);
         to_rvalue(p);
         {
           const Type* rhs = c_cg_top_type(p);
           CSemCheck chk = c_sem_check_assignment(p->pool, var_ty, rhs);
           if (!chk.ok)
             perr(p, "%.*s", KIT_SLICE_ARG(kit_slice_cstr(chk.message)));
         }
         coerce_top_to_lvalue(p);
         c_cg_store_void(p);
       }
     } else if (p->auto_var_init == KIT_AUTOVAR_ZERO && var_ty &&
                !(var_ty->kind == TY_ARRAY && var_ty->arr.incomplete)) {
       /* -ftrivial-auto-var-init=zero: an automatic variable with no explicit
        * initializer is implicitly zeroed (clang/gcc semantics). When the
        * variable is fully written before any read the store is dead and the
        * optimizer drops it. VLAs and incomplete arrays are left alone. */
       c_cg_set_loc(p, loc);
       /* Zero the whole object in one memset rather than recursing to one store
        * per scalar leaf. The per-leaf path is O(leaves^2) on large aggregates
        * (each leaf store stashes a fresh frontend temp, growing g->nlocals,
        * which api_local_const_address_taken then re-scans on every store) and
        * explodes under ASAN — e.g. a 28 KB manifest local in src/api/package.c
        * stalled the debug bootstrap for minutes. memset is also what gcc/clang
        * emit for -ftrivial-auto-var-init=zero. */
       zero_object_bytes_at(p, s, var_ty, 0, var_ty);
     }
   }
 }
 
 void parse_local_decl(Parser* p, const DeclSpecs* specs) {
   if (accept_punct(p, ';')) return;
   parse_init_declarator(p, specs);
   while (accept_punct(p, ',')) {
     parse_init_declarator(p, specs);
   }
   expect_punct(p, ';', "';' after declaration");
 }
 
 /* ============================================================
  * External (top-level) declarations
  * ============================================================ */
 
 void parse_param_list(Parser* p, ParamInfo** infos_out, u16* nparams_out,
                       u8* variadic_out) {
   ParamInfo* infos;
   u32 cap = 4;
   u32 n = 0;
   *variadic_out = 0;
   *infos_out = NULL;
   *nparams_out = 0;
 
   if (is_punct(&p->cur, ')')) {
     return;
   }
   if (is_kw(p, &p->cur, KW_VOID)) {
     Tok n2 = peek1(p);
     if (is_punct(&n2, ')')) {
       advance(p); /* `void` */
       return;     /* `(void)` */
     }
   }
 
   infos = (ParamInfo*)arena_array(p->pool->arena, ParamInfo, cap);
   for (;;) {
     DeclSpecs specs;
     Sym pname = 0;
     SrcLoc ploc = {0, 0, 0};
     const Type* pty;
     if (accept_punct(p, P_ELLIPSIS)) {
       if (n == 0) perr(p, "ellipsis requires a preceding parameter");
       *variadic_out = 1;
       break;
     }
     if (!parse_decl_specs(p, &specs)) {
       perr(p, "expected parameter type");
     }
     if ((specs.storage_explicit && specs.storage != DS_REGISTER) ||
         specs.storage == DS_TYPEDEF || (specs.flags & DF_THREAD)) {
       perr(p, "invalid storage-class specifier in parameter declaration");
     }
     p->param_vla_bound_len = 0;
     p->in_param_decl++;
     pty = parse_declarator_full(p, specs.type, /*allow_abstract=*/1, &pname,
                                 &ploc);
     p->in_param_decl--;
     const Type* declared_pty = pty;
     if (pty && pty->kind == TY_ARRAY) {
       pty = type_ptr(p->pool, pty->arr.elem);
     } else if (pty && pty->kind == TY_FUNC) {
       pty = type_ptr(p->pool, pty);
     }
     if (pty && pty->kind == TY_VOID) {
       perr(p, "'void' must be the only parameter");
     }
     validate_decl_type_constraints(p, &specs, pty, /*is_function=*/0,
                                    /*is_member=*/0);
     if (pname) {
       for (u32 pi = 0; pi < n; ++pi) {
         if (infos[pi].name == pname) perr(p, "redefinition of parameter");
       }
     }
     if (n == cap) {
       cap *= 2;
       ParamInfo* nbuf = (ParamInfo*)arena_array(p->pool->arena, ParamInfo, cap);
       memcpy(nbuf, infos, sizeof(ParamInfo) * n);
       infos = nbuf;
     }
     infos[n].name = pname;
     infos[n].type = pty;
     infos[n].declared_type = declared_pty;
     infos[n].loc = ploc;
     infos[n].vla_bounds = NULL;
     infos[n].vla_bound_len = p->param_vla_bound_len;
     if (p->param_vla_bound_len) {
       ParamVLABoundExpr* bounds = arena_array(p->pool->arena, ParamVLABoundExpr,
                                               p->param_vla_bound_len);
       memcpy(bounds, p->param_vla_bounds,
              sizeof(ParamVLABoundExpr) * p->param_vla_bound_len);
       infos[n].vla_bounds = bounds;
     }
     ++n;
     if (!accept_punct(p, ',')) break;
   }
   *infos_out = infos;
   *nparams_out = (u16)n;
 }
 
 static SymEntry* declare_function(Parser* p, Sym fname, const Type* fn_ty,
                                   const DeclSpecs* specs, SrcLoc fname_loc,
                                   const Attr* dattrs, Sym asm_label,
                                   ObjSecId* out_section_id, u32* out_decl_flags,
                                   Sym* out_alias_target) {
   SymEntry* visible;
   if (out_section_id) *out_section_id = OBJ_SEC_NONE;
   if (out_decl_flags) *out_decl_flags = 0;
   if (out_alias_target) *out_alias_target = 0;
   SymEntry* existing = scope_lookup_current(p, fname);
   if (existing && existing->kind != SEK_FUNC) {
     perr(p, "redefinition of identifier");
   }
   if (existing && existing->kind == SEK_FUNC) {
     const Type* composite = NULL;
     CSemCheck chk =
         c_sem_check_redeclaration(p->pool, existing->type, fn_ty, &composite);
     if (!chk.ok) perr(p, "%.*s", KIT_SLICE_ARG(kit_slice_cstr(chk.message)));
     if (specs->storage == DS_STATIC && existing->linkage == DL_EXTERNAL) {
       perr(p, "static declaration follows non-static declaration");
     }
     existing->type = composite ? composite : existing->type;
     Decl tmp;
     memset(&tmp, 0, sizeof tmp);
     attr_list_to_decl(p->c, p->decls, specs->attrs, &tmp);
     attr_list_to_decl(p->c, p->decls, dattrs, &tmp);
     if (out_section_id) *out_section_id = tmp.section_id;
     if (out_decl_flags) *out_decl_flags = tmp.flags;
     if (out_alias_target) *out_alias_target = tmp.alias_target;
     decl_apply_redecl_flags(p->decls, existing->decl_id, tmp.flags);
     external_func_remember(p, fname, existing);
     return existing;
   }
   /* `existing` is provably NULL here (both branches above perr or return), so
    * the current scope has no binding for fname. Skip re-probing it: walk from
    * the parent scope. */
   visible = scope_lookup_from(p->scope ? p->scope->parent : NULL, fname);
   if (!existing && visible && visible->kind == SEK_FUNC) {
     existing = visible;
   }
   if (!existing) {
     existing = external_func_lookup(p, fname);
   }
   if (existing) {
     const Type* composite = NULL;
     CSemCheck chk =
         c_sem_check_redeclaration(p->pool, existing->type, fn_ty, &composite);
     if (!chk.ok) perr(p, "%.*s", KIT_SLICE_ARG(kit_slice_cstr(chk.message)));
     if (specs->storage == DS_STATIC && existing->linkage == DL_EXTERNAL) {
       perr(p, "static declaration follows non-static declaration");
     }
     if (scope_lookup_current(p, fname) != existing) {
       SymEntry* e = scope_define(p, fname, SEK_FUNC,
                                  composite ? composite : existing->type);
       e->v.sym = existing->v.sym;
       sym_set_decl(e, existing->decl_id, (DeclStorage)existing->storage,
                    (DeclLinkage)existing->linkage, existing->decl_flags,
                    (DeclState)existing->decl_state);
       existing = e;
     } else if (composite) {
       existing->type = composite;
     }
     {
       Decl tmp;
       memset(&tmp, 0, sizeof tmp);
       attr_list_to_decl(p->c, p->decls, specs->attrs, &tmp);
       attr_list_to_decl(p->c, p->decls, dattrs, &tmp);
       if (out_section_id) *out_section_id = tmp.section_id;
       if (out_decl_flags) *out_decl_flags = tmp.flags;
       if (out_alias_target) *out_alias_target = tmp.alias_target;
       decl_apply_redecl_flags(p->decls, existing->decl_id, tmp.flags);
     }
     external_func_remember(p, fname, existing);
     return existing;
   }
   {
     Decl decl_in;
     DeclId did;
     ObjSymId fsym;
     SymEntry* e;
     memset(&decl_in, 0, sizeof decl_in);
     decl_in.name = fname;
     decl_in.asm_name = asm_label;
     decl_in.type = fn_ty;
     decl_in.loc = fname_loc;
     decl_in.storage =
         (specs->storage == DS_STATIC ||
          ((specs->flags & DF_INLINE) && specs->storage != DS_EXTERN))
             ? DS_STATIC
             : DS_EXTERN;
     decl_in.linkage =
         (decl_in.storage == DS_STATIC) ? DL_INTERNAL : DL_EXTERNAL;
     decl_in.visibility =
         decl_in.linkage == DL_EXTERNAL ? p->default_visibility : SV_DEFAULT;
     attr_list_to_decl(p->c, p->decls, specs->attrs, &decl_in);
     attr_list_to_decl(p->c, p->decls, dattrs, &decl_in);
     /* The `inline` specifier is a keyword carried on specs->flags, separate from
      * the __attribute__ flags attr_list_to_decl applies. It must be merged onto
      * the decl so decl_inline_policy() sees it on both the recorded symbol attrs
      * (decl_declare below) and the returned decl flags (out_decl_flags, used to
      * build the function descriptor). Without this, `static inline` functions
      * silently fell back to the DEFAULT inline policy — only the always_inline /
      * noinline attributes reached codegen — so a `static inline` body got no
      * stronger inlining than a plain static one. */
     decl_in.flags |= (specs->flags & DF_INLINE);
     did = decl_declare(p->decls, &decl_in);
     fsym = decl_obj_sym(p->decls, did);
     e = scope_define(p, fname, SEK_FUNC, fn_ty);
     e->v.sym = fsym;
     sym_set_decl(e, did, decl_in.storage, decl_in.linkage, decl_in.flags,
                  DSTATE_DECLARED);
     external_func_remember(p, fname, e);
     if (out_section_id) *out_section_id = decl_in.section_id;
     if (out_decl_flags) *out_decl_flags = decl_in.flags;
     if (out_alias_target) *out_alias_target = decl_in.alias_target;
     return e;
   }
 }
 
 static void parse_function_body(Parser* p, ObjSymId fsym, const Type* fn_ty,
                                 const ABIFuncInfo* abi, const ParamInfo* infos,
                                 u16 nparams, SrcLoc fname_loc,
                                 ObjSecId section_id, u32 decl_flags) {
   CGFuncDesc fd;
   CGParamDesc* pds = NULL;
 
   memset(&fd, 0, sizeof fd);
   fd.sym = fsym;
   fd.text_section_id = section_id;
   fd.group_id = OBJ_GROUP_NONE;
   fd.fn_type = fn_ty;
   fd.abi = abi;
   fd.params = NULL;
   fd.nparams = nparams;
   fd.loc = fname_loc;
   if (decl_flags & DF_NORETURN) fd.flags |= CGFD_NORETURN;
   if (decl_flags & DF_NOINLINE)
     fd.inline_policy = KIT_CG_INLINE_NEVER;
   else if (decl_flags & DF_ALWAYS_INLINE)
     fd.inline_policy = KIT_CG_INLINE_ALWAYS;
   else if (decl_flags & DF_INLINE)
     fd.inline_policy = KIT_CG_INLINE_HINT;
 
   if (nparams) {
     pds = (CGParamDesc*)arena_array(p->pool->arena, CGParamDesc, nparams);
     memset(pds, 0, sizeof(CGParamDesc) * nparams);
     for (u16 i = 0; i < nparams; ++i) {
       pds[i].index = i;
       pds[i].name = infos[i].name;
       pds[i].type = infos[i].type;
       pds[i].slot = FRAME_SLOT_NONE;
       pds[i].abi = &abi->params[i];
       pds[i].incoming = NULL;
       pds[i].nincoming = 0;
       pds[i].loc = infos[i].loc;
     }
     fd.params = pds;
   }
 
   scope_push(p); /* parameter scope */
   GotoLabel* saved_goto_labels = p->goto_labels;
   SwitchCtx* saved_switch = p->cur_switch;
   u8 saved_computed_goto = p->computed_goto_emitted;
   p->goto_labels = NULL;
   p->cur_switch = NULL;
   p->computed_goto_emitted = 0;
   c_cg_set_loc(p, fname_loc);
   /* Record whether this body emits before func_begin (which is itself gated on
    * emit-enabled): goto-label allocation keys off this, not the momentary
    * suppress_codegen depth, so a label first referenced inside a constant-false
    * region still gets a real CG-label id rather than the suppression sentinel.
    */
   p->cur_func_emits = (u8)c_cg_emit_enabled(p);
   p->stack_protector_enabled = 0;
   c_cg_func_begin(p, &fd);
 
   for (u16 i = 0; i < nparams; ++i) {
     FrameSlotDesc fsd;
     FrameSlot s;
     SymEntry* e;
     memset(&fsd, 0, sizeof fsd);
     fsd.type = infos[i].type;
     fsd.name = infos[i].name;
     fsd.loc = infos[i].loc;
     fsd.size = c_abi_sizeof(p->abi, p->pool, infos[i].type);
     fsd.align = c_abi_alignof(p->abi, p->pool, infos[i].type);
     fsd.kind = FS_PARAM;
     fsd.flags = FSF_NONE;
     s = c_cg_param_slot(p, i, &fsd);
     pds[i].slot = s;
     if (infos[i].name) {
       e = scope_define_checked(p, infos[i].name, SEK_LOCAL, infos[i].type);
       e->v.slot = s;
       sym_set_decl(e, DECL_NONE, DS_AUTO, DL_NONE, DF_NONE, DSTATE_DEFINED);
       e->vla_bounds = build_param_vla_bounds(p, &infos[i], infos[i].loc);
     }
   }
 
   if (p->stack_protector_mode == KIT_STACK_PROTECTOR_ALL ||
       p->stack_protector_preselected)
     c_stack_protector_enable(p);
 
   parse_compound_stmt(p);
   if (fn_ty->fn.ret && fn_ty->fn.ret->kind != TY_VOID &&
       fn_ty->fn.ret->kind != TY_STRUCT && fn_ty->fn.ret->kind != TY_UNION) {
     c_cg_push_int(p, 0, fn_ty->fn.ret);
     c_cg_ret(p, 1);
   } else {
     c_cg_ret(p, 0);
   }
   for (GotoLabel* gl = p->goto_labels; gl; gl = gl->next) {
     if (!gl->placed) {
       compiler_panic(p->c, gl->first_use, "goto to undefined label");
     }
   }
   p->goto_labels = saved_goto_labels;
   p->cur_switch = saved_switch;
   p->computed_goto_emitted = saved_computed_goto;
   c_cg_func_end(p);
   scope_pop(p);
 }
 
 /* Parse one external declaration. */
 static void parse_external_decl(Parser* p) {
   DeclSpecs specs;
   Sym name;
   SrcLoc loc;
   const Type* base_ty;
   Attr* dattrs = NULL;
   DeclaratorInfo dinfo;
 
   if (!parse_decl_specs(p, &specs)) {
     perr(p, "expected declaration");
   }
   if (specs.storage == DS_AUTO && specs.storage_explicit) {
     perr(p, "invalid storage-class specifier at file scope");
   }
 
   if (accept_punct(p, ';')) return;
 
   if (specs.storage == DS_TYPEDEF) {
     for (;;) {
       Sym tname = 0;
       SrcLoc tloc = {0, 0, 0};
       const Type* tty =
           parse_declarator_full(p, specs.type,
                                 /*allow_abstract=*/0, &tname, &tloc);
       validate_decl_type_constraints(p, &specs, tty,
                                      tty && tty->kind == TY_FUNC,
                                      /*is_member=*/0);
       if (is_punct(&p->cur, '=')) {
         perr(p, "typedef declarator cannot have initializer");
       }
       {
         SymEntry* te = scope_define_checked(p, tname, SEK_TYPEDEF, tty);
         sym_set_decl(te, DECL_NONE, DS_TYPEDEF, DL_NONE, specs.flags,
                      DSTATE_DECLARED);
       }
       (void)tloc;
       if (!accept_punct(p, ',')) break;
     }
     expect_punct(p, ';', "';' after typedef declaration");
     return;
   }
 
   base_ty = parse_declarator_full_info(p, specs.type, /*allow_abstract=*/0,
                                        &name, &loc, &dattrs, &dinfo);
 
   if (base_ty && base_ty->kind == TY_FUNC) {
     ParamInfo* infos = NULL;
     u16 nparams = 0;
     const Type* fn_ty;
     const ABIFuncInfo* abi;
     SymEntry* fent;
 
     fn_ty = base_ty;
     infos = dinfo.fn_params;
     nparams = dinfo.fn_nparams;
     validate_decl_type_constraints(p, &specs, fn_ty, /*is_function=*/1,
                                    /*is_member=*/0);
     abi = c_abi_func_info(p->abi, p->pool, fn_ty);
 
     ObjSecId fn_section_id;
     u32 fn_decl_flags;
     Sym fn_alias_target;
     fent =
         declare_function(p, name, fn_ty, &specs, loc, dattrs, dinfo.asm_label,
                          &fn_section_id, &fn_decl_flags, &fn_alias_target);
     attr_list_append(&fent->attrs, dattrs);
 
     if (is_punct(&p->cur, '{')) {
       int suppress_body_codegen = specs.storage == DS_EXTERN &&
                                   ((specs.flags | fn_decl_flags) & DF_INLINE);
       if (fent->defined) perr(p, "redefinition of function");
       fent->defined = 1;
       fent->decl_state = DSTATE_FUNC_DEFINED;
       Sym saved_func_name = p->cur_func_name;
       const Type* saved_func_ret = p->cur_func_ret;
       u8 saved_func_emits = p->cur_func_emits;
       p->cur_func_name = name;
       p->cur_func_ret = fn_ty->fn.ret;
       if (p->stack_protector_mode == KIT_STACK_PROTECTOR_BASIC ||
           p->stack_protector_mode == KIT_STACK_PROTECTOR_STRONG) {
         record_function_body(p);
         p->stack_protector_scan = 1;
         p->stack_protector_scan_selected = 0;
         c_cg_codegen_suppress_push(p);
         parse_function_body(p, fent->v.sym, fn_ty, abi, infos, nparams, loc,
                             fn_section_id, fn_decl_flags);
         c_cg_codegen_suppress_pop(p);
         p->stack_protector_scan = 0;
         p->stack_protector_preselected =
             p->stack_protector_scan_selected ? 1u : 0u;
         rewind_function_body(p, 0);
       }
       if (suppress_body_codegen) c_cg_codegen_suppress_push(p);
       parse_function_body(p, fent->v.sym, fn_ty, abi, infos, nparams, loc,
                           fn_section_id, fn_decl_flags);
       if (suppress_body_codegen) c_cg_codegen_suppress_pop(p);
       p->stack_protector_preselected = 0;
       p->function_replay_active = 0;
       p->function_replay_hold = 0;
       p->cur_func_name = saved_func_name;
       p->cur_func_ret = saved_func_ret;
       p->cur_func_emits = saved_func_emits;
       return;
     }
     if (accept_punct(p, ';')) {
       if (fn_alias_target != 0) {
         SymEntry* te = scope_lookup(p, fn_alias_target);
         if (!te) {
           const char* nm = kit_sym_str(p->pool->c, fn_alias_target).s;
           compiler_panic(p->c, loc, "alias target '%.*s' is undefined",
                          KIT_SLICE_ARG(kit_slice_cstr(nm ? nm : "?")));
         }
         KitCgAlias alias;
         memset(&alias, 0, sizeof alias);
         alias.display_name = name;
         alias.linkage_name = kit_cg_c_linkage_name(p->c, name);
         alias.target = te->v.sym;
         alias.sym.bind =
             (fn_decl_flags & DF_WEAK) ? KIT_SB_WEAK : KIT_SB_GLOBAL;
         {
           const Decl* fd = decl_get(p->decls, fent->decl_id);
           alias.sym.visibility =
               fd ? (KitCgVisibility)fd->visibility : KIT_CG_VIS_DEFAULT;
         }
         if (kit_cg_alias(p->cg, alias) == KIT_CG_SYM_NONE) {
           const char* nm = kit_sym_str(p->pool->c, fn_alias_target).s;
           compiler_panic(p->c, loc, "alias target '%.*s' is undefined",
                          KIT_SLICE_ARG(kit_slice_cstr(nm ? nm : "?")));
         }
       }
       return;
     }
     perr(p, "expected '{' or ';' after function declarator");
   }
 
   /* Global object declaration. */
   for (;;) {
     int has_init = is_punct(&p->cur, '=');
     int is_pure_extern =
         (specs.storage == DS_EXTERN || specs.storage == DS_REGISTER) &&
         !has_init;
     SymEntry* existing = scope_lookup_current(p, name);
     ObjSymId sym = OBJ_SYM_NONE;
     ObjSecId section_id = OBJ_SEC_NONE;
     SymEntry* e = NULL;
 
     if (existing && existing->kind != SEK_GLOBAL) {
       perr(p, "redefinition of identifier");
     }
     validate_decl_type_constraints(p, &specs, base_ty, /*is_function=*/0,
                                    /*is_member=*/0);
 
     if (existing && existing->kind == SEK_GLOBAL) {
       const Type* composite = NULL;
       CSemCheck chk = c_sem_check_redeclaration(p->pool, existing->type,
                                                 base_ty, &composite);
       if (!chk.ok) perr(p, "%.*s", KIT_SLICE_ARG(kit_slice_cstr(chk.message)));
       if (specs.storage == DS_STATIC && existing->linkage == DL_EXTERNAL) {
         perr(p, "static declaration follows non-static declaration");
       }
       sym = existing->v.sym;
       e = existing;
       if (has_init && e->defined) {
         perr(p, "redefinition of object");
       }
       if (composite) e->type = composite;
       base_ty = e->type;
     } else {
       Decl decl_in;
       DeclId did;
       memset(&decl_in, 0, sizeof decl_in);
       decl_in.name = name;
       decl_in.asm_name = dinfo.asm_label;
       decl_in.type = base_ty;
       decl_in.loc = loc;
       if (specs.storage == DS_STATIC) {
         decl_in.storage = DS_STATIC;
         decl_in.linkage = DL_INTERNAL;
       } else {
         decl_in.storage = DS_EXTERN;
         decl_in.linkage = DL_EXTERNAL;
       }
       decl_in.visibility =
           decl_in.linkage == DL_EXTERNAL ? p->default_visibility : SV_DEFAULT;
       decl_in.flags = specs.flags & DF_THREAD;
       attr_list_to_decl(p->c, p->decls, specs.attrs, &decl_in);
       attr_list_to_decl(p->c, p->decls, dattrs, &decl_in);
       did = decl_declare(p->decls, &decl_in);
       sym = decl_obj_sym(p->decls, did);
       section_id = decl_in.section_id;
       e = scope_define(p, name, SEK_GLOBAL, base_ty);
       e->v.sym = sym;
       sym_set_decl(e, did, decl_in.storage, decl_in.linkage, decl_in.flags,
                    DSTATE_DECLARED);
     }
     attr_list_append(&e->attrs, dattrs);
 
     u32 attr_align = attrs_pick_aligned(specs.attrs);
     {
       u32 a2 = attrs_pick_aligned(dattrs);
       if (a2 > attr_align) attr_align = a2;
     }
     u32 align_eff = (specs.align > attr_align) ? specs.align : attr_align;
 
     if (has_init) {
       if (e) e->defined = 1;
       if (e) e->decl_state = DSTATE_DEFINED;
       advance(p); /* '=' */
       if (base_ty && base_ty->kind == TY_ARRAY && base_ty->arr.incomplete) {
         const Type* completed = complete_incomplete_array(p, base_ty);
         if (completed != base_ty) {
           base_ty = completed;
           if (e) e->type = base_ty;
         }
       }
       define_static_object(p, sym, section_id, base_ty, specs.quals,
                            /*has_init=*/1, loc, align_eff);
     } else if (!is_pure_extern) {
       if (e && e->decl_state == DSTATE_DECLARED) {
         e->decl_state = DSTATE_TENTATIVE;
       }
       define_static_object(p, sym, section_id, base_ty, specs.quals,
                            /*has_init=*/0, loc, align_eff);
     }
 
     if (!accept_punct(p, ',')) break;
     dattrs = NULL;
     base_ty = parse_declarator_full_info(p, specs.type, /*allow_abstract=*/0,
                                          &name, &loc, &dattrs, &dinfo);
     if (base_ty && base_ty->kind == TY_FUNC) {
       perr(p, "function declarator in object declaration list");
     }
   }
   expect_punct(p, ';', "';' after global declaration");
 }
 
 static void parse_file_scope_asm(Parser* p) {
   u8* bytes;
   size_t nbytes;
   advance(p); /* asm / __asm__ */
   for (;;) {
     if (is_kw(p, &p->cur,
               KW_VOLATILE)) { /* matches `volatile` and `__volatile__` */
       advance(p);
       continue;
     }
     break;
   }
   expect_punct(p, '(', "'(' after file-scope asm");
   if (p->cur.kind != TOK_STR) {
     perr(p, "expected string literal in file-scope asm");
   }
   bytes = decode_string_literal(p, &p->cur, &nbytes);
   advance(p);
   expect_punct(p, ')', "')' after file-scope asm");
   expect_punct(p, ';', "';' after file-scope asm");
   if (nbytes > 0) --nbytes; /* drop decode_string_literal's trailing NUL */
   if (c_cg_emit_enabled(p)) {
     KitSlice asm_src = {{(const char*)bytes}, nbytes};
     kit_cg_file_scope_asm(p->cg, asm_src);
   }
 }
 
 static void parse_translation_unit(Parser* p) {
   while (p->cur.kind != TOK_EOF) {
     if (p->cur.kind == TOK_NEWLINE || is_pp_hash(&p->cur)) {
       advance(p);
       continue;
     }
     if (is_kw(p, &p->cur, KW_STATIC_ASSERT)) {
       parse_static_assert(p);
       continue;
     }
     if (is_kw(p, &p->cur, KW_ASM) || is_kw(p, &p->cur, KW_BUILTIN_ASM)) {
       parse_file_scope_asm(p);
       continue;
     }
     if (accept_punct(p, ';')) {
       continue;
     }
     parse_external_decl(p);
   }
 }
 
 /* ============================================================
  * Entry point
  * ============================================================ */
 
 static u8 parser_default_visibility(KitSymVis vis) {
   switch (vis) {
     case KIT_SV_HIDDEN:
     case KIT_SV_INTERNAL:
       return SV_HIDDEN;
     case KIT_SV_PROTECTED:
       return SV_PROTECTED;
     case KIT_SV_DEFAULT:
     default:
       return SV_DEFAULT;
   }
 }
 
 void parse_c(Compiler* c, Pool* pool, Pp* pp, DeclTable* decls, CG* cg,
              KitSymVis default_visibility, int auto_var_init,
              int stack_protector,
              uint64_t disabled_backend_features) {
   Parser p;
   CKw i;
   u32 syscall_i;
 
   memset(&p, 0, sizeof p);
   p.c = c;
   p.pp = pp;
   p.decls = decls;
   p.cg = cg;
   p.abi = c;
   p.pool = pool;
   p.default_visibility = parser_default_visibility(default_visibility);
   p.auto_var_init = (u8)auto_var_init;
   p.stack_protector_mode = (u8)stack_protector;
   p.general_regs_only =
       (disabled_backend_features & KIT_CG_BACKEND_SIMD) != 0;
 
   /* Index storage for the scope/tag tables and the external-function table all
    * comes from the arena via the pool's shared arena-heap facade. */
   ExternalFuncMap_init(&p.external_funcs, &p.pool->arena_heap);
   KwTab_init(&p.kw_map, &p.pool->arena_heap);
   BindingTab_init(&p.bind, &p.pool->arena_heap);
 
   for (i = (CKw)1; i < KW_COUNT; ++i) {
     p.kw_sym[i] = kit_sym_intern(p.pool->c, kit_slice_cstr(kw_names[i]));
     (void)KwTab_set(&p.kw_map, p.kw_sym[i], (u8)i); /* canonical keyword */
   }
 
   p.sym_b_alloca = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_alloca"));
   p.sym_b_ctz = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_ctz"));
   p.sym_b_ctzl = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_ctzl"));
   p.sym_b_ctzll = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_ctzll"));
   p.sym_b_clz = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_clz"));
   p.sym_b_clzl = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_clzl"));
   p.sym_b_clzll = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_clzll"));
   p.sym_b_trap = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_trap"));
   p.sym_b_unreachable =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_unreachable"));
   p.sym_b_return_address =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_return_address"));
   p.sym_b_frame_address =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_frame_address"));
   p.sym_b_readcyclecounter =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_readcyclecounter"));
   for (syscall_i = 0; syscall_i < 7u; ++syscall_i) {
     char name[16];
     memcpy(name, "__kit_syscall", 13u);
     name[13] = (char)('0' + syscall_i);
     name[14] = '\0';
     p.sym_kit_syscall[syscall_i] =
         kit_sym_intern(p.pool->c, kit_slice_cstr(name));
   }
   p.sym_b_memcpy = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_memcpy"));
   p.sym_b_memmove =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_memmove"));
   p.sym_b_memcmp = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_memcmp"));
   p.sym_b_memset = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_memset"));
   p.sym_b_clear_cache =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin___clear_cache"));
   p.sym_b_isnan = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_isnan"));
   p.sym_b_fabs = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_fabs"));
   p.sym_b_fabsf = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_fabsf"));
   p.sym_b_fabsl = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_fabsl"));
   p.sym_b_inf = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_inf"));
   p.sym_b_inff = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_inff"));
   p.sym_b_infl = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_infl"));
   p.sym_b_huge_val =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_huge_val"));
   p.sym_b_huge_valf =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_huge_valf"));
   p.sym_b_huge_vall =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_huge_vall"));
   p.sym_b_nan = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_nan"));
   p.sym_b_nanf = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_nanf"));
   p.sym_b_nanl = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_nanl"));
   p.sym_b_isless = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_isless"));
   p.sym_b_islessequal =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_islessequal"));
   p.sym_b_isgreater =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_isgreater"));
   p.sym_b_isgreaterequal =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_isgreaterequal"));
   p.sym_b_islessgreater =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_islessgreater"));
   p.sym_b_isunordered =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_isunordered"));
   p.sym_func = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__func__"));
   p.sym_func_gcc = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__FUNCTION__"));
   p.sym_pretty_func_gcc =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__PRETTY_FUNCTION__"));
   p.sym_b_expect = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_expect"));
   p.sym_b_offsetof =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_offsetof"));
   p.sym_b_constant_p =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_constant_p"));
   p.sym_b_va_list =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_va_list"));
   p.sym_b_va_start =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_va_start"));
   p.sym_b_va_arg = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_va_arg"));
   p.sym_b_va_end = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_va_end"));
   p.sym_b_va_copy =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__builtin_va_copy"));
   p.sym_attribute = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__attribute__"));
   p.sym_volatile_alias =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__volatile__"));
   p.sym_alignof_alias = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__alignof__"));
   p.sym_typeof_alias = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__typeof"));
   p.sym_typeof_alias2 =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__typeof__"));
   p.sym_asm_alias = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__asm"));
   p.sym_inline_alias = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__inline"));
   p.sym_inline_alias2 = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__inline__"));
   /* __restrict / __restrict__: GCC keyword spellings of `restrict`. glibc
    * headers use these as real keywords (and #undef any fallback macro under
    * __GNUC__), so recognize them in the parser, not just via a pp macro. */
   p.sym_restrict_alias = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__restrict"));
   p.sym_restrict_alias2 =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__restrict__"));
   p.sym_thread_alias = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__thread"));
   /* GNU alias spellings -> their canonical CKw. Registered after the canonical
    * keywords above so the canonical mapping always wins (matching the old
    * ident_kw_inline fall-through, which scanned kw_sym[] before the aliases).
    */
   (void)KwTab_set(&p.kw_map, p.sym_alignof_alias, (u8)KW_ALIGNOF);
   (void)KwTab_set(&p.kw_map, p.sym_asm_alias, (u8)KW_BUILTIN_ASM);
   (void)KwTab_set(&p.kw_map, p.sym_inline_alias, (u8)KW_INLINE);
   (void)KwTab_set(&p.kw_map, p.sym_inline_alias2, (u8)KW_INLINE);
   (void)KwTab_set(&p.kw_map, p.sym_restrict_alias, (u8)KW_RESTRICT);
   (void)KwTab_set(&p.kw_map, p.sym_restrict_alias2, (u8)KW_RESTRICT);
   (void)KwTab_set(&p.kw_map, p.sym_thread_alias, (u8)KW_THREAD_LOCAL);
   (void)KwTab_set(&p.kw_map, p.sym_volatile_alias, (u8)KW_VOLATILE);
   p.sym_int128 = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__int128"));
   p.sym_int128_t = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__int128_t"));
   p.sym_uint128_t = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__uint128_t"));
   p.sym_a_load_n = kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_load_n"));
   p.sym_a_store_n =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_store_n"));
   p.sym_a_exchange_n =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_exchange_n"));
   p.sym_a_fetch_add =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_fetch_add"));
   p.sym_a_fetch_sub =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_fetch_sub"));
   p.sym_a_fetch_and =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_fetch_and"));
   p.sym_a_fetch_or =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_fetch_or"));
   p.sym_a_fetch_xor =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_fetch_xor"));
   p.sym_a_fetch_nand =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_fetch_nand"));
   p.sym_a_cas_n =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_compare_exchange_n"));
   p.sym_a_always_lock_free =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_always_lock_free"));
   p.sym_a_is_lock_free =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_is_lock_free"));
   p.sym_a_thread_fence =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_thread_fence"));
   p.sym_a_signal_fence =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__atomic_signal_fence"));
   p.sym_sync_synchronize =
       kit_sym_intern(p.pool->c, KIT_SLICE_LIT("__sync_synchronize"));
 
   p.scope = scope_new(&p, NULL);
 
   p.cur = fetch_tok(&p);
 
   parse_translation_unit(&p);
 }