kit

parse_init.c (57470B)

---

 /* parse_init.c — runtime and static-storage initializers.
  *
  * Covers §6.7.9 (initializers):
  *   - Runtime aggregate/scalar initializers (init_at, init_elided,
  *     init_struct_fields, init_string_at, parse_designator_chain,
  *     push_subobject_lv, emit_copy_leaf, emit_walk_copy,
  *     emit_struct_copy_into_slot, zero_init_at)
  *   - Static-storage object definition (parse_static_init_at,
  *     parse_static_string_at, parse_static_const, encode_int_le,
  *     pick_object_section, define_static_object, srl_push)
  */
 
 #include "parse/parse_priv.h"
 
 /* ============================================================
  * File-local helpers
  * ============================================================ */
 
 static SrcLoc tok_loc_init(Parser* p, const Tok* t) {
   return pp_materialize_loc(p->pp, t->loc);
 }
 
 static const Type* init_field_type_at(const Type* ty, u16 i) {
   const Field* f = &ty->rec.fields[i];
   return f->type;
 }
 
 static u32 init_field_offset_at(const ABIRecordLayout* L, u16 i) {
   return L->fields[i].offset;
 }
 
 /* True if `ty` is char/signed char/unsigned char. */
 int is_char_kind(const Type* ty) {
   if (!ty) return 0;
   return ty->kind == TY_CHAR || ty->kind == TY_SCHAR || ty->kind == TY_UCHAR;
 }
 
 /* Decode the string token at p->cur without advancing. Returns a heap-
  * allocated byte buffer (caller frees) and writes length (including NUL)
  * to *nlen_out. */
 static u8* peek_string_bytes(Parser* p, size_t* nlen_out) {
   Tok t = p->cur;
   if (t.kind != TOK_STR) perr(p, "internal: peek_string_bytes on non-string");
   return decode_string_literal(p, &t, nlen_out);
 }
 
 static u64 decode_lit_unit_le(const u8* src, u32 size) {
   u64 v = 0;
   u32 i;
   if (size > 8u) size = 8u;
   for (i = 0; i < size; ++i) v |= (u64)src[i] << (8u * i);
   return v;
 }
 
 /* ============================================================
  * Runtime initializers
  * ============================================================ */
 
 /* Forward declaration for mutual recursion. */
 void init_at(Parser* p, FrameSlot slot, const Type* arr_ty, u32 offset,
              const Type* ty);
 
 typedef struct InitDesignatorCont {
   const Type* parent_ty;
   u32 parent_offset;
   u32 next_index;
 } InitDesignatorCont;
 
 static void init_aggregate_remainder(Parser* p, FrameSlot slot,
                                      const Type* arr_ty, u32 offset,
                                      const Type* ty, u32 start_index);
 
 static void replay_recorded_initializer_expr(Parser* p) {
   if (p->replay_len == 0)
     perr(p, "internal: empty initializer expression replay");
   p->cur = p->replay[0];
   p->replay_pos = 1;
   p->replay_active = 1;
   p->has_next = 0;
 }
 
 static void record_initializer_expr_for_replay(Parser* p) {
   u32 len = 0;
   u32 cap = 0;
   Tok* buf = NULL;
   int paren_depth = 0;
   int brack_depth = 0;
   int brace_depth = 0;
 
   for (;;) {
     if (len == cap) {
       u32 new_cap = cap ? cap * 2u : 16u;
       Tok* nb = arena_array(p->pool->arena, Tok, new_cap);
       if (!nb) perr(p, "out of memory recording initializer expression");
       if (buf && len) memcpy(nb, buf, len * sizeof(*buf));
       buf = nb;
       cap = new_cap;
     }
     buf[len++] = p->cur;
 
     if (p->cur.kind == TOK_EOF) break;
     if (paren_depth == 0 && brack_depth == 0 && brace_depth == 0 &&
         (is_punct(&p->cur, ',') || is_punct(&p->cur, '}'))) {
       break;
     }
 
     if (is_punct(&p->cur, '('))
       ++paren_depth;
     else if (is_punct(&p->cur, ')'))
       --paren_depth;
     else if (is_punct(&p->cur, '['))
       ++brack_depth;
     else if (is_punct(&p->cur, ']'))
       --brack_depth;
     else if (is_punct(&p->cur, '{'))
       ++brace_depth;
     else if (is_punct(&p->cur, '}'))
       --brace_depth;
 
     advance(p);
   }
 
   p->replay = buf;
   p->replay_cap = cap;
   p->replay_len = len;
   replay_recorded_initializer_expr(p);
 }
 
 static int try_init_aggregate_from_expr(Parser* p, FrameSlot slot,
                                         const Type* arr_ty, u32 offset,
                                         const Type* ty) {
   const Type* expr_ty;
   u32 save_depth;
   int compatible;
 
   if (!ty || (ty->kind != TY_STRUCT && ty->kind != TY_UNION)) return 0;
   if (is_punct(&p->cur, '{') || is_punct(&p->cur, '.') ||
       is_punct(&p->cur, '[')) {
     return 0;
   }
 
   record_initializer_expr_for_replay(p);
 
   save_depth = c_cg_stack_depth(p);
   c_cg_codegen_suppress_push(p);
   parse_assign_expr(p);
   expr_ty = c_cg_top_type(p);
   compatible =
       type_compatible(type_unqual(p->pool, ty), type_unqual(p->pool, expr_ty));
   c_cg_drop_to_depth(p, save_depth);
   c_cg_codegen_suppress_pop(p);
 
   replay_recorded_initializer_expr(p);
   if (!compatible) return 0;
 
   parse_assign_expr(p);
   if (!type_compatible(type_unqual(p->pool, ty),
                        type_unqual(p->pool, c_cg_top_type(p)))) {
     perr(p, "incompatible aggregate initializer");
   }
   emit_struct_copy_into_slot(p, slot, arr_ty, offset, ty);
   return 1;
 }
 
 /* Push the lvalue of a sub-object at byte offset `offset` within the array
  * local `slot` (whose type is `arr_ty`), with element type `elem_ty`. */
 void push_subobject_lv(Parser* p, FrameSlot slot, const Type* arr_ty,
                        u32 offset, const Type* elem_ty) {
   c_cg_push_local_typed(p, slot, arr_ty);
   /* Fold the byte offset onto the local lvalue's aux; the next
    * load/store/addr will bake it into the memop's ea.offset. The result is an
    * lvalue of elem_ty backed by the frame slot. */
   c_cg_lv_member(p, (i64)offset, elem_ty, /*bf_off=*/0, /*bf_w=*/0, /*ss=*/0);
 }
 
 void zero_object_bytes_at(Parser* p, FrameSlot slot, const Type* arr_ty,
                           u32 offset, const Type* ty) {
   KitCgMemAccess access = c_cg_mem(p, ty);
   push_subobject_lv(p, slot, arr_ty, offset, ty);
   c_cg_addr(p);
   kit_cg_memset(p->cg, 0, c_abi_sizeof(p->abi, p->pool, ty), access);
 }
 
 static void push_record_field_lv(Parser* p, FrameSlot slot, const Type* arr_ty,
                                  u32 rec_offset, const Type* rec_ty,
                                  u32 field_index) {
   const Field* f = &rec_ty->rec.fields[field_index];
   const ABIRecordLayout* L = c_abi_record_layout(p->abi, p->pool, rec_ty);
   u32 foff = L->fields[field_index].offset;
   u16 bf_off = 0;
   u16 bf_w = 0;
   u32 bf_ss = 0;
   push_subobject_lv(p, slot, arr_ty, rec_offset, rec_ty);
   if (f->flags & FIELD_BITFIELD) {
     bf_off = L->fields[field_index].bit_offset;
     bf_w = L->fields[field_index].bit_width;
     bf_ss = L->fields[field_index].storage_size;
   }
   c_cg_lv_member(p, (i64)foff, f->type, bf_off, bf_w, bf_ss);
 }
 
 /* Emit a load+store for one scalar leaf. */
 static void emit_copy_leaf(Parser* p, FrameSlot dst_slot,
                            const Type* dst_arr_ty, u32 dst_off,
                            FrameSlot src_ptr_slot, const Type* src_ptr_ty,
                            u32 src_off, const Type* leaf_ty) {
   push_subobject_lv(p, dst_slot, dst_arr_ty, dst_off, leaf_ty);
   c_cg_push_local_typed(p, src_ptr_slot, src_ptr_ty);
   c_cg_load(p);
   /* TOS is now a pointer rvalue (the loaded source pointer). Retag as a
    * C-language lvalue with POINTER_RV base, then fold the source byte offset
    * onto its aux. The next c_cg_load consumes the EA into the memop. */
   c_cg_deref(p, leaf_ty);
   c_cg_lv_member(p, (i64)src_off, leaf_ty, 0, 0, 0);
   c_cg_load(p);
   c_cg_store_void(p);
 }
 
 /* Walk a (possibly nested) aggregate, emitting a leaf load+store for each
  * scalar member. */
 static void emit_walk_copy(Parser* p, FrameSlot dst_slot,
                            const Type* dst_arr_ty, u32 dst_off,
                            FrameSlot src_ptr_slot, const Type* src_ptr_ty,
                            u32 src_off, const Type* ty) {
   if (ty->kind == TY_STRUCT) {
     const ABIRecordLayout* L = c_abi_record_layout(p->abi, p->pool, ty);
     for (u16 i = 0; i < ty->rec.nfields; ++i) {
       const Field* f = &ty->rec.fields[i];
       if (f->flags & FIELD_BITFIELD) continue;
       const Type* fty = init_field_type_at(ty, i);
       u32 foff = init_field_offset_at(L, i);
       emit_walk_copy(p, dst_slot, dst_arr_ty, dst_off + foff, src_ptr_slot,
                      src_ptr_ty, src_off + foff, fty);
     }
     return;
   }
   if (ty->kind == TY_ARRAY) {
     u32 esz = c_abi_sizeof(p->abi, p->pool, ty->arr.elem);
     for (u32 i = 0; i < ty->arr.count; ++i) {
       emit_walk_copy(p, dst_slot, dst_arr_ty, dst_off + i * esz, src_ptr_slot,
                      src_ptr_ty, src_off + i * esz, ty->arr.elem);
     }
     return;
   }
   if (ty->kind == TY_UNION) {
     u32 sz = c_abi_sizeof(p->abi, p->pool, ty);
     const Type* uchar_ty = type_prim(p->pool, TY_UCHAR);
     for (u32 i = 0; i < sz; ++i) {
       emit_copy_leaf(p, dst_slot, dst_arr_ty, dst_off + i, src_ptr_slot,
                      src_ptr_ty, src_off + i, uchar_ty);
     }
     return;
   }
   emit_copy_leaf(p, dst_slot, dst_arr_ty, dst_off, src_ptr_slot, src_ptr_ty,
                  src_off, ty);
 }
 
 /* Source struct/union value is on top of the cg stack as an lvalue.
  * Spill its address into a fresh pointer slot, then walk the type and
  * copy each scalar leaf into the destination sub-object. */
 void emit_struct_copy_into_slot(Parser* p, FrameSlot dst_slot,
                                 const Type* dst_arr_ty, u32 dst_off,
                                 const Type* ty) {
   const Type* ptr_ty = type_ptr(p->pool, ty);
   FrameSlotDesc fsd;
   FrameSlot src_ptr_slot;
   c_cg_addr(p);
   memset(&fsd, 0, sizeof fsd);
   fsd.type = ptr_ty;
   fsd.size = c_abi_sizeof(p->abi, p->pool, ptr_ty);
   fsd.align = c_abi_alignof(p->abi, p->pool, ptr_ty);
   fsd.kind = FS_LOCAL;
   fsd.flags = FSF_NONE;
   src_ptr_slot = c_cg_local(p, &fsd);
   c_cg_push_local_typed(p, src_ptr_slot, ptr_ty);
   c_cg_swap(p);
   c_cg_store_void(p);
   emit_walk_copy(p, dst_slot, dst_arr_ty, dst_off, src_ptr_slot, ptr_ty, 0, ty);
 }
 
 /* Recursively zero-initialize the sub-object at `offset` of type `ty`. */
 void zero_init_at(Parser* p, FrameSlot slot, const Type* arr_ty, u32 offset,
                   const Type* ty) {
   if (ty->kind == TY_ARRAY) {
     u32 esz = c_abi_sizeof(p->abi, p->pool, ty->arr.elem);
     for (u32 i = 0; i < ty->arr.count; ++i) {
       zero_init_at(p, slot, arr_ty, offset + i * esz, ty->arr.elem);
     }
     return;
   }
   if (ty->kind == TY_STRUCT) {
     const ABIRecordLayout* L = c_abi_record_layout(p->abi, p->pool, ty);
     for (u16 i = 0; i < ty->rec.nfields; ++i) {
       const Field* f = &ty->rec.fields[i];
       if (f->flags & FIELD_ZERO_WIDTH) continue;
       if (f->flags & FIELD_BITFIELD) {
         push_record_field_lv(p, slot, arr_ty, offset, ty, i);
         c_cg_push_int(p, 0, f->type);
         c_cg_store_void(p);
         continue;
       }
       {
         const Type* fty = init_field_type_at(ty, i);
         u32 foff = init_field_offset_at(L, i);
         zero_init_at(p, slot, arr_ty, offset + foff, fty);
       }
     }
     return;
   }
   if (ty->kind == TY_UNION) {
     if (ty->rec.nfields > 0) {
       const Field* f = &ty->rec.fields[0];
       if (!(f->flags & FIELD_BITFIELD)) {
         zero_init_at(p, slot, arr_ty, offset, f->type);
       }
     }
     return;
   }
   push_subobject_lv(p, slot, arr_ty, offset, ty);
   c_cg_push_int(p, 0, ty);
   c_cg_store_void(p);
 }
 
 static void init_field_at(Parser* p, FrameSlot slot, const Type* arr_ty,
                           u32 rec_offset, const Type* rec_ty, u32 field_index) {
   const ABIRecordLayout* L = c_abi_record_layout(p->abi, p->pool, rec_ty);
   const Field* f = &rec_ty->rec.fields[field_index];
   if (f->flags & FIELD_ZERO_WIDTH) return;
   if (f->flags & FIELD_BITFIELD) {
     push_record_field_lv(p, slot, arr_ty, rec_offset, rec_ty, field_index);
     parse_assign_expr(p);
     to_rvalue(p);
     {
       const Type* rhs = c_cg_top_type(p);
       CSemCheck chk = c_sem_check_assignment(p->pool, f->type, 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);
     return;
   }
   init_at(p, slot, arr_ty, rec_offset + L->fields[field_index].offset, f->type);
 }
 
 /* Emit byte stores for a string literal initializing a char-array sub-object.
  */
 static void init_string_at(Parser* p, FrameSlot slot, const Type* arr_ty,
                            u32 offset, const Type* elem_ty, u32 count) {
   size_t n = 0;
   u8* bytes = peek_string_bytes(p, &n);
   u32 elem_size = c_abi_sizeof(p->abi, p->pool, elem_ty);
   size_t elems = elem_size ? n / elem_size : 0;
   size_t copy = elems;
   size_t i;
   if (copy > count) copy = count;
   for (i = 0; i < copy; ++i) {
     push_subobject_lv(p, slot, arr_ty, offset + (u32)i * elem_size, elem_ty);
     c_cg_push_int(p, (i64)decode_lit_unit_le(bytes + i * elem_size, elem_size),
                   elem_ty);
     c_cg_store_void(p);
   }
   for (; i < count; ++i) {
     push_subobject_lv(p, slot, arr_ty, offset + (u32)i * elem_size, elem_ty);
     c_cg_push_int(p, 0, elem_ty);
     c_cg_store_void(p);
   }
   kit_compiler_context(p->c)->heap->free(kit_compiler_context(p->c)->heap,
                                          bytes, 0);
   advance(p); /* consume TOK_STR */
 }
 
 /* Parse a designator chain (`[const]` and `.ident` repeats) ending at `=`. */
 static void parse_designator_chain(Parser* p, const Type* outer_ty,
                                    u32 outer_offset, const Type** sub_ty_out,
                                    u32* sub_offset_out, u32* top_index_out,
                                    InitDesignatorCont* cont_out) {
   const Type* cur_ty = outer_ty;
   u32 cur_off = outer_offset;
   int first = 1;
   InitDesignatorCont cont;
   memset(&cont, 0, sizeof cont);
   for (;;) {
     if (is_punct(&p->cur, '[')) {
       i64 idx;
       u32 esz;
       SrcLoc cloc = tok_loc_init(p, &p->cur);
       const Type* parent_ty = cur_ty;
       u32 parent_off = cur_off;
       advance(p);
       idx = eval_const_int(p, cloc);
       expect_punct(p, ']', "']' after designator index");
       if (!cur_ty || cur_ty->kind != TY_ARRAY) {
         perr(p, "array designator on non-array");
       }
       if (idx < 0 || (u32)idx >= cur_ty->arr.count) {
         perr(p, "array designator index out of range");
       }
       esz = c_abi_sizeof(p->abi, p->pool, cur_ty->arr.elem);
       cur_off += (u32)idx * esz;
       cur_ty = cur_ty->arr.elem;
       cont.parent_ty = parent_ty;
       cont.parent_offset = parent_off;
       cont.next_index = (u32)idx + 1u;
       if (first) *top_index_out = (u32)idx;
       first = 0;
     } else if (is_punct(&p->cur, '.')) {
       Sym fname;
       const Type* fty;
       u32 foff;
       const Field* ff;
       u16 fi;
       u32 selected_index = 0;
       int have_selected_index = 0;
       const Type* parent_ty = cur_ty;
       u32 parent_off = cur_off;
       advance(p);
       if (p->cur.kind != TOK_IDENT ||
           ident_kw_inline(p, tok_ident(&p->cur)) != KW_NONE) {
         perr(p, "expected field name after '.'");
       }
       fname = tok_ident(&p->cur);
       advance(p);
       if (!cur_ty || (cur_ty->kind != TY_STRUCT && cur_ty->kind != TY_UNION)) {
         perr(p, "field designator on non-record type");
       }
       if (!find_field(p->abi, p->pool, cur_ty, fname, &fty, &foff, &ff)) {
         perr(p, "no such field in designator");
       }
       cur_off += foff;
       for (fi = 0; fi < cur_ty->rec.nfields; ++fi) {
         const Field* g = &cur_ty->rec.fields[fi];
         if (g->name == fname && fname != 0) {
           selected_index = fi;
           have_selected_index = 1;
           if (first) {
             *top_index_out = fi;
           }
           break;
         }
         if ((g->flags & FIELD_ANON) &&
             (g->type->kind == TY_STRUCT || g->type->kind == TY_UNION)) {
           const Type* tmp_ty;
           u32 tmp_off;
           const Field* tmp_f;
           if (find_field(p->abi, p->pool, g->type, fname, &tmp_ty, &tmp_off,
                          &tmp_f)) {
             selected_index = fi;
             have_selected_index = 1;
             if (first) {
               *top_index_out = fi;
             }
             break;
           }
         }
       }
       if (have_selected_index) {
         cont.parent_ty = parent_ty;
         cont.parent_offset = parent_off;
         cont.next_index = selected_index + 1u;
       }
       cur_ty = fty;
       first = 0;
     } else {
       break;
     }
   }
   if (first) perr(p, "internal: empty designator chain");
   expect_punct(p, '=', "'=' after designator");
   *sub_ty_out = cur_ty;
   *sub_offset_out = cur_off;
   if (cont_out) *cont_out = cont;
 }
 
 static int aggregate_has_index(const Type* ty, u32 index) {
   if (!ty) return 0;
   if (ty->kind == TY_ARRAY) return index < ty->arr.count;
   if (ty->kind == TY_STRUCT) return index < ty->rec.nfields;
   return 0;
 }
 
 static int designator_continues_inside(Parser* p, const Type* outer_ty,
                                        u32 outer_offset, const Type* top_ty,
                                        u32 top_offset,
                                        const InitDesignatorCont* cont) {
   u32 top_size;
   if (!cont || !cont->parent_ty) return 0;
   if (cont->parent_ty == outer_ty && cont->parent_offset == outer_offset)
     return 0;
   if (!aggregate_has_index(cont->parent_ty, cont->next_index)) return 0;
   top_size = c_abi_sizeof(p->abi, p->pool, top_ty);
   return cont->parent_offset >= top_offset &&
          cont->parent_offset - top_offset <= top_size;
 }
 
 static u32 init_struct_fields(Parser* p, FrameSlot slot, const Type* arr_ty,
                               u32 offset, const Type* ty, u32 start_field,
                               int braced) {
   const ABIRecordLayout* L = c_abi_record_layout(p->abi, p->pool, ty);
   u32 i = start_field;
   u32 zero_lo = start_field;
   /* A braced list may carry designators that re-target any field, including a
    * field earlier than one already seen, so the running position `i` does not
    * bound the loop — only '}'/EOF (or, for an unbraced nested list, the field
    * count) terminates it. */
   for (;;) {
     if (braced) {
       if (is_punct(&p->cur, '}') || p->cur.kind == TOK_EOF) break;
     } else if (i >= ty->rec.nfields) {
       break;
     }
     if (braced && is_punct(&p->cur, '.')) {
       const Type* sub_ty;
       u32 sub_off;
       u32 top_idx = 0;
       InitDesignatorCont cont;
       parse_designator_chain(p, ty, offset, &sub_ty, &sub_off, &top_idx, &cont);
       while (zero_lo < top_idx) {
         const Field* zf = &ty->rec.fields[zero_lo];
         if (zf->flags & FIELD_BITFIELD) {
           if (!(zf->flags & FIELD_ZERO_WIDTH)) {
             push_record_field_lv(p, slot, arr_ty, offset, ty, zero_lo);
             c_cg_push_int(p, 0, zf->type);
             c_cg_store_void(p);
           }
         } else {
           u32 zoff = offset + L->fields[zero_lo].offset;
           zero_init_at(p, slot, arr_ty, zoff, zf->type);
         }
         ++zero_lo;
       }
       init_at(p, slot, arr_ty, sub_off, sub_ty);
       {
         const Field* top_f = &ty->rec.fields[top_idx];
         u32 top_off = offset + L->fields[top_idx].offset;
         if (designator_continues_inside(p, ty, offset, top_f->type, top_off,
                                         &cont) &&
             accept_punct(p, ',') && !is_punct(&p->cur, '}')) {
           init_aggregate_remainder(p, slot, arr_ty, cont.parent_offset,
                                    cont.parent_ty, cont.next_index);
         }
       }
       i = top_idx;
       if (zero_lo <= top_idx) zero_lo = top_idx + 1;
       goto next_item_struct;
     }
     if (i >= ty->rec.nfields) {
       /* Excess positional initializer with no designator to place it; stop and
        * let the caller diagnose the missing '}'. */
       break;
     }
     init_field_at(p, slot, arr_ty, offset, ty, i);
     if (zero_lo <= i) zero_lo = i + 1;
     if (!braced) {
       ++i;
       break;
     }
   next_item_struct:
     if (!accept_punct(p, ',')) {
       ++i;
       break;
     }
     if (is_punct(&p->cur, '}')) {
       ++i;
       break;
     }
     ++i;
   }
   if (braced) {
     u32 j;
     for (j = zero_lo; j < ty->rec.nfields; ++j) {
       const Field* f = &ty->rec.fields[j];
       if (f->flags & FIELD_BITFIELD) {
         if (!(f->flags & FIELD_ZERO_WIDTH)) {
           push_record_field_lv(p, slot, arr_ty, offset, ty, j);
           c_cg_push_int(p, 0, f->type);
           c_cg_store_void(p);
         }
       } else {
         u32 foff = offset + L->fields[j].offset;
         zero_init_at(p, slot, arr_ty, foff, f->type);
       }
     }
   }
   return i;
 }
 
 static void init_aggregate_remainder(Parser* p, FrameSlot slot,
                                      const Type* arr_ty, u32 offset,
                                      const Type* ty, u32 start_index) {
   if (ty->kind == TY_ARRAY) {
     u32 esz = c_abi_sizeof(p->abi, p->pool, ty->arr.elem);
     u32 i;
     for (i = start_index; i < ty->arr.count; ++i) {
       init_at(p, slot, arr_ty, offset + i * esz, ty->arr.elem);
       if (i + 1u >= ty->arr.count) return;
       if (!accept_punct(p, ',')) break;
       if (is_punct(&p->cur, '}')) break;
     }
     for (++i; i < ty->arr.count; ++i) {
       zero_init_at(p, slot, arr_ty, offset + i * esz, ty->arr.elem);
     }
     return;
   }
   if (ty->kind == TY_STRUCT) {
     const ABIRecordLayout* L = c_abi_record_layout(p->abi, p->pool, ty);
     u32 i;
     for (i = start_index; i < ty->rec.nfields; ++i) {
       init_field_at(p, slot, arr_ty, offset, ty, i);
       if (i + 1u >= ty->rec.nfields) return;
       if (!accept_punct(p, ',')) break;
       if (is_punct(&p->cur, '}')) break;
     }
     for (++i; i < ty->rec.nfields; ++i) {
       const Field* f = &ty->rec.fields[i];
       if (f->flags & FIELD_BITFIELD) {
         if (!(f->flags & FIELD_ZERO_WIDTH)) {
           push_record_field_lv(p, slot, arr_ty, offset, ty, i);
           c_cg_push_int(p, 0, f->type);
           c_cg_store_void(p);
         }
       } else {
         const Type* fty = init_field_type_at(ty, i);
         u32 foff = init_field_offset_at(L, i);
         zero_init_at(p, slot, arr_ty, offset + foff, fty);
       }
     }
     return;
   }
   init_at(p, slot, arr_ty, offset, ty);
 }
 
 void init_at(Parser* p, FrameSlot slot, const Type* arr_ty, u32 offset,
              const Type* ty) {
   if (ty->kind == TY_ARRAY) {
     const Type* elem_ty = ty->arr.elem;
     u32 esz = c_abi_sizeof(p->abi, p->pool, elem_ty);
     if (p->cur.kind == TOK_STR &&
         string_literal_initializes_array(p, elem_ty, &p->cur)) {
       init_string_at(p, slot, arr_ty, offset, elem_ty, ty->arr.count);
       return;
     }
     if (is_punct(&p->cur, '{') && peek1(p).kind == TOK_STR) {
       Tok str = peek1(p);
       if (string_literal_initializes_array(p, elem_ty, &str)) {
         advance(p);
         init_string_at(p, slot, arr_ty, offset, elem_ty, ty->arr.count);
         accept_punct(p, ',');
         expect_punct(p, '}', "'}' after string initializer");
         return;
       }
     }
     if (!is_punct(&p->cur, '{')) {
       init_aggregate_remainder(p, slot, arr_ty, offset, ty, 0);
       return;
     }
     advance(p); /* '{' */
     {
       u32 i = 0;
       u32 zero_lo = 0;
       if (!is_punct(&p->cur, '}')) {
         for (;;) {
           if (is_punct(&p->cur, '[')) {
             const Type* sub_ty;
             u32 sub_off;
             u32 top_idx = 0;
             InitDesignatorCont cont;
             parse_designator_chain(p, ty, offset, &sub_ty, &sub_off, &top_idx,
                                    &cont);
             while (zero_lo < top_idx) {
               zero_init_at(p, slot, arr_ty, offset + zero_lo * esz, elem_ty);
               ++zero_lo;
             }
             init_at(p, slot, arr_ty, sub_off, sub_ty);
             if (designator_continues_inside(p, ty, offset, elem_ty,
                                             offset + top_idx * esz, &cont) &&
                 accept_punct(p, ',') && !is_punct(&p->cur, '}')) {
               init_aggregate_remainder(p, slot, arr_ty, cont.parent_offset,
                                        cont.parent_ty, cont.next_index);
             }
             i = top_idx + 1;
             if (zero_lo < i) zero_lo = i;
           } else {
             if (i >= ty->arr.count) {
               perr(p, "too many initializers for array");
             }
             init_at(p, slot, arr_ty, offset + i * esz, elem_ty);
             ++i;
             if (zero_lo < i) zero_lo = i;
           }
           if (!accept_punct(p, ',')) break;
           if (is_punct(&p->cur, '}')) break;
         }
       }
       expect_punct(p, '}', "'}' after array initializer");
       {
         u32 j;
         for (j = zero_lo; j < ty->arr.count; ++j) {
           zero_init_at(p, slot, arr_ty, offset + j * esz, elem_ty);
         }
       }
     }
     return;
   }
   if (ty->kind == TY_STRUCT) {
     if (!is_punct(&p->cur, '{')) {
       if (try_init_aggregate_from_expr(p, slot, arr_ty, offset, ty)) return;
       init_aggregate_remainder(p, slot, arr_ty, offset, ty, 0);
       return;
     }
     advance(p); /* '{' */
     zero_object_bytes_at(p, slot, arr_ty, offset, ty);
     init_struct_fields(p, slot, arr_ty, offset, ty, 0, /*braced=*/1);
     expect_punct(p, '}', "'}' after struct initializer");
     return;
   }
   if (ty->kind == TY_UNION) {
     int had_brace = accept_punct(p, '{');
     if (!had_brace &&
         try_init_aggregate_from_expr(p, slot, arr_ty, offset, ty)) {
       return;
     }
     if (ty->rec.nfields == 0) {
       if (had_brace) expect_punct(p, '}', "'}'");
       return;
     }
     if (had_brace && is_punct(&p->cur, '.')) {
       const Type* sub_ty;
       u32 sub_off;
       u32 top_idx = 0;
       parse_designator_chain(p, ty, offset, &sub_ty, &sub_off, &top_idx, NULL);
       init_at(p, slot, arr_ty, sub_off, sub_ty);
     } else {
       const Field* f = &ty->rec.fields[0];
       if (!(f->flags & FIELD_BITFIELD)) {
         init_at(p, slot, arr_ty, offset, f->type);
       }
     }
     if (had_brace) {
       accept_punct(p, ',');
       expect_punct(p, '}', "'}' after union initializer");
     }
     return;
   }
   /* Scalar (incl. pointer). */
   int had_brace = accept_punct(p, '{');
   push_subobject_lv(p, slot, arr_ty, offset, ty);
   parse_assign_expr(p);
   to_rvalue(p);
   {
     const Type* rhs = c_cg_top_type(p);
     CSemCheck chk = c_sem_check_assignment(p->pool, 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);
   if (had_brace) {
     accept_punct(p, ',');
     expect_punct(p, '}', "'}' after scalar initializer");
   }
 }
 
 /* ============================================================
  * Static-storage initializers
  * ============================================================ */
 
 void encode_int_le(u8* dst, u32 size, i64 v) {
   for (u32 i = 0; i < size; ++i) {
     dst[i] = (u8)((v >> (8u * i)) & 0xffu);
   }
 }
 
 static u64 decode_uint_le(const u8* src, u32 size) {
   u64 v = 0;
   if (size > 8) size = 8;
   for (u32 i = 0; i < size; ++i) {
     v |= (u64)src[i] << (8u * i);
   }
   return v;
 }
 
 static void encode_uint_le(u8* dst, u32 size, u64 v) {
   if (size > 8) size = 8;
   for (u32 i = 0; i < size; ++i) {
     dst[i] = (u8)((v >> (8u * i)) & 0xffu);
   }
 }
 
 static void encode_uint128_le(u8* dst, u32 size, u64 lo, u64 hi) {
   if (size > 16) size = 16;
   for (u32 i = 0; i < size; ++i) {
     u64 lane = i < 8u ? lo : hi;
     dst[i] = (u8)((lane >> (8u * (i & 7u))) & 0xffu);
   }
 }
 
 static void encode_binary128_from_double_le(u8 out[16], double value) {
   union {
     double d;
     u64 u;
   } in;
   u64 lo = 0;
   u64 hi = 0;
   u64 frac;
   u32 sign;
   u32 exp;
   in.d = value;
   sign = (u32)(in.u >> 63);
   exp = (u32)((in.u >> 52) & 0x7ffu);
   frac = in.u & 0x000fffffffffffffull;
   if (sign) hi |= 1ull << 63;
   if (exp == 0x7ffu) {
     hi |= (u64)0x7fffu << 48;
     if (frac) {
       lo |= (frac & 0xfu) << 60;
       hi |= frac >> 4;
       hi |= 1ull << 47;
     }
   } else if (exp != 0 || frac != 0) {
     i32 e;
     u64 sig;
     if (exp == 0) {
       e = -1022;
       sig = frac;
       while ((sig & (1ull << 52)) == 0) {
         sig <<= 1;
         --e;
       }
       frac = sig & 0x000fffffffffffffull;
     } else {
       e = (i32)exp - 1023;
     }
     hi |= (u64)(u32)(e + 16383) << 48;
     lo |= (frac & 0xfu) << 60;
     hi |= frac >> 4;
   }
   encode_uint128_le(out, 16, lo, hi);
 }
 
 static double parse_static_float_add(Parser* p);
 
 static double parse_static_float_primary(Parser* p) {
   double v;
   if (accept_punct(p, '+')) return parse_static_float_primary(p);
   if (accept_punct(p, '-')) return -parse_static_float_primary(p);
   if (accept_punct(p, '(')) {
     v = parse_static_float_add(p);
     expect_punct(p, ')', "')' in floating constant expression");
     return v;
   }
   if (p->cur.kind == TOK_FLT) {
     v = parse_float_literal(p, &p->cur);
     advance(p);
     return v;
   }
   if (p->cur.kind == TOK_NUM) {
     v = (double)parse_int_literal(p, &p->cur);
     advance(p);
     return v;
   }
   perr(p, "expected floating constant expression");
   return 0.0;
 }
 
 static double parse_static_float_mul(Parser* p) {
   double v = parse_static_float_primary(p);
   for (;;) {
     if (accept_punct(p, '*')) {
       v *= parse_static_float_primary(p);
     } else if (accept_punct(p, '/')) {
       v /= parse_static_float_primary(p);
     } else {
       return v;
     }
   }
 }
 
 static double parse_static_float_add(Parser* p) {
   double v = parse_static_float_mul(p);
   for (;;) {
     if (accept_punct(p, '+')) {
       v += parse_static_float_mul(p);
     } else if (accept_punct(p, '-')) {
       v -= parse_static_float_mul(p);
     } else {
       return v;
     }
   }
 }
 
 static int try_parse_static_float(Parser* p, u8* dst, u32 size,
                                   const Type* ty) {
   const Type* uty = type_unqual(p->pool, ty);
   double value;
   if (!uty || (uty->kind != TY_FLOAT && uty->kind != TY_DOUBLE &&
                uty->kind != TY_LDOUBLE)) {
     return 0;
   }
   value = parse_static_float_add(p);
   if (uty->kind == TY_FLOAT && size == 4u) {
     union {
       float f;
       u8 b[4];
     } u;
     u.f = (float)value;
     memcpy(dst, u.b, 4);
     return 1;
   }
   if ((uty->kind == TY_DOUBLE || uty->kind == TY_LDOUBLE) && size == 8u) {
     union {
       double d;
       u8 b[8];
     } u;
     u.d = value;
     memcpy(dst, u.b, 8);
     return 1;
   }
   if (uty->kind == TY_LDOUBLE && size == 16u) {
     encode_binary128_from_double_le(dst, value);
     return 1;
   }
   perr(p, "unsupported static floating initializer type");
   return 0;
 }
 
 /* Encode a string literal at *buf+offset for a char-array sub-object. */
 static void parse_static_string_at(Parser* p, u8* buf, u32 buflen, u32 offset,
                                    const Type* elem_ty, u32 count) {
   size_t n = 0;
   u8* bytes = peek_string_bytes(p, &n);
   u32 elem_size = c_abi_sizeof(p->abi, p->pool, elem_ty);
   size_t elems = elem_size ? n / elem_size : 0;
   size_t copy = elems;
   size_t copy_bytes;
   if (copy > count) copy = count;
   copy_bytes = copy * elem_size;
   if (offset + (u32)copy_bytes > buflen)
     perr(p, "string initializer overflows object");
   memcpy(buf + offset, bytes, copy_bytes);
   kit_compiler_context(p->c)->heap->free(kit_compiler_context(p->c)->heap,
                                          bytes, 0);
   advance(p);
 }
 
 /* Append one pending relocation to the parser-side list. */
 void srl_push(Parser* p, u32 offset, u32 size, ObjSymId target, i64 addend) {
   if (p->static_relocs_len == p->static_relocs_cap) {
     u32 nc = p->static_relocs_cap ? p->static_relocs_cap * 2u : 4u;
     void* nb = arena_array(p->pool->arena, StaticReloc, nc);
     if (!nb) perr(p, "out of memory recording static relocs");
     if (p->static_relocs && p->static_relocs_len) {
       memcpy(nb, p->static_relocs,
              p->static_relocs_len * sizeof(*p->static_relocs));
     }
     p->static_relocs = nb;
     p->static_relocs_cap = nc;
   }
   p->static_relocs[p->static_relocs_len].offset = offset;
   p->static_relocs[p->static_relocs_len].size = size;
   p->static_relocs[p->static_relocs_len].target = target;
   p->static_relocs[p->static_relocs_len].addend = addend;
   p->static_relocs[p->static_relocs_len].label = 0;
   p->static_relocs[p->static_relocs_len].is_label = 0;
   ++p->static_relocs_len;
 }
 
 /* Append one pending label-address relocation (&&label) to the list. */
 void srl_push_label(Parser* p, u32 offset, u32 size, CGLabel label,
                     i64 addend) {
   srl_push(p, offset, size, 0, addend);
   p->static_relocs[p->static_relocs_len - 1u].label = label;
   p->static_relocs[p->static_relocs_len - 1u].is_label = 1;
 }
 
 typedef enum CStaticConstKind {
   C_STATIC_CONST_INT,
   C_STATIC_CONST_NULL_PTR,
   C_STATIC_CONST_ADDR,
   C_STATIC_CONST_LABEL_ADDR, /* &&label in a static pointer initializer */
 } CStaticConstKind;
 
 typedef struct CStaticConst {
   CStaticConstKind kind;
   CConstInt int_value;
   ObjSymId target;
   i64 addend;
   CGLabel label; /* valid when kind == C_STATIC_CONST_LABEL_ADDR */
 } CStaticConst;
 
 typedef struct StaticRelocSave {
   void* relocs;
   u32 len;
   u32 cap;
 } StaticRelocSave;
 
 static Sym mint_compound_literal_sym(Parser* p) {
   static const char prefix[] = "__kit_compound_literal.";
   char buf[sizeof(prefix) + 12u];
   u32 wlen = 0;
   u32 id = ++p->compound_literal_counter;
   for (u32 i = 0; prefix[i] != 0; ++i) {
     buf[wlen++] = prefix[i];
   }
   {
     char digits[12];
     int dn = 0;
     if (id == 0) digits[dn++] = '0';
     while (id) {
       digits[dn++] = (char)('0' + (id % 10u));
       id /= 10u;
     }
     while (dn) buf[wlen++] = digits[--dn];
   }
   return kit_sym_intern(p->pool->c, (KitSlice){.s = buf, .len = wlen});
 }
 
 static void static_relocs_swap_empty(Parser* p, StaticRelocSave* save) {
   save->relocs = p->static_relocs;
   save->len = p->static_relocs_len;
   save->cap = p->static_relocs_cap;
   p->static_relocs = NULL;
   p->static_relocs_len = 0;
   p->static_relocs_cap = 0;
 }
 
 static void static_relocs_restore(Parser* p, const StaticRelocSave* save) {
   p->static_relocs = save->relocs;
   p->static_relocs_len = save->len;
   p->static_relocs_cap = save->cap;
 }
 
 static ObjSymId define_static_compound_literal(Parser* p, const Type* lit_ty,
                                                SrcLoc loc) {
   Decl decl_in;
   DeclId did;
   ObjSymId sym;
   StaticRelocSave relocs;
 
   if (p->cur_func_name != 0) {
     perr(p, "block-scope compound literal is not a static address constant");
   }
   if (lit_ty && lit_ty->kind == TY_ARRAY && lit_ty->arr.incomplete) {
     lit_ty = complete_incomplete_array(p, lit_ty);
   }
 
   memset(&decl_in, 0, sizeof decl_in);
   decl_in.name = mint_compound_literal_sym(p);
   decl_in.type = lit_ty;
   decl_in.loc = loc;
   decl_in.storage = DS_STATIC;
   decl_in.linkage = DL_INTERNAL;
   decl_in.visibility = SV_DEFAULT;
   did = decl_declare(p->decls, &decl_in);
   sym = decl_obj_sym(p->decls, did);
 
   static_relocs_swap_empty(p, &relocs);
   define_static_object(p, sym, decl_in.section_id, lit_ty,
                        lit_ty ? lit_ty->qual : 0, /*has_init=*/1, loc,
                        decl_in.align);
   static_relocs_restore(p, &relocs);
   return sym;
 }
 
 static CStaticConst parse_static_compound_literal_after_type(Parser* p,
                                                              const Type* lit_ty,
                                                              SrcLoc loc) {
   CStaticConst r;
   memset(&r, 0, sizeof r);
   if (!is_punct(&p->cur, '{')) {
     perr(p, "expected compound literal initializer in static initializer");
   }
   r.kind = C_STATIC_CONST_ADDR;
   r.target = define_static_compound_literal(p, lit_ty, loc);
   r.addend = 0;
   return r;
 }
 
 static CConstInt int_bits_for_type(Parser* p, CConstInt v, const Type* ty) {
   u32 sz = c_abi_sizeof(p->abi, p->pool, ty);
   v.type = ty;
   if (sz < 8u) {
     u32 bits = sz * 8u;
     v.lo &= bits ? ((1ull << bits) - 1ull) : 0;
     v.hi = 0;
   } else if (sz == 8u) {
     v.hi = 0;
   } else if (sz < 16u) {
     u32 hi_bits = sz * 8u - 64u;
     v.hi &= hi_bits ? ((1ull << hi_bits) - 1ull) : 0;
   }
   if (ty && ty->kind == TY_BOOL) {
     v.lo = (v.lo || v.hi) ? 1u : 0u;
     v.hi = 0;
   }
   return v;
 }
 
 static void check_static_integer_initializer_range(Parser* p, const Type* ty,
                                                    CConstInt v) {
   const Type* dst = type_unqual(p->pool, ty);
   u32 bits;
   if (!dst || !type_is_int(dst) || dst->kind == TY_BOOL) return;
   if (dst->kind == TY_CHAR) return;
   if (!type_is_signed_integer(dst)) return;
   bits = c_abi_sizeof(p->abi, p->pool, dst) * 8u;
   if (bits < 64u) {
     i64 minv = -(1ll << (bits - 1u));
     i64 maxv = (1ll << (bits - 1u)) - 1ll;
     if (type_is_signed_integer(v.type)) {
       i64 sv = const_int_as_i64(p, v);
       if (sv < minv || sv > maxv) {
         perr(p, "initializer value overflows destination type");
       }
     } else {
       u64 maxu = (u64)maxv;
       if (v.hi != 0 || v.lo > maxu) {
         perr(p, "initializer value overflows destination type");
       }
     }
   }
 }
 
 static CConstInt parse_null_pointer_constant(Parser* p, SrcLoc loc) {
   if (is_punct(&p->cur, '(')) {
     Tok n = peek1(p);
     if (starts_type_name(p, &n)) {
       const Type* cast_ty;
       const Type* cast_unqual;
       advance(p);
       cast_ty = parse_type_name(p);
       cast_unqual = type_unqual(p->pool, cast_ty);
       expect_punct(p, ')', "')' after cast in null pointer constant");
       if (!cast_unqual ||
           (cast_unqual->kind != TY_PTR && cast_unqual->kind != TY_VOID &&
            !type_is_int(cast_unqual))) {
         perr(p, "invalid cast in null pointer constant");
       }
       return parse_null_pointer_constant(p, loc);
     }
     if (is_punct(&n, '(')) {
       advance(p);
       {
         CConstInt v = parse_null_pointer_constant(p, loc);
         expect_punct(p, ')', "')' in null pointer constant");
         return v;
       }
     }
   }
   return eval_const_int_typed(p, loc);
 }
 
 /* Try to parse the current expression as a static initializer address
  * constant. Leaves non-address expressions untouched. */
 static int try_parse_static_address_const(Parser* p, CStaticConst* out) {
   Tok t = p->cur;
   Sym name = 0;
   int saw_amp = 0;
   i64 element_addend = 0;
   i64 byte_addend = 0;
   SymEntry* e;
   const Type* tgt_ty;
   ObjSymId tgt;
   if (t.kind == TOK_STR) {
     size_t n = 0;
     u8* bytes = decode_string_literal(p, &t, &n);
     const Type* elem_ty = string_literal_elem_type(p, &t);
     ObjSymId str_sym = emit_string_literal_to_rodata(p, bytes, n, elem_ty);
     kit_compiler_context(p->c)->heap->free(kit_compiler_context(p->c)->heap,
                                            bytes, 0);
     advance(p);
     out->kind = C_STATIC_CONST_ADDR;
     out->target = str_sym;
     out->addend = 0;
     return 1;
   }
   if (is_punct(&t, '&')) {
     saw_amp = 1;
     advance(p);
     if (is_punct(&p->cur, '(')) {
       Tok n = peek1(p);
       if (starts_type_name(p, &n)) {
         const Type* lit_ty;
         advance(p);
         lit_ty = parse_type_name(p);
         expect_punct(p, ')', "')' after compound literal type-name");
         *out = parse_static_compound_literal_after_type(
             p, lit_ty, pp_materialize_loc(p->pp, t.loc));
         return 1;
       }
     }
     if (p->cur.kind != TOK_IDENT ||
         ident_kw_inline(p, tok_ident(&p->cur)) != KW_NONE) {
       perr(p, "expected identifier after '&' in static initializer");
     }
     name = tok_ident(&p->cur);
     advance(p);
   } else if (t.kind == TOK_IDENT &&
              ident_kw_inline(p, tok_ident(&t)) == KW_NONE) {
     name = tok_ident(&t);
     advance(p);
   } else {
     return 0;
   }
   e = scope_lookup(p, name);
   if (!e || (e->kind != SEK_GLOBAL && e->kind != SEK_FUNC)) {
     perr(p, "static initializer is not a constant address expression");
   }
   tgt = e->v.sym;
   tgt_ty = e->type;
   if (saw_amp && is_punct(&p->cur, '[')) {
     SrcLoc cloc;
     advance(p);
     cloc = tok_loc_init(p, &p->cur);
     element_addend = eval_const_int(p, cloc);
     expect_punct(p, ']', "']' after array-subscript constant");
     if (tgt_ty && tgt_ty->kind == TY_ARRAY) {
       byte_addend +=
           element_addend * (i64)c_abi_sizeof(p->abi, p->pool, tgt_ty->arr.elem);
     } else {
       byte_addend += element_addend;
     }
   }
   while (is_punct(&p->cur, '+') || is_punct(&p->cur, '-')) {
     int neg = is_punct(&p->cur, '-');
     SrcLoc cloc;
     i64 v;
     advance(p);
     cloc = tok_loc_init(p, &p->cur);
     v = eval_const_int(p, cloc);
     if (neg) v = -v;
     if (tgt_ty && tgt_ty->kind == TY_ARRAY) {
       byte_addend += v * (i64)c_abi_sizeof(p->abi, p->pool, tgt_ty->arr.elem);
     } else if (tgt_ty && tgt_ty->kind == TY_PTR) {
       byte_addend +=
           v * (i64)c_abi_sizeof(p->abi, p->pool, tgt_ty->ptr.pointee);
     } else if (saw_amp) {
       byte_addend += v * (i64)c_abi_sizeof(p->abi, p->pool, tgt_ty);
     } else {
       byte_addend += v;
     }
   }
   out->kind = C_STATIC_CONST_ADDR;
   out->target = tgt;
   out->addend = byte_addend;
   return 1;
 }
 
 static CStaticConst parse_static_const(Parser* p, const Type* ty, SrcLoc loc) {
   CStaticConst r;
   memset(&r, 0, sizeof r);
   r.kind = C_STATIC_CONST_INT;
   if (ty && ty->kind == TY_PTR) {
     if (is_punct(&p->cur, P_AND)) {
       /* GNU labels-as-values: `&&label` in a static pointer initializer,
        * e.g. a direct-threaded dispatch table `static void *tab[] = {...}`. */
       Sym lname;
       SrcLoc lloc;
       advance(p); /* '&&' */
       if (p->cur.kind != TOK_IDENT ||
           ident_kw_inline(p, tok_ident(&p->cur)) != KW_NONE) {
         perr(p, "expected label name after '&&' in static initializer");
       }
       lname = tok_ident(&p->cur);
       lloc = tok_loc_init(p, &p->cur);
       advance(p);
       r.kind = C_STATIC_CONST_LABEL_ADDR;
       r.label = take_label_addr(p, lname, lloc);
       r.addend = 0;
       return r;
     }
     if (is_punct(&p->cur, '(')) {
       Tok n = peek1(p);
       /* Grouping parens around the pointer initializer, e.g. `("str")`,
        * `(&x)`, or `((expr))`. A `(type-name)` is a cast or compound literal
        * and is handled below, so peel only when the inner token does not start
        * a type-name. */
       if (!starts_type_name(p, &n)) {
         advance(p);
         r = parse_static_const(p, ty, loc);
         expect_punct(p, ')', "')' in static pointer initializer");
         return r;
       }
     }
     if (is_punct(&p->cur, '(')) {
       Tok n = peek1(p);
       if (starts_type_name(p, &n)) {
         const Type* cast_ty;
         const Type* cast_unqual;
         advance(p);
         cast_ty = parse_type_name(p);
         cast_unqual = type_unqual(p->pool, cast_ty);
         expect_punct(p, ')', "')' after cast or compound literal type-name");
         if (is_punct(&p->cur, '{')) {
           const Type* lit_unqual = type_unqual(p->pool, cast_ty);
           if (!lit_unqual || lit_unqual->kind != TY_ARRAY) {
             perr(p,
                  "non-array compound literal needs '&' in pointer initializer");
           }
           return parse_static_compound_literal_after_type(p, cast_ty, loc);
         }
         if (!cast_unqual ||
             (cast_unqual->kind != TY_PTR && cast_unqual->kind != TY_VOID &&
              !type_is_int(cast_unqual))) {
           perr(p, "invalid cast in null pointer constant");
         }
         if (cast_unqual->kind == TY_PTR &&
             (p->cur.kind == TOK_STR || is_punct(&p->cur, '&') ||
              (p->cur.kind == TOK_IDENT &&
               ident_kw_inline(p, tok_ident(&p->cur)) == KW_NONE)) &&
             try_parse_static_address_const(p, &r)) {
           return r;
         }
         r.int_value = parse_null_pointer_constant(p, loc);
         if (const_int_as_i64(p, r.int_value) != 0 &&
             cast_unqual->kind == TY_PTR) {
           r.kind = C_STATIC_CONST_INT;
           return r;
         }
         if (const_int_as_i64(p, r.int_value) != 0) {
           perr(p, "static pointer initializer is not a null pointer constant");
         }
         r.kind = C_STATIC_CONST_NULL_PTR;
         return r;
       }
     }
     if (try_parse_static_address_const(p, &r)) return r;
     r.int_value = parse_null_pointer_constant(p, loc);
     if (const_int_as_i64(p, r.int_value) != 0) {
       perr(p, "static pointer initializer is not a null pointer constant");
     }
     r.kind = C_STATIC_CONST_NULL_PTR;
     return r;
   }
   r.int_value = eval_const_int_typed(p, loc);
   check_static_integer_initializer_range(p, ty, r.int_value);
   return r;
 }
 
 static void parse_static_bitfield_at(Parser* p, u8* buf, u32 buflen,
                                      u32 rec_offset, const ABIFieldLayout* fl,
                                      const Type* field_ty) {
   SrcLoc cloc = tok_loc_init(p, &p->cur);
   CStaticConst parsed = parse_static_const(p, field_ty, cloc);
   u32 storage_off = rec_offset + fl->offset;
   u32 storage_size = fl->storage_size;
   u32 width = fl->bit_width;
   u32 lsb = fl->bit_offset;
   u64 ones;
   u64 mask;
   u64 cur;
   u64 val;
   if (parsed.kind != C_STATIC_CONST_INT) {
     perr(p, "bit-field initializer requires integer constant expression");
   }
   if (width == 0) return;
   if (storage_size > 8) perr(p, "bit-field storage unit too wide");
   if (storage_off > buflen || storage_size > buflen - storage_off)
     perr(p, "initializer overflows object");
   ones = width >= 64u ? ~(u64)0 : (((u64)1 << width) - 1u);
   mask = ones << lsb;
   cur = decode_uint_le(buf + storage_off, storage_size);
   val = (int_bits_for_type(p, parsed.int_value, field_ty).lo & ones) << lsb;
   cur = (cur & ~mask) | val;
   encode_uint_le(buf + storage_off, storage_size, cur);
 }
 
 static void parse_static_aggregate_remainder(Parser* p, u8* buf, u32 buflen,
                                              u32 offset, const Type* ty,
                                              u32 start_index) {
   if (ty->kind == TY_ARRAY) {
     const Type* elem = ty->arr.elem;
     u32 esz = c_abi_sizeof(p->abi, p->pool, elem);
     u32 i;
     for (i = start_index; i < ty->arr.count; ++i) {
       parse_static_init_at(p, buf, buflen, offset + i * esz, elem);
       if (i + 1u >= ty->arr.count) return;
       if (!accept_punct(p, ',')) break;
       if (is_punct(&p->cur, '}')) break;
     }
     return;
   }
   if (ty->kind == TY_STRUCT) {
     const ABIRecordLayout* L = c_abi_record_layout(p->abi, p->pool, ty);
     u32 i;
     for (i = start_index; i < ty->rec.nfields; ++i) {
       const Field* f = &ty->rec.fields[i];
       if (f->flags & FIELD_BITFIELD) {
         if (!(f->flags & FIELD_ZERO_WIDTH)) {
           parse_static_bitfield_at(p, buf, buflen, offset, &L->fields[i],
                                    f->type);
         }
       } else {
         const Type* fty = init_field_type_at(ty, i);
         u32 foff = init_field_offset_at(L, i);
         parse_static_init_at(p, buf, buflen, offset + foff, fty);
       }
       if (i + 1u >= ty->rec.nfields) return;
       if (!accept_punct(p, ',')) break;
       if (is_punct(&p->cur, '}')) break;
     }
     return;
   }
   parse_static_init_at(p, buf, buflen, offset, ty);
 }
 
 void parse_static_init_at(Parser* p, u8* buf, u32 buflen, u32 offset,
                           const Type* ty) {
   /* An aggregate object may be initialized by a (possibly parenthesized)
    * compound literal of its own type: `static T x = (T){...};` or, after macro
    * expansion, `static T x = ((T){...});`. Strip the `(type-name)` cast so the
    * brace body below initializes the object in place; peel grouping parens by
    * recursing and matching the closing ')'. Pointer/scalar targets keep their
    * own handling (parse_static_const / eval_const), where a compound literal
    * can instead yield an address or value. */
   if ((ty->kind == TY_STRUCT || ty->kind == TY_UNION || ty->kind == TY_ARRAY) &&
       is_punct(&p->cur, '(')) {
     Tok n = peek1(p);
     if (starts_type_name(p, &n)) {
       advance(p);
       parse_type_name(p);
       expect_punct(p, ')', "')' after compound literal type-name");
     } else if (is_punct(&n, '(')) {
       advance(p);
       parse_static_init_at(p, buf, buflen, offset, ty);
       expect_punct(p, ')', "')' after parenthesized initializer");
       return;
     }
   }
   if (ty->kind == TY_ARRAY) {
     const Type* elem = ty->arr.elem;
     u32 esz = c_abi_sizeof(p->abi, p->pool, elem);
     u32 i = 0;
     int had_brace;
     if (p->cur.kind == TOK_STR &&
         string_literal_initializes_array(p, elem, &p->cur)) {
       parse_static_string_at(p, buf, buflen, offset, elem, ty->arr.count);
       return;
     }
     if (is_punct(&p->cur, '{') && peek1(p).kind == TOK_STR) {
       Tok str = peek1(p);
       if (string_literal_initializes_array(p, elem, &str)) {
         advance(p);
         parse_static_string_at(p, buf, buflen, offset, elem, ty->arr.count);
         accept_punct(p, ',');
         expect_punct(p, '}', "'}' after string initializer");
         return;
       }
     }
     had_brace = accept_punct(p, '{');
     if (!had_brace) {
       parse_static_aggregate_remainder(p, buf, buflen, offset, ty, 0);
       return;
     }
     if (!is_punct(&p->cur, '}')) {
       for (;;) {
         if (is_punct(&p->cur, '[')) {
           const Type* sub_ty;
           u32 sub_off;
           u32 top_idx = 0;
           InitDesignatorCont cont;
           parse_designator_chain(p, ty, offset, &sub_ty, &sub_off, &top_idx,
                                  &cont);
           parse_static_init_at(p, buf, buflen, sub_off, sub_ty);
           if (designator_continues_inside(p, ty, offset, elem,
                                           offset + top_idx * esz, &cont) &&
               accept_punct(p, ',') && !is_punct(&p->cur, '}')) {
             parse_static_aggregate_remainder(p, buf, buflen, cont.parent_offset,
                                              cont.parent_ty, cont.next_index);
           }
           i = top_idx + 1;
         } else {
           if (i >= ty->arr.count) {
             perr(p, "too many initializers for array");
           }
           parse_static_init_at(p, buf, buflen, offset + i * esz, elem);
           ++i;
         }
         if (!accept_punct(p, ',')) break;
         if (is_punct(&p->cur, '}')) break;
       }
     }
     expect_punct(p, '}', "'}' after array initializer");
     return;
   }
   if (ty->kind == TY_STRUCT) {
     int had_brace = accept_punct(p, '{');
     const ABIRecordLayout* L = c_abi_record_layout(p->abi, p->pool, ty);
     u32 i = 0;
     if (!had_brace) {
       parse_static_aggregate_remainder(p, buf, buflen, offset, ty, 0);
       return;
     }
     /* Designators may re-target any field regardless of the running position
      * `i`, so the loop is bounded by '}'/EOF; `i` only drives positional
      * placement (and is range-checked before use). */
     while (!is_punct(&p->cur, '}') && p->cur.kind != TOK_EOF) {
       const Field* f;
       if (is_punct(&p->cur, '.')) {
         const Type* sub_ty;
         u32 sub_off;
         u32 top_idx = 0;
         InitDesignatorCont cont;
         parse_designator_chain(p, ty, offset, &sub_ty, &sub_off, &top_idx,
                                &cont);
         parse_static_init_at(p, buf, buflen, sub_off, sub_ty);
         {
           const Field* top_f = &ty->rec.fields[top_idx];
           u32 top_off = offset + L->fields[top_idx].offset;
           if (designator_continues_inside(p, ty, offset, top_f->type, top_off,
                                           &cont) &&
               accept_punct(p, ',') && !is_punct(&p->cur, '}')) {
             parse_static_aggregate_remainder(p, buf, buflen, cont.parent_offset,
                                              cont.parent_ty, cont.next_index);
           }
         }
         i = top_idx + 1;
         if (!accept_punct(p, ',')) break;
         continue;
       }
       if (i >= ty->rec.nfields) break; /* excess positional initializer */
       f = &ty->rec.fields[i];
       if (f->flags & FIELD_BITFIELD) {
         if (!(f->flags & FIELD_ZERO_WIDTH)) {
           parse_static_bitfield_at(p, buf, buflen, offset, &L->fields[i],
                                    f->type);
         }
       } else {
         const Type* fty = init_field_type_at(ty, i);
         u32 foff = init_field_offset_at(L, i);
         parse_static_init_at(p, buf, buflen, offset + foff, fty);
       }
       ++i;
       if (!accept_punct(p, ',')) break;
     }
     expect_punct(p, '}', "'}' after struct initializer");
     return;
   }
   if (ty->kind == TY_UNION) {
     int had_brace = accept_punct(p, '{');
     if (ty->rec.nfields == 0) {
       if (had_brace) expect_punct(p, '}', "'}' after union initializer");
       return;
     }
     if (had_brace && is_punct(&p->cur, '.')) {
       const Type* sub_ty;
       u32 sub_off;
       u32 top_idx = 0;
       parse_designator_chain(p, ty, offset, &sub_ty, &sub_off, &top_idx, NULL);
       (void)top_idx;
       parse_static_init_at(p, buf, buflen, sub_off, sub_ty);
     } else {
       const Field* f = &ty->rec.fields[0];
       if (!(f->flags & FIELD_BITFIELD)) {
         parse_static_init_at(p, buf, buflen, offset, f->type);
       } else if (!(f->flags & FIELD_ZERO_WIDTH)) {
         const ABIRecordLayout* L = c_abi_record_layout(p->abi, p->pool, ty);
         parse_static_bitfield_at(p, buf, buflen, offset, &L->fields[0],
                                  f->type);
       }
     }
     if (had_brace) {
       accept_punct(p, ',');
       expect_punct(p, '}', "'}' after union initializer");
     }
     return;
   }
   /* Scalar / pointer. */
   {
     int had_brace = accept_punct(p, '{');
     SrcLoc cloc = tok_loc_init(p, &p->cur);
     u32 sz = c_abi_sizeof(p->abi, p->pool, ty);
     CStaticConst cv;
     if (offset + sz > buflen) perr(p, "initializer overflows object");
     if (try_parse_static_float(p, buf + offset, sz, ty)) {
       if (had_brace) {
         accept_punct(p, ',');
         expect_punct(p, '}', "'}' after scalar initializer");
       }
       return;
     }
     cv = parse_static_const(p, ty, cloc);
     if (cv.kind == C_STATIC_CONST_ADDR) {
       srl_push(p, offset, sz, cv.target, cv.addend);
     } else if (cv.kind == C_STATIC_CONST_LABEL_ADDR) {
       srl_push_label(p, offset, sz, cv.label, cv.addend);
     } else if (cv.kind == C_STATIC_CONST_NULL_PTR) {
       encode_int_le(buf + offset, sz, 0);
     } else {
       {
         CConstInt bits = int_bits_for_type(p, cv.int_value, ty);
         encode_uint128_le(buf + offset, sz, bits.lo, bits.hi);
       }
     }
     if (had_brace) {
       accept_punct(p, ',');
       expect_punct(p, '}', "'}' after scalar initializer");
     }
   }
 }
 
 static void emit_static_data(Parser* p, const u8* buf, u32 size) {
   u32 pos = 0;
   u32 emitted_relocs = 0;
 
   while (emitted_relocs < p->static_relocs_len) {
     u32 best = p->static_relocs_len;
     u32 best_off = 0xffffffffu;
     for (u32 i = 0; i < p->static_relocs_len; ++i) {
       if (p->static_relocs[i].offset < pos) continue;
       if (p->static_relocs[i].offset < best_off) {
         best = i;
         best_off = p->static_relocs[i].offset;
       }
     }
     if (best == p->static_relocs_len) break;
     if (best_off > size || p->static_relocs[best].size > size - best_off) {
       perr(p, "static initializer relocation overflows object");
     }
     if (best_off > pos) {
       if (buf) {
         kit_cg_data_bytes(p->cg, buf + pos, best_off - pos);
       } else {
         kit_cg_data_zero(p->cg, best_off - pos);
       }
     }
     if (p->static_relocs[best].is_label) {
       kit_cg_data_label_addr(p->cg, p->static_relocs[best].label,
                              p->static_relocs[best].addend,
                              p->static_relocs[best].size, 0);
     } else {
       kit_cg_data_addr(p->cg, p->static_relocs[best].target,
                        p->static_relocs[best].addend,
                        p->static_relocs[best].size, 0);
     }
     pos = best_off + p->static_relocs[best].size;
     ++emitted_relocs;
   }
 
   if (pos < size) {
     if (buf) {
       kit_cg_data_bytes(p->cg, buf + pos, size - pos);
     } else {
       kit_cg_data_zero(p->cg, size - pos);
     }
   }
 }
 
 /* Define a static-storage object. */
 void define_static_object(Parser* p, ObjSymId sym, ObjSecId section_id,
                           const Type* var_ty, u16 quals, int has_init,
                           SrcLoc loc, u32 align_override) {
   u32 size = c_abi_sizeof(p->abi, p->pool, var_ty);
   u32 align = c_abi_alignof(p->abi, p->pool, var_ty);
   KitCgDataDefAttrs attrs;
   if (align_override > align) align = align_override;
   u8* buf = NULL;
   int has_nonzero = 0;
   int has_label_reloc = 0;
 
   if (has_init) {
     buf = (u8*)arena_array(p->pool->arena, u8, size ? size : 1u);
     memset(buf, 0, size);
     p->static_relocs_len = 0;
     parse_static_init_at(p, buf, size, 0, var_ty);
     for (u32 i = 0; i < size; ++i) {
       if (buf[i]) {
         has_nonzero = 1;
         break;
       }
     }
     if (p->static_relocs_len) has_nonzero = 1;
     for (u32 i = 0; i < p->static_relocs_len; ++i) {
       if (p->static_relocs[i].is_label) {
         has_label_reloc = 1;
         break;
       }
     }
   }
 
   memset(&attrs, 0, sizeof attrs);
   attrs.section = section_id;
   attrs.align = align ? align : 1u;
   /* Label-address relocations (&&label) are tied to the enclosing function's
    * label namespace, so the table must be emitted as function-local static
    * data while that function is still open. */
   if (has_label_reloc) {
     attrs.flags |= KIT_CG_DATADEF_FUNCTION_LOCAL;
   }
   if ((quals & Q_CONST) != 0 && has_nonzero) {
     attrs.flags |= KIT_CG_DATADEF_READONLY;
   }
   if (!has_init || !has_nonzero) {
     attrs.flags |= KIT_CG_DATADEF_ZERO_FILL;
   }
 
   kit_cg_data_begin(p->cg, sym, attrs);
   emit_static_data(p, (attrs.flags & KIT_CG_DATADEF_ZERO_FILL) ? NULL : buf,
                    size);
   kit_cg_data_end(p->cg);
   p->static_relocs_len = 0;
   (void)loc;
 }