kit

parse_expr.c (123669B)

---

 /* parse_expr.c — precedence climbing, unary/primary, literal decoding,
  * constant evaluation. */
 
 #include "parse/literal_unicode.h"
 #include "parse/parse_priv.h"
 
 static const Type* ty_int(Parser* p) { return type_prim(p->pool, TY_INT); }
 static const Type* ty_size_t(Parser* p) {
   return c_abi_size_type(p->abi, p->pool);
 }
 static int type_is_fp(const Type* t);
 static int cg_const_is_zero(KitCgConstInt v);
 
 static int type_is_incomplete(const Type* t) {
   if (!t) return 1;
   if (t->kind == TY_VOID) return 1;
   if ((t->kind == TY_STRUCT || t->kind == TY_UNION) && t->rec.incomplete)
     return 1;
   if (t->kind == TY_ARRAY && t->arr.incomplete) return 1;
   return 0;
 }
 
 static void require_sizeof_type(Parser* p, const Type* ty) {
   if (!ty || type_is_incomplete(ty) || ty->kind == TY_FUNC) {
     perr(p, "sizeof operand has incomplete or function type");
   }
 }
 
 static int type_is_void_ptr(const Type* ty) {
   return ty && ty->kind == TY_PTR && ty->ptr.pointee &&
          ty->ptr.pointee->kind == TY_VOID;
 }
 
 static const Type* ty_char16(Parser* p) {
   return type_prim(p->pool, TY_USHORT);
 }
 
 static const Type* ty_char32(Parser* p) { return type_prim(p->pool, TY_UINT); }
 
 static const Type* ty_wchar(Parser* p) {
   /* sizeof(wchar_t) is a resolved data-model fact (2 on Windows, 4 else);
    * key on the width rather than re-deriving from the OS identity. */
   KitTargetSpec target = kit_compiler_target_spec(p->c);
   return target.wchar_size == 2 ? ty_char16(p) : ty_int(p);
 }
 
 static int pointer_pointees_compatible(Parser* p, const Type* lhs,
                                        const Type* rhs) {
   const Type* lp;
   const Type* rp;
   if (!lhs || !rhs || lhs->kind != TY_PTR || rhs->kind != TY_PTR) return 0;
   lp = lhs->ptr.pointee;
   rp = rhs->ptr.pointee;
   if (!lp || !rp) return 0;
   return type_compatible(type_unqual(p->pool, lp), type_unqual(p->pool, rp));
 }
 
 static int null_pointer_constant(Parser* p, const Type* ty) {
   KitCgConstInt v;
   return type_is_int(ty) &&
          (c_cg_top_is_null_ptr_const(p) ||
           (kit_cg_top_const_int_ex(p->cg, &v) && cg_const_is_zero(v)));
 }
 
 static void require_scalar(Parser* p, const Type* ty, const char* what) {
   if (!c_type_is_scalar(ty))
     perr(p, "%.*s requires scalar operand",
          KIT_SLICE_ARG(kit_slice_cstr(what)));
 }
 
 static void require_arith(Parser* p, const Type* ty, const char* what) {
   if (!type_is_arith(ty))
     perr(p, "%.*s requires arithmetic operand",
          KIT_SLICE_ARG(kit_slice_cstr(what)));
 }
 
 static const Type* conditional_pointer_type(Parser* p, const Type* then_ty,
                                             int then_null, const Type* else_ty,
                                             int else_null) {
   if (then_ty && then_ty->kind == TY_PTR && else_null) return then_ty;
   if (else_ty && else_ty->kind == TY_PTR && then_null) return else_ty;
   if (!then_ty || !else_ty || then_ty->kind != TY_PTR ||
       else_ty->kind != TY_PTR)
     return NULL;
   if (type_is_void_ptr(then_ty)) return then_ty;
   if (type_is_void_ptr(else_ty)) return else_ty;
   if (pointer_pointees_compatible(p, then_ty, else_ty)) return then_ty;
   return NULL;
 }
 
 /* ============================================================
  * Literal parsing
  * ============================================================ */
 
 static u32 integer_type_bits(Parser* p, const Type* ty);
 static int integer_type_signed(Parser* p, const Type* ty);
 
 static u64 parse_int_literal_u64(Parser* p, const Tok* t, int* decimal_out) {
   KitSlice spell_sl = pp_text_slice(p->pp, t);
   size_t len = spell_sl.len;
   const char* s = spell_sl.s;
   size_t i = 0;
   u64 base = 10;
   u64 acc = 0;
   int decimal = 1;
   if (!s) perr(p, "bad numeric literal");
   if (len >= 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
     base = 16;
     decimal = 0;
     i = 2;
   } else if (len >= 2 && s[0] == '0' && (s[1] == 'b' || s[1] == 'B')) {
     base = 2;
     decimal = 0;
     i = 2;
   } else if (len >= 1 && s[0] == '0') {
     base = 8;
     decimal = 0;
     i = 1;
   }
   for (; i < len; ++i) {
     int c = (unsigned char)s[i];
     int dv;
     if (c == 'u' || c == 'U' || c == 'l' || c == 'L') break;
     if (c >= '0' && c <= '9')
       dv = c - '0';
     else if (c >= 'a' && c <= 'f')
       dv = c - 'a' + 10;
     else if (c >= 'A' && c <= 'F')
       dv = c - 'A' + 10;
     else
       perr(p, "bad digit in numeric literal");
     if ((u64)dv >= base) perr(p, "digit out of range for base");
     if (acc > (~0ull - (u64)dv) / base) perr(p, "integer literal too large");
     acc = acc * base + dv;
   }
   if (decimal_out) *decimal_out = decimal;
   return acc;
 }
 
 static int uint_fits_type(Parser* p, u64 v, const Type* ty) {
   u32 nb = integer_type_bits(p, ty);
   if (integer_type_signed(p, ty)) {
     if (nb >= 64) return v <= 0x7fffffffffffffffull;
     return v <= ((1ull << (nb - 1u)) - 1ull);
   }
   if (nb >= 64) return 1;
   return v <= ((1ull << nb) - 1ull);
 }
 
 static const Type* first_fitting_type(Parser* p, u64 v, const TypeKind* kinds,
                                       u32 nkinds) {
   u32 i;
   for (i = 0; i < nkinds; ++i) {
     const Type* ty = type_prim(p->pool, kinds[i]);
     if (uint_fits_type(p, v, ty)) return ty;
   }
   perr(p, "integer literal too large for supported integer types");
 }
 
 i64 parse_int_literal(Parser* p, const Tok* t) {
   return (i64)parse_int_literal_u64(p, t, NULL);
 }
 
 static const Type* int_literal_type(Parser* p, const Tok* t) {
   int u = (t->flags & TF_INT_U) != 0;
   int l = (t->flags & TF_INT_L) != 0;
   int ll = (t->flags & TF_INT_LL) != 0;
   int decimal = 1;
   u64 v = parse_int_literal_u64(p, t, &decimal);
   if (u && ll) {
     static const TypeKind order[] = {TY_ULLONG};
     return first_fitting_type(p, v, order,
                               (u32)(sizeof order / sizeof order[0]));
   }
   if (!u && ll) {
     static const TypeKind dec_order[] = {TY_LLONG};
     static const TypeKind other_order[] = {TY_LLONG, TY_ULLONG};
     return decimal ? first_fitting_type(
                          p, v, dec_order,
                          (u32)(sizeof dec_order / sizeof dec_order[0]))
                    : first_fitting_type(
                          p, v, other_order,
                          (u32)(sizeof other_order / sizeof other_order[0]));
   }
   if (u && l) {
     static const TypeKind order[] = {TY_ULONG, TY_ULLONG};
     return first_fitting_type(p, v, order,
                               (u32)(sizeof order / sizeof order[0]));
   }
   if (!u && l) {
     static const TypeKind dec_order[] = {TY_LONG, TY_LLONG};
     static const TypeKind other_order[] = {TY_LONG, TY_ULONG, TY_LLONG,
                                            TY_ULLONG};
     return decimal ? first_fitting_type(
                          p, v, dec_order,
                          (u32)(sizeof dec_order / sizeof dec_order[0]))
                    : first_fitting_type(
                          p, v, other_order,
                          (u32)(sizeof other_order / sizeof other_order[0]));
   }
   if (u) {
     static const TypeKind order[] = {TY_UINT, TY_ULONG, TY_ULLONG};
     return first_fitting_type(p, v, order,
                               (u32)(sizeof order / sizeof order[0]));
   }
   if (decimal) {
     static const TypeKind order[] = {TY_INT, TY_LONG, TY_LLONG};
     return first_fitting_type(p, v, order,
                               (u32)(sizeof order / sizeof order[0]));
   } else {
     static const TypeKind order[] = {TY_INT,   TY_UINT,  TY_LONG,
                                      TY_ULONG, TY_LLONG, TY_ULLONG};
     return first_fitting_type(p, v, order,
                               (u32)(sizeof order / sizeof order[0]));
   }
 }
 
 double parse_float_literal(Parser* p, const Tok* t) {
   KitSlice spell_sl = pp_text_slice(p->pp, t);
   size_t len = spell_sl.len;
   const char* s = spell_sl.s;
   size_t i = 0;
   int is_hex = 0;
   double v = 0.0;
   int exp = 0;
   int dec_exp = 0;
   int frac_seen = 0;
   if (!s) perr(p, "bad float literal");
   if (len >= 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
     is_hex = 1;
     i = 2;
   }
   while (i < len) {
     int c = (unsigned char)s[i];
     int dv;
     if (c == '.' || c == 'e' || c == 'E' || c == 'p' || c == 'P' || c == 'f' ||
         c == 'F' || c == 'l' || c == 'L')
       break;
     if (c >= '0' && c <= '9')
       dv = c - '0';
     else if (is_hex && c >= 'a' && c <= 'f')
       dv = c - 'a' + 10;
     else if (is_hex && c >= 'A' && c <= 'F')
       dv = c - 'A' + 10;
     else
       perr(p, "bad digit in float literal");
     v = v * (is_hex ? 16.0 : 10.0) + (double)dv;
     i++;
   }
   if (i < len && s[i] == '.') {
     i++;
     while (i < len) {
       int c = (unsigned char)s[i];
       int dv;
       if (c == 'e' || c == 'E' || c == 'p' || c == 'P' || c == 'f' ||
           c == 'F' || c == 'l' || c == 'L')
         break;
       if (c >= '0' && c <= '9')
         dv = c - '0';
       else if (is_hex && c >= 'a' && c <= 'f')
         dv = c - 'a' + 10;
       else if (is_hex && c >= 'A' && c <= 'F')
         dv = c - 'A' + 10;
       else
         perr(p, "bad digit in float literal");
       v = v * (is_hex ? 16.0 : 10.0) + (double)dv;
       exp -= 1;
       frac_seen = 1;
       i++;
     }
   }
   (void)frac_seen;
   if (i < len && (s[i] == 'e' || s[i] == 'E' || s[i] == 'p' || s[i] == 'P')) {
     int neg = 0;
     int n = 0;
     int hex_exp = (s[i] == 'p' || s[i] == 'P');
     i++;
     if (i < len && (s[i] == '+' || s[i] == '-')) {
       if (s[i] == '-') neg = 1;
       i++;
     }
     while (i < len) {
       int c = (unsigned char)s[i];
       if (c < '0' || c > '9') break;
       n = n * 10 + (c - '0');
       i++;
     }
     dec_exp = neg ? -n : n;
     if (hex_exp) {
       dec_exp += exp * 4;
       exp = 0;
     }
   }
   while (exp < 0) {
     v /= (is_hex ? 16.0 : 10.0);
     exp++;
   }
   while (exp > 0) {
     v *= (is_hex ? 16.0 : 10.0);
     exp--;
   }
   if (is_hex) {
     while (dec_exp < 0) {
       v /= 2.0;
       dec_exp++;
     }
     while (dec_exp > 0) {
       v *= 2.0;
       dec_exp--;
     }
   } else {
     while (dec_exp < 0) {
       v /= 10.0;
       dec_exp++;
     }
     while (dec_exp > 0) {
       v *= 10.0;
       dec_exp--;
     }
   }
   return v;
 }
 
 static const Type* float_literal_type(Parser* p, const Tok* t) {
   if (t->flags & TF_FLT_F) return type_prim(p->pool, TY_FLOAT);
   if (t->flags & TF_FLT_L) return type_prim(p->pool, TY_LDOUBLE);
   return type_prim(p->pool, TY_DOUBLE);
 }
 
 const Type* char_literal_type(Parser* p, const Tok* t) {
   if (t->flags & TF_STR_U16) return ty_char16(p);
   if (t->flags & TF_STR_U32) return ty_char32(p);
   return ty_int(p);
 }
 
 static CLitStringEnc literal_string_encoding(const Tok* t) {
   if (t->flags & TF_STR_U8) return C_LIT_STR_UTF8;
   if (t->flags & TF_STR_U16) return C_LIT_STR_UTF16;
   if (t->flags & (TF_STR_WIDE | TF_STR_U32)) return C_LIT_STR_UTF32;
   return C_LIT_STR_ORDINARY;
 }
 
 const Type* string_literal_elem_type(Parser* p, const Tok* t) {
   if (t->flags & TF_STR_WIDE) return ty_wchar(p);
   if (t->flags & TF_STR_U16) return ty_char16(p);
   if (t->flags & TF_STR_U32) return ty_char32(p);
   return type_prim(p->pool, TY_CHAR);
 }
 
 int string_literal_initializes_array(Parser* p, const Type* elem,
                                      const Tok* t) {
   const Type* uelem;
   if (!elem || !t || t->kind != TOK_STR) return 0;
   uelem = type_unqual(p->pool, elem);
   if (!(t->flags & (TF_STR_WIDE | TF_STR_U16 | TF_STR_U32))) {
     return is_char_kind(uelem);
   }
   return type_compatible(uelem, string_literal_elem_type(p, t));
 }
 
 i64 decode_char_literal(Parser* p, const Tok* t) {
   KitSlice spell_sl = pp_text_slice(p->pp, t);
   size_t len = spell_sl.len;
   const char* s = spell_sl.s;
   size_t i = 0;
   CLitUnit unit;
   const char* err = NULL;
   u32 v;
   u32 bits = 8;
   CLitStringEnc enc = literal_string_encoding(t);
   if (!s) perr(p, "bad char literal");
   if (t->flags & TF_STR_U8)
     i = 2;
   else if (t->flags & (TF_STR_WIDE | TF_STR_U16 | TF_STR_U32))
     i = 1;
   if (t->flags & TF_STR_U16)
     bits = 16;
   else if (t->flags & (TF_STR_WIDE | TF_STR_U32))
     bits = 32;
   if (i >= len || s[i] != '\'') perr(p, "malformed character literal");
   i++;
   if (i >= len || s[i] == '\'') perr(p, "empty character literal");
   if (!c_lit_decode_unit(s, len, &i, &unit, &err)) {
     compiler_panic(
         p->c, pp_materialize_loc(p->pp, t->loc), "%.*s",
         KIT_SLICE_ARG(kit_slice_cstr(err ? err : "bad character literal")));
   }
   if (!c_lit_encode_char_unit(enc, bits, unit, &v, &err)) {
     compiler_panic(
         p->c, pp_materialize_loc(p->pp, t->loc), "%.*s",
         KIT_SLICE_ARG(kit_slice_cstr(err ? err : "bad character literal")));
   }
   if (i >= len || s[i] != '\'') {
     perr(p, "multi-character constants are not supported");
   }
   return (i64)v;
 }
 
 u8* decode_string_literal(Parser* p, const Tok* t, size_t* nlen_out) {
   KitSlice spell_sl = pp_text_slice(p->pp, t);
   size_t len = spell_sl.len;
   const char* s = spell_sl.s;
   size_t i = 0;
   Heap* h = kit_compiler_context(p->c)->heap;
   u8* buf;
   size_t k = 0;
   const Type* elem_ty;
   u32 elem_size;
   CLitStringEnc enc = literal_string_encoding(t);
   const char* err = NULL;
   if (!s) perr(p, "bad string literal");
   if (t->flags & TF_STR_U8)
     i = 2;
   else if (t->flags & (TF_STR_WIDE | TF_STR_U16 | TF_STR_U32))
     i = 1;
   elem_ty = string_literal_elem_type(p, t);
   elem_size = c_abi_sizeof(p->abi, p->pool, elem_ty);
   if (i >= len || s[i] != '"') perr(p, "malformed string literal");
   i++;
   buf = (u8*)h->alloc(h, (len + 1u) * elem_size, 1);
   if (!buf) perr(p, "out of memory in string literal");
   while (i < len && s[i] != '"') {
     CLitUnit unit;
     if (!c_lit_decode_unit(s, len, &i, &unit, &err)) {
       compiler_panic(
           p->c, pp_materialize_loc(p->pp, t->loc), "%.*s",
           KIT_SLICE_ARG(kit_slice_cstr(err ? err : "bad string literal")));
     }
     if (!c_lit_append_string_unit(buf, &k, enc, elem_size, unit, &err)) {
       compiler_panic(
           p->c, pp_materialize_loc(p->pp, t->loc), "%.*s",
           KIT_SLICE_ARG(kit_slice_cstr(err ? err : "bad string literal")));
     }
   }
   c_lit_encode_uint_le(buf + k, elem_size, 0);
   k += elem_size;
   *nlen_out = k;
   return buf;
 }
 
 KitCgSym emit_string_to_rodata(Parser* p, const u8* bytes, size_t n) {
   const Type* arr_ty =
       type_array(p->pool, type_prim(p->pool, TY_CHAR), (u32)n, 0);
   return kit_cg_const_data(p->cg, bytes, n, 1u, c_cg_tid(p, arr_ty));
 }
 
 KitCgSym emit_string_literal_to_rodata(Parser* p, const u8* bytes,
                                        size_t nbytes, const Type* elem_ty) {
   u32 elem_size = c_abi_sizeof(p->abi, p->pool, elem_ty);
   u32 count = elem_size ? (u32)(nbytes / elem_size) : 0;
   const Type* arr_ty = type_array(p->pool, elem_ty, count, 0);
   return kit_cg_const_data(p->cg, bytes, nbytes,
                            c_abi_alignof(p->abi, p->pool, elem_ty),
                            c_cg_tid(p, arr_ty));
 }
 
 /* ============================================================
  * Integer conversion helpers + constant-expression guard
  * ============================================================ */
 
 static const Type* offsetof_designator(Parser* p, const Type* base, u32* off);
 static const Type* common_fp_type(Parser* p, const Type* a, const Type* b);
 static void coerce_fp_cmp_operands(Parser* p, const Type* common);
 
 typedef struct CConstGuardMark {
   u32 depth;
   u32 not_eval;
   const char* error;
   SrcLoc error_loc;
 } CConstGuardMark;
 
 static int c_const_guard_active(Parser* p) {
   return p && p->const_guard_depth != 0;
 }
 
 static void c_const_guard_note_at(Parser* p, SrcLoc loc, const char* message) {
   if (!p || !p->const_guard_depth || p->const_guard_not_eval ||
       p->const_guard_error) {
     return;
   }
   p->const_guard_error = message;
   p->const_guard_error_loc = loc;
 }
 
 static void c_const_guard_note(Parser* p, const char* message) {
   c_const_guard_note_at(p, pp_materialize_loc(p->pp, p->cur.loc), message);
 }
 
 void c_const_guard_not_eval_push(Parser* p) {
   if (p && p->const_guard_depth) ++p->const_guard_not_eval;
 }
 
 void c_const_guard_not_eval_pop(Parser* p) {
   if (!p || !p->const_guard_depth) return;
   if (!p->const_guard_not_eval)
     perr(p, "internal parser constant guard not-evaluated underflow");
   --p->const_guard_not_eval;
 }
 
 static CConstGuardMark c_const_guard_push(Parser* p) {
   CConstGuardMark mark;
   memset(&mark, 0, sizeof mark);
   if (!p) return mark;
   mark.depth = p->const_guard_depth;
   mark.not_eval = p->const_guard_not_eval;
   mark.error = p->const_guard_error;
   mark.error_loc = p->const_guard_error_loc;
   if (p->const_guard_depth == 0) {
     p->const_guard_not_eval = 0;
     p->const_guard_error = NULL;
     memset(&p->const_guard_error_loc, 0, sizeof p->const_guard_error_loc);
   }
   ++p->const_guard_depth;
   return mark;
 }
 
 static int c_const_guard_pop(Parser* p, CConstGuardMark mark,
                              const char** error_out, SrcLoc* loc_out) {
   const char* error = p ? p->const_guard_error : NULL;
   SrcLoc loc;
   memset(&loc, 0, sizeof loc);
   if (p) {
     loc = p->const_guard_error_loc;
     if (!p->const_guard_depth)
       perr(p, "internal parser constant guard underflow");
     p->const_guard_depth = mark.depth;
     p->const_guard_not_eval = mark.not_eval;
     p->const_guard_error = mark.error;
     p->const_guard_error_loc = mark.error_loc;
   }
   if (error_out) *error_out = error;
   if (loc_out) *loc_out = loc;
   return error == NULL;
 }
 
 static u32 integer_type_bits(Parser* p, const Type* ty) {
   u32 sz = ty ? c_abi_sizeof(p->abi, p->pool, ty) : 8u;
   if (ty && (ty->kind == TY_INT128 || ty->kind == TY_UINT128)) return 128;
   if (sz >= 8) return 64;
   return sz * 8u;
 }
 
 static int integer_type_signed(Parser* p, const Type* ty) {
   (void)p;
   if (!ty) return 1;
   return type_is_signed_integer(ty) != 0;
 }
 
 static u32 integer_rank(const Type* ty) {
   return ty ? type_kind_int_rank((TypeKind)ty->kind) : 0;
 }
 
 static const Type* integer_unsigned_variant(Parser* p, const Type* ty) {
   TypeKind k = ty ? (TypeKind)ty->kind : TY_UINT;
   return type_prim(p->pool, type_kind_unsigned_variant(k));
 }
 
 static const Type* integer_promote_type(Parser* p, const Type* ty) {
   const Type* u = type_unqual(p->pool, ty);
   if (u && u->kind == TY_ENUM) return type_prim(p->pool, TY_INT);
   return type_promoted(p->pool, u);
 }
 
 static const Type* integer_common_type(Parser* p, const Type* a,
                                        const Type* b) {
   const Type* ap = integer_promote_type(p, a);
   const Type* bp = integer_promote_type(p, b);
   int as = integer_type_signed(p, ap);
   int bs = integer_type_signed(p, bp);
   u32 ar = integer_rank(ap);
   u32 br = integer_rank(bp);
   if (type_compatible(ap, bp)) return ap;
   if (as == bs) return ar >= br ? ap : bp;
   if (!as && ar >= br) return ap;
   if (!bs && br >= ar) return bp;
   if (as && integer_type_bits(p, ap) > integer_type_bits(p, bp)) return ap;
   if (bs && integer_type_bits(p, bp) > integer_type_bits(p, ap)) return bp;
   return integer_unsigned_variant(p, as ? ap : bp);
 }
 
 static int cg_const_is_zero(KitCgConstInt v) {
   return v.known && v.lo == 0 && v.hi == 0;
 }
 
 static int cg_top_const_truth(Parser* p, int* truth_out) {
   KitCgConstInt v;
   if (!kit_cg_top_const_int_ex(p->cg, &v)) return 0;
   if (truth_out) *truth_out = (v.lo != 0 || v.hi != 0);
   return 1;
 }
 
 static int cg_top2_const_int(Parser* p, KitCgConstInt* out) {
   if (!p || kit_cg_stack_depth(p->cg) < 2u) return 0;
   c_cg_swap(p);
   if (!kit_cg_top_const_int_ex(p->cg, out)) {
     c_cg_swap(p);
     return 0;
   }
   c_cg_swap(p);
   return 1;
 }
 
 static CConstInt cconst_from_cg(Parser* p, const Type* ty, KitCgConstInt v) {
   CConstInt r;
   memset(&r, 0, sizeof r);
   r.type = ty ? type_unqual(p->pool, ty) : ty_int(p);
   r.lo = v.lo;
   r.hi = v.hi;
   if (r.type && r.type->kind == TY_BOOL) {
     r.lo = (r.lo || r.hi) ? 1u : 0u;
     r.hi = 0;
   }
   return r;
 }
 
 i64 const_int_as_i64(Parser* p, CConstInt v) {
   u32 nb = integer_type_bits(p, v.type);
   u64 u = v.lo;
   if (integer_type_signed(p, v.type) && nb < 64) {
     u64 mask = (1ull << nb) - 1ull;
     u64 sign = 1ull << (nb - 1u);
     u &= mask;
     if (u & sign) u |= ~mask;
   }
   return (i64)u;
 }
 
 static i64 cg_const_as_i64(Parser* p, const Type* ty, KitCgConstInt v) {
   return const_int_as_i64(p, cconst_from_cg(p, ty, v));
 }
 
 static void c_const_check_divrem(Parser* p, BinOp bop, SrcLoc loc) {
   KitCgConstInt rhs;
   if (!c_const_guard_active(p)) return;
   if (bop != BO_SDIV && bop != BO_UDIV && bop != BO_SREM && bop != BO_UREM)
     return;
   if (kit_cg_top_const_int_ex(p->cg, &rhs) && cg_const_is_zero(rhs)) {
     compiler_panic(p->c, loc,
                    (bop == BO_SDIV || bop == BO_UDIV)
                        ? "division by zero in constant"
                        : "modulo by zero in constant");
   }
 }
 
 static void c_const_check_shift(Parser* p, BinOp bop, SrcLoc loc) {
   KitCgConstInt lhs;
   KitCgConstInt rhs;
   const Type* lhs_ty;
   i64 sh;
   if (!c_const_guard_active(p)) return;
   if (bop != BO_SHL && bop != BO_SHR_S && bop != BO_SHR_U) return;
   if (!kit_cg_top_const_int_ex(p->cg, &rhs)) return;
   lhs_ty = c_cg_top2_type(p);
   sh = cg_const_as_i64(p, c_cg_top_type(p), rhs);
   if (sh < 0 || sh >= (i64)integer_type_bits(p, lhs_ty)) {
     compiler_panic(p->c, loc,
                    "shift count out of range in constant expression");
   }
   if (bop == BO_SHL && integer_type_signed(p, lhs_ty) &&
       cg_top2_const_int(p, &lhs) && cg_const_as_i64(p, lhs_ty, lhs) < 0) {
     compiler_panic(p->c, loc,
                    "left shift of negative value in constant expression");
   }
 }
 
 CConstInt eval_const_int_typed(Parser* p, SrcLoc loc) {
   CConstGuardMark mark;
   KitCgConstInt cg_value;
   CConstInt value;
   const Type* ty;
   const char* guard_error = NULL;
   SrcLoc guard_loc;
   int has_const;
   u32 start_cg_depth;
 
   memset(&cg_value, 0, sizeof cg_value);
   memset(&value, 0, sizeof value);
   memset(&guard_loc, 0, sizeof guard_loc);
   start_cg_depth = kit_cg_stack_depth(p->cg);
 
   mark = c_const_guard_push(p);
   kit_cg_unevaluated_push(p->cg);
   parse_cond_expr(p);
   ty = c_cg_top_type(p);
   has_const = kit_cg_top_const_int_ex(p->cg, &cg_value);
   c_cg_drop_to_depth(p, start_cg_depth);
   kit_cg_unevaluated_pop(p->cg);
   if (!c_const_guard_pop(p, mark, &guard_error, &guard_loc)) {
     compiler_panic(p->c, guard_loc, "%.*s",
                    KIT_SLICE_ARG(kit_slice_cstr(guard_error)));
   }
 
   if (kit_cg_stack_depth(p->cg) != start_cg_depth) {
     compiler_panic(p->c, loc,
                    "internal parser constant expression stack imbalance");
   }
   if (!type_is_int(ty)) perr(p, "integer constant expression required");
   if (!has_const) perr(p, "integer constant expression required");
   value = cconst_from_cg(p, ty, cg_value);
   return value;
 }
 
 i64 eval_const_int(Parser* p, SrcLoc loc) {
   return const_int_as_i64(p, eval_const_int_typed(p, loc));
 }
 
 /* ============================================================
  * to_rvalue
  * ============================================================ */
 
 static void decay_array_to_pointer(Parser* p, const Type* arr_ty) {
   c_cg_decay_array(p, arr_ty);
 }
 
 static FrameSlot vla_size_slot_for_type(VLABound* bounds, const Type* ty) {
   for (VLABound* b = bounds; b; b = b->next) {
     if (b->array_ty == ty) return b->byte_slot;
   }
   return FRAME_SLOT_NONE;
 }
 
 void to_rvalue(Parser* p) {
   const Type* t = c_cg_top_type(p);
   int is_lvalue = c_cg_top_is_lvalue(p);
   if (t) {
     if (t->kind == TY_ARRAY) {
       decay_array_to_pointer(p, t);
       return;
     }
     if (t->kind == TY_FUNC) {
       c_cg_addr(p);
       return;
     }
     if (t->kind == TY_STRUCT || t->kind == TY_UNION) {
       const Type* uty = type_unqual(p->pool, t);
       c_cg_retag_keep_flags(p, 0, uty);
       return;
     }
   }
   if (is_lvalue) c_cg_load(p);
 }
 
 /* ============================================================
  * coerce_top_to_lvalue (used by assignment / initializers)
  * ============================================================ */
 
 void coerce_top_to_lvalue(Parser* p) {
   const Type* src = c_cg_top_type(p);
   const Type* dst = c_cg_top2_type(p);
   if (!src || !dst || src == dst) return;
   if (type_is_arith(src) && type_is_arith(dst)) {
     c_cg_convert(p, dst);
   } else if (type_is_arith(src) && type_is_ptr(dst)) {
     c_cg_convert(p, dst);
   } else if (type_is_ptr(src) && type_is_ptr(dst)) {
     c_cg_convert(p, dst);
   }
 }
 
 void coerce_top_to_type(Parser* p, const Type* dst) {
   const Type* src = c_cg_top_type(p);
   if (!src || !dst || src == dst) return;
   if (type_is_arith(src) && type_is_arith(dst)) {
     c_cg_convert(p, dst);
   } else if (type_is_arith(src) && type_is_ptr(dst)) {
     c_cg_convert(p, dst);
   } else if (type_is_ptr(src) && type_is_ptr(dst)) {
     c_cg_convert(p, dst);
   }
 }
 
 static const Type* atomic_pointee_type(Parser* p, const Type* ptr_ty,
                                        const char* who) {
   if (!ptr_ty || ptr_ty->kind != TY_PTR) {
     perr(p, "%.*s: pointer argument must have pointer type",
          KIT_SLICE_ARG(kit_slice_cstr(who)));
   }
   return ptr_ty->ptr.pointee;
 }
 
 static const Type* atomic_lock_free_type_for_size(Parser* p, i64 size) {
   const Type* ty = NULL;
   switch (size) {
     case 1:
       ty = type_prim(p->pool, TY_UCHAR);
       break;
     case 2:
       ty = type_prim(p->pool, TY_USHORT);
       break;
     case 4:
       ty = type_prim(p->pool, TY_UINT);
       break;
     case 8:
       ty = type_prim(p->pool, TY_ULLONG);
       break;
     case 16:
       ty = type_prim(p->pool, TY_UINT128);
       break;
     default:
       return NULL;
   }
   return c_abi_sizeof(p->abi, p->pool, ty) == (u32)size ? ty : NULL;
 }
 
 static int atomic_lock_free_for_const_size(Parser* p, i64 size) {
   if (size <= 0 || size > 16) return 0;
   const Type* ty = atomic_lock_free_type_for_size(p, size);
   return ty ? kit_cg_atomic_is_lock_free(p->c, c_cg_mem(p, ty)) : 0;
 }
 
 static KitCgSym builtin_libcall_sym(Parser* p, const char* name,
                                     const Type* fn_ty) {
   KitCgDecl decl;
   Sym source_name = kit_sym_intern(p->pool->c, kit_slice_cstr(name));
   memset(&decl, 0, sizeof decl);
   decl.kind = KIT_CG_DECL_FUNC;
   decl.display_name = source_name;
   decl.linkage_name = kit_cg_c_linkage_name(p->c, source_name);
   decl.type = c_cg_tid(p, fn_ty);
   decl.sym.bind = KIT_SB_GLOBAL;
   decl.sym.visibility = KIT_CG_VIS_DEFAULT;
   decl.as.func.debug_type = type_cg_debug_in_pool(p->cg, p->c, p->pool, fn_ty);
   return kit_cg_decl(p->cg, decl);
 }
 
 static int parse_builtin_mem_call(Parser* p, Sym name, SrcLoc loc) {
   const Type* void_ty = type_void(p->pool);
   const Type* void_ptr_ty = type_ptr(p->pool, void_ty);
   const Type* const_void_ptr_ty =
       type_ptr(p->pool, type_qualified(p->pool, void_ty, Q_CONST));
   const Type* size_ty = ty_size_t(p);
   const Type* int_ty = ty_int(p);
   const Type* params[3];
   const Type* fn_ty;
   const char* libname;
   KitCgSym sym;
 
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after builtin");
 
   if (name == p->sym_b_memcpy || name == p->sym_b_memmove) {
     libname = name == p->sym_b_memcpy ? "memcpy" : "memmove";
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, void_ptr_ty);
     expect_punct(p, ',', "',' in memory builtin");
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, const_void_ptr_ty);
     expect_punct(p, ',', "',' in memory builtin");
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, size_ty);
     expect_punct(p, ')', "')' after memory builtin");
     params[0] = void_ptr_ty;
     params[1] = const_void_ptr_ty;
     params[2] = size_ty;
     fn_ty = type_func(p->pool, void_ptr_ty, params, 3, 0);
   } else if (name == p->sym_b_memset) {
     libname = "memset";
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, void_ptr_ty);
     expect_punct(p, ',', "',' in __builtin_memset");
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, int_ty);
     expect_punct(p, ',', "',' in __builtin_memset");
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, size_ty);
     expect_punct(p, ')', "')' after __builtin_memset");
     params[0] = void_ptr_ty;
     params[1] = int_ty;
     params[2] = size_ty;
     fn_ty = type_func(p->pool, void_ptr_ty, params, 3, 0);
   } else {
     libname = "memcmp";
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, const_void_ptr_ty);
     expect_punct(p, ',', "',' in __builtin_memcmp");
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, const_void_ptr_ty);
     expect_punct(p, ',', "',' in __builtin_memcmp");
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, size_ty);
     expect_punct(p, ')', "')' after __builtin_memcmp");
     params[0] = const_void_ptr_ty;
     params[1] = const_void_ptr_ty;
     params[2] = size_ty;
     fn_ty = type_func(p->pool, int_ty, params, 3, 0);
   }
 
   sym = builtin_libcall_sym(p, libname, fn_ty);
   c_cg_set_loc(p, loc);
   c_cg_call_symbol(p, sym, 3, fn_ty);
   return 1;
 }
 
 static int parse_builtin_clear_cache_call(Parser* p, Sym name, SrcLoc loc) {
   const Type* void_ty = type_void(p->pool);
   const Type* void_ptr_ty = type_ptr(p->pool, void_ty);
   const Type* params[2];
   const Type* fn_ty;
   KitCgSym sym;
 
   if (name != p->sym_b_clear_cache) return 0;
 
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after __builtin___clear_cache");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, void_ptr_ty);
   expect_punct(p, ',', "',' in __builtin___clear_cache");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, void_ptr_ty);
   expect_punct(p, ')', "')' after __builtin___clear_cache");
 
   /* Instruction-cache coherency is automatic on x86, and wasm has no separate
    * I-cache to flush (the engine handles code installation), so
    * __builtin___clear_cache is a no-op on those targets — matching GCC/Clang.
    * Emitting the __clear_cache libcall there would reference an undefined
    * symbol. Targets that need explicit coherency (ARM, RISC-V) keep the call.
    * The argument expressions are still evaluated for their side effects. The
    * coherency fact is a backend capability, not an arch identity. */
   if (kit_cg_target_backend_features(p->c) & KIT_CG_BACKEND_ICACHE_COHERENT) {
     c_cg_drop(p);
     c_cg_drop(p);
     c_cg_push_int(p, 0, ty_int(p));
     return 1;
   }
 
   params[0] = void_ptr_ty;
   params[1] = void_ptr_ty;
   fn_ty = type_func(p->pool, void_ty, params, 2, 0);
   sym = builtin_libcall_sym(p, "__clear_cache", fn_ty);
   c_cg_set_loc(p, loc);
   c_cg_call_symbol(p, sym, 2, fn_ty);
   c_cg_push_int(p, 0, ty_int(p));
   return 1;
 }
 
 static MemOrder parse_atomic_mem_order(Parser* p) {
   if (p->cur.kind == TOK_NUM) {
     return (MemOrder)eval_const_int(p, pp_materialize_loc(p->pp, p->cur.loc));
   }
   parse_assign_expr(p);
   to_rvalue(p);
   c_cg_drop(p);
   return MO_SEQ_CST;
 }
 
 /* ============================================================
  * Builtin call handling
  * ============================================================ */
 
 static int offsetof_find_member(Parser* p, const Type* rec_ty, Sym mname,
                                 const Type** out_ty, u32* out_off) {
   const ABIRecordLayout* L;
   rec_ty = type_unqual(p->pool, rec_ty);
   if (!rec_ty || (rec_ty->kind != TY_STRUCT && rec_ty->kind != TY_UNION))
     return 0;
   L = c_abi_record_layout(p->abi, p->pool, rec_ty);
   if (!L) return 0;
   for (u16 i = 0; i < rec_ty->rec.nfields; ++i) {
     const Field* f = &rec_ty->rec.fields[i];
     if (f->name == mname && mname != 0) {
       *out_ty = f->type;
       *out_off = L->fields[i].offset;
       return 1;
     }
   }
   for (u16 i = 0; i < rec_ty->rec.nfields; ++i) {
     const Field* f = &rec_ty->rec.fields[i];
     const Type* fty = type_unqual(p->pool, f->type);
     const Type* nested_ty = NULL;
     u32 nested_off = 0;
     if (!((f->flags & FIELD_ANON) &&
           (fty->kind == TY_STRUCT || fty->kind == TY_UNION))) {
       continue;
     }
     if (offsetof_find_member(p, fty, mname, &nested_ty, &nested_off)) {
       *out_ty = nested_ty;
       *out_off = L->fields[i].offset + nested_off;
       return 1;
     }
   }
   return 0;
 }
 
 static const Type* offsetof_designator(Parser* p, const Type* base, u32* off) {
   const Type* cur = base;
   if (p->cur.kind != TOK_IDENT ||
       ident_kw_inline(p, tok_ident(&p->cur)) != KW_NONE) {
     perr(p, "expected member name in __builtin_offsetof");
   }
   for (;;) {
     if (cur->kind == TY_STRUCT || cur->kind == TY_UNION) {
       Sym mname = tok_ident(&p->cur);
       const Type* mty = NULL;
       u32 moff = 0;
       if (!offsetof_find_member(p, cur, mname, &mty, &moff))
         perr(p, "no such member in __builtin_offsetof");
       advance(p);
       *off += moff;
       cur = mty;
     } else if (cur->kind == TY_ARRAY) {
       /* fall through to bracket branch */
     } else {
       perr(p, "__builtin_offsetof step into non-aggregate");
     }
     if (is_punct(&p->cur, '.')) {
       advance(p);
       if (p->cur.kind != TOK_IDENT ||
           ident_kw_inline(p, tok_ident(&p->cur)) != KW_NONE) {
         perr(p, "expected member name after '.'");
       }
       continue;
     }
     if (is_punct(&p->cur, '[')) {
       advance(p);
       i64 idx = eval_const_int(p, pp_materialize_loc(p->pp, p->cur.loc));
       expect_punct(p, ']', "']' in __builtin_offsetof");
       if (cur->kind != TY_ARRAY) {
         perr(p, "__builtin_offsetof '[' on non-array");
       }
       *off += (u32)((i64)c_abi_sizeof(p->abi, p->pool, cur->arr.elem) * idx);
       cur = cur->arr.elem;
       continue;
     }
     break;
   }
   return cur;
 }
 
 typedef struct BuiltinOverflowInfo {
   KitCgIntrinsic intrin;
   TypeKind type_kind;
   const char* name;
 } BuiltinOverflowInfo;
 
 static int sym_eq_cstr(Parser* p, Sym sym, const char* want) {
   KitSlice got = kit_sym_str(p->pool->c, sym);
   return got.s && kit_slice_eq_cstr(got, want);
 }
 
 static int builtin_overflow_info(Parser* p, Sym name,
                                  BuiltinOverflowInfo* out) {
   static const BuiltinOverflowInfo infos[] = {
       {KIT_CG_INTRIN_SADD_OVERFLOW, TY_INT, "__builtin_sadd_overflow"},
       {KIT_CG_INTRIN_SADD_OVERFLOW, TY_LONG, "__builtin_saddl_overflow"},
       {KIT_CG_INTRIN_SADD_OVERFLOW, TY_LLONG, "__builtin_saddll_overflow"},
       {KIT_CG_INTRIN_UADD_OVERFLOW, TY_UINT, "__builtin_uadd_overflow"},
       {KIT_CG_INTRIN_UADD_OVERFLOW, TY_ULONG, "__builtin_uaddl_overflow"},
       {KIT_CG_INTRIN_UADD_OVERFLOW, TY_ULLONG, "__builtin_uaddll_overflow"},
       {KIT_CG_INTRIN_SSUB_OVERFLOW, TY_INT, "__builtin_ssub_overflow"},
       {KIT_CG_INTRIN_SSUB_OVERFLOW, TY_LONG, "__builtin_ssubl_overflow"},
       {KIT_CG_INTRIN_SSUB_OVERFLOW, TY_LLONG, "__builtin_ssubll_overflow"},
       {KIT_CG_INTRIN_USUB_OVERFLOW, TY_UINT, "__builtin_usub_overflow"},
       {KIT_CG_INTRIN_USUB_OVERFLOW, TY_ULONG, "__builtin_usubl_overflow"},
       {KIT_CG_INTRIN_USUB_OVERFLOW, TY_ULLONG, "__builtin_usubll_overflow"},
       {KIT_CG_INTRIN_SMUL_OVERFLOW, TY_INT, "__builtin_smul_overflow"},
       {KIT_CG_INTRIN_SMUL_OVERFLOW, TY_LONG, "__builtin_smull_overflow"},
       {KIT_CG_INTRIN_SMUL_OVERFLOW, TY_LLONG, "__builtin_smulll_overflow"},
       {KIT_CG_INTRIN_UMUL_OVERFLOW, TY_UINT, "__builtin_umul_overflow"},
       {KIT_CG_INTRIN_UMUL_OVERFLOW, TY_ULONG, "__builtin_umull_overflow"},
       {KIT_CG_INTRIN_UMUL_OVERFLOW, TY_ULLONG, "__builtin_umulll_overflow"},
   };
   size_t i;
   for (i = 0; i < sizeof(infos) / sizeof(infos[0]); ++i) {
     if (sym_eq_cstr(p, name, infos[i].name)) {
       if (out) *out = infos[i];
       return 1;
     }
   }
   return 0;
 }
 
 static FrameSlot builtin_tmp_slot(Parser* p, const Type* ty) {
   FrameSlotDesc fsd;
   memset(&fsd, 0, sizeof fsd);
   fsd.type = ty;
   fsd.size = c_abi_sizeof(p->abi, p->pool, ty);
   fsd.align = c_abi_alignof(p->abi, p->pool, ty);
   fsd.kind = FS_LOCAL;
   return c_cg_local(p, &fsd);
 }
 
 static void builtin_store_top(Parser* p, FrameSlot slot, const Type* ty) {
   c_cg_push_local_typed(p, slot, ty);
   c_cg_swap(p);
   c_cg_store_void(p);
 }
 
 static void builtin_load_slot(Parser* p, FrameSlot slot, const Type* ty) {
   c_cg_push_local_typed(p, slot, ty);
   c_cg_load(p);
 }
 
 typedef struct BuiltinBitInfo {
   const char* name;
   KitCgIntrinsic intrin;
   TypeKind arg_kind;
   TypeKind result_kind;
 } BuiltinBitInfo;
 
 static int parse_builtin_bit_call(Parser* p, Sym name, SrcLoc loc) {
   static const BuiltinBitInfo infos[] = {
       {"__builtin_popcount", KIT_CG_INTRIN_POPCOUNT, TY_UINT, TY_INT},
       {"__builtin_popcountl", KIT_CG_INTRIN_POPCOUNT, TY_ULONG, TY_INT},
       {"__builtin_popcountll", KIT_CG_INTRIN_POPCOUNT, TY_ULLONG, TY_INT},
       {"__builtin_bswap16", KIT_CG_INTRIN_BSWAP, TY_USHORT, TY_USHORT},
       {"__builtin_bswap32", KIT_CG_INTRIN_BSWAP, TY_UINT, TY_UINT},
       {"__builtin_bswap64", KIT_CG_INTRIN_BSWAP, TY_ULLONG, TY_ULLONG},
   };
   const BuiltinBitInfo* info = NULL;
   const Type* arg_ty;
   const Type* result_ty;
   size_t i;
   for (i = 0; i < sizeof infos / sizeof infos[0]; ++i) {
     if (sym_eq_cstr(p, name, infos[i].name)) {
       info = &infos[i];
       break;
     }
   }
   if (!info) return 0;
   arg_ty = type_prim(p->pool, info->arg_kind);
   result_ty = type_prim(p->pool, info->result_kind);
   advance(p);
   expect_punct(p, '(', "'(' after bit builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, arg_ty);
   expect_punct(p, ')', "')' after bit builtin");
   c_cg_set_loc(p, loc);
   kit_cg_intrinsic(p->cg, info->intrin, 1, c_cg_tid(p, result_ty));
   c_cg_retag_top(p, result_ty);
   return 1;
 }
 
 typedef struct BuiltinRotateInfo {
   const char* name;
   TypeKind type_kind;
   u8 left;
 } BuiltinRotateInfo;
 
 static int parse_builtin_rotate_call(Parser* p, Sym name) {
   static const BuiltinRotateInfo infos[] = {
       {"__builtin_rotateleft8", TY_UCHAR, 1},
       {"__builtin_rotateleft16", TY_USHORT, 1},
       {"__builtin_rotateleft32", TY_UINT, 1},
       {"__builtin_rotateleft64", TY_ULLONG, 1},
       {"__builtin_rotateright8", TY_UCHAR, 0},
       {"__builtin_rotateright16", TY_USHORT, 0},
       {"__builtin_rotateright32", TY_UINT, 0},
       {"__builtin_rotateright64", TY_ULLONG, 0},
   };
   const BuiltinRotateInfo* info = NULL;
   const Type* ty;
   FrameSlot value_slot;
   FrameSlot count_slot;
   u32 bits;
   size_t i;
   for (i = 0; i < sizeof infos / sizeof infos[0]; ++i) {
     if (sym_eq_cstr(p, name, infos[i].name)) {
       info = &infos[i];
       break;
     }
   }
   if (!info) return 0;
   ty = type_prim(p->pool, info->type_kind);
   bits = integer_type_bits(p, ty);
   value_slot = builtin_tmp_slot(p, ty);
   count_slot = builtin_tmp_slot(p, ty);
 
   advance(p);
   expect_punct(p, '(', "'(' after rotate builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, ty);
   builtin_store_top(p, value_slot, ty);
   expect_punct(p, ',', "',' in rotate builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, ty);
   builtin_store_top(p, count_slot, ty);
   expect_punct(p, ')', "')' after rotate builtin");
 
   /* CG shifts with KIT_CG_INTOP_NONE reduce the count modulo the operand
    * width. Thus width-count deliberately becomes a zero shift when count is
    * zero, avoiding the undefined full-width shift in the equivalent C idiom. */
   builtin_load_slot(p, value_slot, ty);
   builtin_load_slot(p, count_slot, ty);
   c_cg_binop(p, info->left ? BO_SHL : BO_SHR_U);
   builtin_load_slot(p, value_slot, ty);
   c_cg_push_int(p, (i64)bits, ty);
   builtin_load_slot(p, count_slot, ty);
   c_cg_binop(p, BO_ISUB);
   c_cg_binop(p, info->left ? BO_SHR_U : BO_SHL);
   c_cg_binop(p, BO_OR);
   return 1;
 }
 
 static int parse_builtin_prefetch_call(Parser* p, Sym name, SrcLoc loc) {
   const Type* ptr_ty;
   u32 nargs = 1;
   i64 rw = 0;
   i64 locality = 3;
   if (!sym_eq_cstr(p, name, "__builtin_prefetch")) return 0;
   advance(p);
   expect_punct(p, '(', "'(' after __builtin_prefetch");
   parse_assign_expr(p);
   to_rvalue(p);
   ptr_ty = c_cg_top_type(p);
   if (!ptr_ty || ptr_ty->kind != TY_PTR)
     perr(p, "__builtin_prefetch address must be a pointer");
   if (accept_punct(p, ',')) {
     rw = eval_const_int(p, pp_materialize_loc(p->pp, p->cur.loc));
     if (rw < 0 || rw > 1) perr(p, "__builtin_prefetch rw must be 0 or 1");
     c_cg_push_int(p, rw, ty_int(p));
     nargs = 2;
     if (accept_punct(p, ',')) {
       locality = eval_const_int(p, pp_materialize_loc(p->pp, p->cur.loc));
       if (locality < 0 || locality > 3)
         perr(p, "__builtin_prefetch locality must be in [0, 3]");
       c_cg_push_int(p, locality, ty_int(p));
       nargs = 3;
     }
   }
   expect_punct(p, ')', "')' after __builtin_prefetch");
   c_cg_set_loc(p, loc);
   kit_cg_intrinsic(p->cg, KIT_CG_INTRIN_PREFETCH, nargs,
                    c_cg_tid(p, type_void(p->pool)));
   c_cg_push_int(p, 0, ty_int(p));
   return 1;
 }
 
 static int parse_builtin_assume_aligned_call(Parser* p, Sym name, SrcLoc loc) {
   const Type* ptr_ty;
   i64 align;
   i64 offset = 0;
   u32 nargs = 2;
   if (!sym_eq_cstr(p, name, "__builtin_assume_aligned")) return 0;
   advance(p);
   expect_punct(p, '(', "'(' after __builtin_assume_aligned");
   parse_assign_expr(p);
   to_rvalue(p);
   ptr_ty = c_cg_top_type(p);
   if (!ptr_ty || ptr_ty->kind != TY_PTR)
     perr(p, "__builtin_assume_aligned argument must be a pointer");
   expect_punct(p, ',', "',' in __builtin_assume_aligned");
   align = eval_const_int(p, pp_materialize_loc(p->pp, p->cur.loc));
   if (align <= 0 || ((u64)align & ((u64)align - 1u)) != 0)
     perr(p, "__builtin_assume_aligned alignment must be a power of two");
   c_cg_push_int(p, align, ty_size_t(p));
   if (accept_punct(p, ',')) {
     offset = eval_const_int(p, pp_materialize_loc(p->pp, p->cur.loc));
     c_cg_push_int(p, offset, ty_size_t(p));
     nargs = 3;
   }
   expect_punct(p, ')', "')' after __builtin_assume_aligned");
   c_cg_set_loc(p, loc);
   kit_cg_intrinsic(p->cg, KIT_CG_INTRIN_ASSUME_ALIGNED, nargs,
                    c_cg_tid(p, ptr_ty));
   c_cg_retag_top(p, ptr_ty);
   return 1;
 }
 
 static int parse_builtin_cpu_relax_call(Parser* p, Sym name, SrcLoc loc) {
   if (!sym_eq_cstr(p, name, "__builtin_kit_cpu_relax")) return 0;
   advance(p);
   expect_punct(p, '(', "'(' after __builtin_kit_cpu_relax");
   expect_punct(p, ')', "')' after __builtin_kit_cpu_relax");
   c_cg_set_loc(p, loc);
   kit_cg_intrinsic(p->cg, KIT_CG_INTRIN_CPU_YIELD, 0,
                    c_cg_tid(p, type_void(p->pool)));
   c_cg_push_int(p, 0, ty_int(p));
   return 1;
 }
 
 static int parse_builtin_target_has_call(Parser* p, Sym name) {
   Tok tok;
   u8* bytes;
   size_t nbytes = 0;
   int enabled;
   Heap* h;
   if (!sym_eq_cstr(p, name, "__builtin_kit_target_has")) return 0;
   advance(p);
   expect_punct(p, '(', "'(' after __builtin_kit_target_has");
   if (p->cur.kind != TOK_STR ||
       (p->cur.flags & (TF_STR_WIDE | TF_STR_U16 | TF_STR_U32)))
     perr(p, "__builtin_kit_target_has expects an ordinary string literal");
   tok = p->cur;
   bytes = decode_string_literal(p, &tok, &nbytes);
   advance(p);
   expect_punct(p, ')', "')' after __builtin_kit_target_has");
   enabled = kit_target_has_feature(
       kit_compiler_target(p->c),
       (KitSlice){.s = (const char*)bytes, .len = nbytes ? nbytes - 1u : 0u});
   h = kit_compiler_context(p->c)->heap;
   h->free(h, bytes, 0);
   c_cg_push_int(p, enabled, ty_int(p));
   return 1;
 }
 
 typedef struct BuiltinCarryInfo {
   const char* name;
   TypeKind type_kind;
   u8 subtract;
 } BuiltinCarryInfo;
 
 static int parse_builtin_carry_call(Parser* p, Sym name, SrcLoc loc) {
   static const BuiltinCarryInfo infos[] = {
       {"__builtin_addc", TY_UINT, 0},       {"__builtin_addcl", TY_ULONG, 0},
       {"__builtin_addcll", TY_ULLONG, 0},  {"__builtin_subc", TY_UINT, 1},
       {"__builtin_subcl", TY_ULONG, 1},    {"__builtin_subcll", TY_ULLONG, 1},
   };
   const BuiltinCarryInfo* info = NULL;
   const Type* ty;
   const Type* bool_ty = type_prim(p->pool, TY_BOOL);
   const Type* ptr_ty;
   FrameSlot a_slot, b_slot, in_slot, ptr_slot, value_slot, flag1_slot;
   KitCgIntrinsic intrin;
   size_t i;
   for (i = 0; i < sizeof infos / sizeof infos[0]; ++i) {
     if (sym_eq_cstr(p, name, infos[i].name)) {
       info = &infos[i];
       break;
     }
   }
   if (!info) return 0;
   ty = type_prim(p->pool, info->type_kind);
   a_slot = builtin_tmp_slot(p, ty);
   b_slot = builtin_tmp_slot(p, ty);
   in_slot = builtin_tmp_slot(p, ty);
   value_slot = builtin_tmp_slot(p, ty);
   flag1_slot = builtin_tmp_slot(p, bool_ty);
   intrin = info->subtract ? KIT_CG_INTRIN_USUB_OVERFLOW
                           : KIT_CG_INTRIN_UADD_OVERFLOW;
 
   advance(p);
   expect_punct(p, '(', "'(' after carry builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, ty);
   builtin_store_top(p, a_slot, ty);
   expect_punct(p, ',', "',' in carry builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, ty);
   builtin_store_top(p, b_slot, ty);
   expect_punct(p, ',', "',' in carry builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, ty);
   builtin_store_top(p, in_slot, ty);
   expect_punct(p, ',', "',' in carry builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   ptr_ty = c_cg_top_type(p);
   if (!ptr_ty || ptr_ty->kind != TY_PTR ||
       !type_compatible(type_unqual(p->pool, ptr_ty->ptr.pointee), ty))
     perr(p, "carry builtin output must point to its unsigned operand type");
   ptr_slot = builtin_tmp_slot(p, ptr_ty);
   builtin_store_top(p, ptr_slot, ptr_ty);
   expect_punct(p, ')', "')' after carry builtin");
 
   c_cg_set_loc(p, loc);
   builtin_load_slot(p, a_slot, ty);
   builtin_load_slot(p, b_slot, ty);
   kit_cg_intrinsic(p->cg, intrin, 2, c_cg_tid(p, ty));
   c_cg_retag_at(p, 1, ty, 0);
   c_cg_retag_top(p, bool_ty);
   builtin_store_top(p, flag1_slot, bool_ty);
   builtin_store_top(p, value_slot, ty);
 
   builtin_load_slot(p, value_slot, ty);
   builtin_load_slot(p, in_slot, ty);
   kit_cg_intrinsic(p->cg, intrin, 2, c_cg_tid(p, ty));
   c_cg_retag_at(p, 1, ty, 0);
   c_cg_retag_top(p, bool_ty);
   builtin_load_slot(p, flag1_slot, bool_ty);
   c_cg_binop(p, BO_OR);
   c_cg_convert(p, ty);
 
   builtin_load_slot(p, ptr_slot, ptr_ty);
   c_cg_deref(p, ty);
   c_cg_swap(p);
   c_cg_store_void(p);
   return 1; /* the second arithmetic result remains below the stored flag */
 }
 
 typedef struct BuiltinMulHighInfo {
   const char* name;
   TypeKind type_kind;
   KitCgIntrinsic intrin;
 } BuiltinMulHighInfo;
 
 static int parse_builtin_mul_high_call(Parser* p, Sym name, SrcLoc loc) {
   static const BuiltinMulHighInfo infos[] = {
       {"__builtin_kit_umul_high32", TY_UINT, KIT_CG_INTRIN_UMUL_HIGH},
       {"__builtin_kit_umul_high64", TY_ULLONG, KIT_CG_INTRIN_UMUL_HIGH},
       {"__builtin_kit_smul_high32", TY_INT, KIT_CG_INTRIN_SMUL_HIGH},
       {"__builtin_kit_smul_high64", TY_LLONG, KIT_CG_INTRIN_SMUL_HIGH},
   };
   const BuiltinMulHighInfo* info = NULL;
   const Type* ty;
   size_t i;
   for (i = 0; i < sizeof infos / sizeof infos[0]; ++i) {
     if (sym_eq_cstr(p, name, infos[i].name)) {
       info = &infos[i];
       break;
     }
   }
   if (!info) return 0;
   ty = type_prim(p->pool, info->type_kind);
   advance(p);
   expect_punct(p, '(', "'(' after multiply-high builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, ty);
   expect_punct(p, ',', "',' in multiply-high builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, ty);
   expect_punct(p, ')', "')' after multiply-high builtin");
   c_cg_set_loc(p, loc);
   kit_cg_intrinsic(p->cg, info->intrin, 2, c_cg_tid(p, ty));
   c_cg_retag_top(p, ty);
   return 1;
 }
 
 /* The type-generic overflow builtins (no s/u + width suffix). They infer the
  * operation type from the result pointer's pointee and the signed/unsigned
  * intrinsic from that type's signedness, then reuse the same per-type
  * KIT_CG_INTRIN_*_OVERFLOW machinery as the explicit __builtin_smull_overflow
  * family. kit's own source uses these (e.g. cg_checked_scaled_offset), so they
  * must self-host. */
 typedef enum { OVF_ADD, OVF_SUB, OVF_MUL } OverflowOp;
 
 static int builtin_overflow_generic(Parser* p, Sym name, OverflowOp* op_out) {
   static const struct {
     OverflowOp op;
     const char* name;
   } g[] = {
       {OVF_ADD, "__builtin_add_overflow"},
       {OVF_SUB, "__builtin_sub_overflow"},
       {OVF_MUL, "__builtin_mul_overflow"},
   };
   size_t i;
   for (i = 0; i < sizeof(g) / sizeof(g[0]); ++i) {
     if (sym_eq_cstr(p, name, g[i].name)) {
       *op_out = g[i].op;
       return 1;
     }
   }
   return 0;
 }
 
 static KitCgIntrinsic overflow_intrin_for(OverflowOp op, int is_signed) {
   switch (op) {
     case OVF_ADD:
       return is_signed ? KIT_CG_INTRIN_SADD_OVERFLOW : KIT_CG_INTRIN_UADD_OVERFLOW;
     case OVF_SUB:
       return is_signed ? KIT_CG_INTRIN_SSUB_OVERFLOW : KIT_CG_INTRIN_USUB_OVERFLOW;
     case OVF_MUL:
     default:
       return is_signed ? KIT_CG_INTRIN_SMUL_OVERFLOW : KIT_CG_INTRIN_UMUL_OVERFLOW;
   }
 }
 
 static int parse_builtin_overflow_call(Parser* p, Sym name, SrcLoc loc) {
   BuiltinOverflowInfo info;
   OverflowOp gop = OVF_ADD;
   KitCgIntrinsic intrin;
   const Type* op_ty;
   const Type* ptr_ty;
   const Type* out_ty;
   const Type* bool_ty;
   FrameSlot ptr_slot;
   FrameSlot ov_slot;
   int is_generic;
 
   if (builtin_overflow_info(p, name, &info)) {
     is_generic = 0;
     intrin = info.intrin;
     op_ty = type_prim(p->pool, info.type_kind);
   } else if (builtin_overflow_generic(p, name, &gop)) {
     /* op_ty + intrin are resolved from the result pointee, parsed below. */
     is_generic = 1;
     intrin = KIT_CG_INTRIN_SADD_OVERFLOW;
     op_ty = NULL;
   } else {
     return 0;
   }
   bool_ty = type_prim(p->pool, TY_BOOL);
 
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after overflow builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   if (!is_generic) coerce_top_to_type(p, op_ty);
   expect_punct(p, ',', "',' in overflow builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   if (!is_generic) coerce_top_to_type(p, op_ty);
   expect_punct(p, ',', "',' in overflow builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   ptr_ty = c_cg_top_type(p);
   if (!ptr_ty || ptr_ty->kind != TY_PTR) {
     perr(p, "overflow builtin result argument must be a pointer");
   }
   out_ty = ptr_ty->ptr.pointee;
   if (is_generic) {
     /* Result type (and thus the operation type) is the pointee; operands are
      * coerced to it after the pointer is stashed (op_ty is unknown until now). */
     const Type* res = type_unqual(p->pool, out_ty);
     if (!type_is_int(res)) {
       perr(p, "__builtin_*_overflow result must point to an integer");
     }
     op_ty = res;
     intrin = overflow_intrin_for(gop, type_is_signed_integer(res));
   } else if (!type_compatible(type_unqual(p->pool, out_ty), op_ty)) {
     perr(p, "overflow builtin result pointer type mismatch");
   }
   expect_punct(p, ')', "')' after overflow builtin");
 
   ptr_slot = builtin_tmp_slot(p, ptr_ty);
   c_cg_push_local_typed(p, ptr_slot, ptr_ty);
   c_cg_swap(p);
   c_cg_store_void(p);
 
   if (is_generic) {
     /* Coerce both operands to the resolved op_ty now that the pointer is
      * stashed (stack is [a, b], b on top). */
     coerce_top_to_type(p, op_ty);
     c_cg_swap(p);
     coerce_top_to_type(p, op_ty);
     c_cg_swap(p);
   }
 
   c_cg_set_loc(p, loc);
   kit_cg_intrinsic(p->cg, intrin, 2, c_cg_tid(p, op_ty));
   c_cg_retag_at(p, 1, op_ty, 0);
   c_cg_retag_top(p, bool_ty);
 
   ov_slot = builtin_tmp_slot(p, bool_ty);
   c_cg_push_local_typed(p, ov_slot, bool_ty);
   c_cg_swap(p);
   c_cg_store_void(p);
 
   c_cg_push_local_typed(p, ptr_slot, ptr_ty);
   c_cg_load(p);
   c_cg_deref(p, out_ty);
   c_cg_swap(p);
   c_cg_store_void(p);
 
   c_cg_push_local_typed(p, ov_slot, bool_ty);
   c_cg_load(p);
   return 1;
 }
 
 static int parse_builtin_isnan_call(Parser* p, Sym name, SrcLoc loc) {
   const Type* arg_ty;
   if (name != p->sym_b_isnan) return 0;
 
   reject_general_regs_only_fp(p, "floating-point builtins");
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after __builtin_isnan");
   parse_assign_expr(p);
   to_rvalue(p);
   arg_ty = c_cg_top_type(p);
   if (!type_is_fp(arg_ty)) {
     perr(p, "__builtin_isnan argument must have floating type");
   }
   expect_punct(p, ')', "')' after __builtin_isnan");
 
   c_cg_set_loc(p, loc);
   c_cg_dup(p);
   c_cg_cmp(p, CMP_NE);
   return 1;
 }
 
 /* C99 floating comparison builtins (Route A). The five relational forms map
  * directly to ordered FP predicates (NaN -> false): isless/islessequal/
  * isgreater/isgreaterequal -> OLT/OLE/OGT/OGE (the same predicates the bare
  * `< <= > >=` operators produce, but as the explicit quiet macros), and
  * islessgreater -> ONE (ordered-and-not-equal). isunordered has no standalone
  * predicate in the CmpOp enum, so it is synthesized as (a != a) || (b != b)
  * using the unordered self-compare that __builtin_isnan already relies on. */
 static int parse_builtin_fp_cmp_call(Parser* p, Sym name, SrcLoc loc) {
   CmpOp cop;
   int is_unordered = 0;
   const Type* common;
 
   if (name == p->sym_b_isless) {
     cop = CMP_OLT_F;
   } else if (name == p->sym_b_islessequal) {
     cop = CMP_OLE_F;
   } else if (name == p->sym_b_isgreater) {
     cop = CMP_OGT_F;
   } else if (name == p->sym_b_isgreaterequal) {
     cop = CMP_OGE_F;
   } else if (name == p->sym_b_islessgreater) {
     cop = CMP_ONE_F;
   } else if (name == p->sym_b_isunordered) {
     cop = CMP_OEQ_F; /* unused; isunordered is synthesized below */
     is_unordered = 1;
   } else {
     return 0;
   }
 
   reject_general_regs_only_fp(p, "floating-point builtins");
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after floating comparison builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   if (!type_is_fp(c_cg_top_type(p))) {
     perr(p, "floating comparison builtin requires floating arguments");
   }
   expect_punct(p, ',', "',' between floating comparison builtin arguments");
   parse_assign_expr(p);
   to_rvalue(p);
   if (!type_is_fp(c_cg_top_type(p))) {
     perr(p, "floating comparison builtin requires floating arguments");
   }
   expect_punct(p, ')', "')' after floating comparison builtin");
 
   /* Bring both operands to a common floating type so the compare (and the
    * synthesized self-compares) see matching widths, mirroring the bare
    * relational path (parse_rel). */
   common = common_fp_type(p, c_cg_top2_type(p), c_cg_top_type(p));
   coerce_fp_cmp_operands(p, common);
 
   c_cg_set_loc(p, loc);
   if (!is_unordered) {
     c_cg_cmp(p, cop);
     return 1;
   }
 
   /* isunordered(a, b) == isnan(a) || isnan(b). Stash both operands, then OR the
    * two unordered self-compares (each yields the 0/1 int isnan result). */
   {
     FrameSlot slot_a = builtin_tmp_slot(p, common);
     FrameSlot slot_b = builtin_tmp_slot(p, common);
     /* stack: [a, b] */
     c_cg_push_local_typed(p, slot_b, common);
     c_cg_swap(p);
     c_cg_store_void(p);
     /* stack: [a] */
     c_cg_push_local_typed(p, slot_a, common);
     c_cg_swap(p);
     c_cg_store_void(p);
     /* stack: [] */
     c_cg_push_local_typed(p, slot_a, common);
     c_cg_load(p);
     c_cg_dup(p);
     c_cg_cmp(p, CMP_NE); /* isnan(a): unordered not-equal */
     c_cg_push_local_typed(p, slot_b, common);
     c_cg_load(p);
     c_cg_dup(p);
     c_cg_cmp(p, CMP_NE); /* isnan(b) */
     c_cg_binop(p, BO_OR);
   }
   return 1;
 }
 
 static const Type* builtin_math_fp_type(Parser* p, Sym name) {
   reject_general_regs_only_fp(p, "floating-point builtins");
   if (name == p->sym_b_fabsf || name == p->sym_b_inff ||
       name == p->sym_b_huge_valf || name == p->sym_b_nanf) {
     return type_prim(p->pool, TY_FLOAT);
   }
   if (name == p->sym_b_fabsl || name == p->sym_b_infl ||
       name == p->sym_b_huge_vall || name == p->sym_b_nanl) {
     return type_prim(p->pool, TY_LDOUBLE);
   }
   return type_prim(p->pool, TY_DOUBLE);
 }
 
 static int parse_builtin_inf_call(Parser* p, Sym name, SrcLoc loc) {
   const Type* ty;
   if (name != p->sym_b_inf && name != p->sym_b_inff && name != p->sym_b_infl &&
       name != p->sym_b_huge_val && name != p->sym_b_huge_valf &&
       name != p->sym_b_huge_vall) {
     return 0;
   }
 
   ty = builtin_math_fp_type(p, name);
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after floating builtin");
   expect_punct(p, ')', "')' after floating builtin");
   c_cg_set_loc(p, loc);
   c_cg_push_float(p, __builtin_inf(), ty);
   return 1;
 }
 
 /* __builtin_nan / nanf / nanl: produce a quiet NaN of the matching width.
  * The argument is a (constant) tag string selecting the NaN payload; kit
  * ignores the payload and always emits the default quiet NaN — matching the
  * `""` tag that <math.h>'s NAN expands to (__builtin_nanf("")). */
 static int parse_builtin_nan_call(Parser* p, Sym name, SrcLoc loc) {
   const Type* ty;
   if (name != p->sym_b_nan && name != p->sym_b_nanf && name != p->sym_b_nanl) {
     return 0;
   }
   ty = builtin_math_fp_type(p, name);
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after __builtin_nan");
   parse_assign_expr(p); /* the tag string — evaluated and discarded */
   to_rvalue(p);
   c_cg_drop(p);
   expect_punct(p, ')', "')' after __builtin_nan");
   c_cg_set_loc(p, loc);
   c_cg_push_float(p, __builtin_nan(""), ty);
   return 1;
 }
 
 /* __builtin_constant_p(expr): 1 if expr folds to a compile-time integer
  * constant, else 0. kit answers from what its single-pass front end can fold at
  * parse time — which matches GCC at -O0, where expressions GCC would fold only
  * under optimization also report 0. The operand's value is never used: it is
  * parsed and immediately dropped. kit's value stack is lazy, so a constant or
  * otherwise side-effect-free operand emits no code; only an operand containing
  * an eager side effect (a call) emits, and such an operand is never a constant
  * (so the result — 0 — is still correct). The result is a pushed integer
  * constant, usable anywhere a constant expression is. */
 static int parse_builtin_constant_p_call(Parser* p, Sym name, SrcLoc loc) {
   KitCgConstInt cval;
   int is_const;
   if (name != p->sym_b_constant_p) return 0;
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after __builtin_constant_p");
   c_const_guard_not_eval_push(p);
   parse_assign_expr(p);
   is_const = c_cg_emit_enabled(p) && kit_cg_top_const_int_ex(p->cg, &cval);
   c_cg_drop(p);
   c_const_guard_not_eval_pop(p);
   expect_punct(p, ')', "')' after __builtin_constant_p");
   c_cg_set_loc(p, loc);
   c_cg_push_int(p, is_const ? 1 : 0, ty_int(p));
   return 1;
 }
 
 static int parse_builtin_fabs_call(Parser* p, Sym name, SrcLoc loc) {
   const Type* ty;
   FrameSlot slot;
   CGLabel L_nonneg;
   CGLabel L_nonzero;
   if (name != p->sym_b_fabs && name != p->sym_b_fabsf &&
       name != p->sym_b_fabsl) {
     return 0;
   }
 
   ty = builtin_math_fp_type(p, name);
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after __builtin_fabs");
   parse_assign_expr(p);
   to_rvalue(p);
   if (!type_is_fp(c_cg_top_type(p))) {
     perr(p, "__builtin_fabs argument must have floating type");
   }
   coerce_top_to_type(p, ty);
   expect_punct(p, ')', "')' after __builtin_fabs");
 
   slot = builtin_tmp_slot(p, ty);
   c_cg_push_local_typed(p, slot, ty);
   c_cg_swap(p);
   c_cg_store_void(p);
 
   c_cg_set_loc(p, loc);
   c_cg_push_local_typed(p, slot, ty);
   c_cg_load(p);
   c_cg_push_float(p, 0.0, ty);
   c_cg_cmp(p, CMP_LT_F);
   L_nonneg = c_cg_label_new(p);
   c_cg_branch_false(p, L_nonneg);
   c_cg_push_local_typed(p, slot, ty);
   c_cg_push_local_typed(p, slot, ty);
   c_cg_load(p);
   c_cg_unop(p, UO_NEG);
   c_cg_store_void(p);
   c_cg_label_place(p, L_nonneg);
   c_cg_push_local_typed(p, slot, ty);
   c_cg_load(p);
   c_cg_push_float(p, 0.0, ty);
   c_cg_cmp(p, CMP_EQ);
   L_nonzero = c_cg_label_new(p);
   c_cg_branch_false(p, L_nonzero);
   c_cg_push_local_typed(p, slot, ty);
   c_cg_push_float(p, 0.0, ty);
   c_cg_store_void(p);
   c_cg_label_place(p, L_nonzero);
   c_cg_push_local_typed(p, slot, ty);
   c_cg_load(p);
   return 1;
 }
 
 static int parse_builtin_abs_call(Parser* p, Sym name, SrcLoc loc) {
   KitSlice name_sl = kit_sym_str(p->pool->c, name);
   size_t nlen = name_sl.len;
   const char* nm = name_sl.s;
   const char* libname = NULL;
   const Type* int_ty = NULL;
   const Type* params[1];
   const Type* fn_ty;
   KitCgSym sym;
 
   if (nm && nlen == 13u && memcmp(nm, "__builtin_abs", 13u) == 0) {
     libname = "abs";
     int_ty = type_prim(p->pool, TY_INT);
   } else if (nm && nlen == 14u && memcmp(nm, "__builtin_labs", 14u) == 0) {
     libname = "labs";
     int_ty = type_prim(p->pool, TY_LONG);
   } else if (nm && nlen == 15u && memcmp(nm, "__builtin_llabs", 15u) == 0) {
     libname = "llabs";
     int_ty = type_prim(p->pool, TY_LLONG);
   } else {
     return 0;
   }
 
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after abs builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, int_ty);
   expect_punct(p, ')', "')' after abs builtin");
 
   params[0] = int_ty;
   fn_ty = type_func(p->pool, int_ty, params, 1, 0);
   sym = builtin_libcall_sym(p, libname, fn_ty);
   c_cg_set_loc(p, loc);
   c_cg_call_symbol(p, sym, 1, fn_ty);
   return 1;
 }
 
 static int parse_kit_syscall_call(Parser* p, Sym name, SrcLoc loc) {
   const Type* long_ty;
   u32 arity = 0;
   u32 nargs;
   int found = 0;
 
   for (u32 i = 0; i < 7u; ++i) {
     if (name == p->sym_kit_syscall[i]) {
       arity = i;
       found = 1;
       break;
     }
   }
   if (!found) return 0;
 
   long_ty = type_prim(p->pool, TY_LONG);
   nargs = arity + 1u; /* syscall number plus payload args */
   advance(p);         /* IDENT */
   expect_punct(p, '(', "'(' after __kit_syscall");
   for (u32 i = 0; i < nargs; ++i) {
     if (i) expect_punct(p, ',', "',' in __kit_syscall");
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, long_ty);
   }
   expect_punct(p, ')', "')' after __kit_syscall");
 
   c_cg_set_loc(p, loc);
   c_cg_syscall(p, nargs, long_ty);
   return 1;
 }
 
 static int try_parse_builtin_call(Parser* p) {
   Sym name = tok_ident(&p->cur);
   SrcLoc loc = pp_materialize_loc(p->pp, p->cur.loc);
 
   /* A resolved-target feature query is a parser-folded integer constant, not a
    * runtime call, so it remains valid inside integer constant expressions. */
   if (parse_builtin_target_has_call(p, name)) return 1;
 
   if (c_const_guard_active(p) && name != p->sym_b_offsetof &&
       name != p->sym_b_constant_p) {
     c_const_guard_note_at(p, loc,
                           "function call in integer constant expression");
   }
 
   if (parse_kit_syscall_call(p, name, loc)) return 1;
 
   if (parse_builtin_bit_call(p, name, loc)) return 1;
   if (parse_builtin_rotate_call(p, name)) return 1;
   if (parse_builtin_prefetch_call(p, name, loc)) return 1;
   if (parse_builtin_assume_aligned_call(p, name, loc)) return 1;
   if (parse_builtin_cpu_relax_call(p, name, loc)) return 1;
   if (parse_builtin_carry_call(p, name, loc)) return 1;
   if (parse_builtin_mul_high_call(p, name, loc)) return 1;
 
   if (name == p->sym_b_memcpy || name == p->sym_b_memmove ||
       name == p->sym_b_memcmp || name == p->sym_b_memset) {
     return parse_builtin_mem_call(p, name, loc);
   }
 
   if (parse_builtin_overflow_call(p, name, loc)) return 1;
   if (parse_builtin_isnan_call(p, name, loc)) return 1;
   if (parse_builtin_fp_cmp_call(p, name, loc)) return 1;
   if (parse_builtin_inf_call(p, name, loc)) return 1;
   if (parse_builtin_nan_call(p, name, loc)) return 1;
   if (parse_builtin_constant_p_call(p, name, loc)) return 1;
   if (parse_builtin_fabs_call(p, name, loc)) return 1;
   if (parse_builtin_abs_call(p, name, loc)) return 1;
   if (parse_builtin_clear_cache_call(p, name, loc)) return 1;
 
   if (name != p->sym_b_alloca && name != p->sym_b_ctz &&
       name != p->sym_b_ctzl && name != p->sym_b_ctzll && name != p->sym_b_clz &&
       name != p->sym_b_clzl && name != p->sym_b_clzll &&
       name != p->sym_b_trap && name != p->sym_b_unreachable &&
       name != p->sym_b_return_address && name != p->sym_b_frame_address &&
       name != p->sym_b_readcyclecounter && name != p->sym_b_expect &&
       name != p->sym_b_offsetof && name != p->sym_b_va_start &&
       name != p->sym_b_va_arg && name != p->sym_b_va_end &&
       name != p->sym_b_va_copy && name != p->sym_a_load_n &&
       name != p->sym_a_store_n && name != p->sym_a_exchange_n &&
       name != p->sym_a_fetch_add && name != p->sym_a_fetch_sub &&
       name != p->sym_a_fetch_and && name != p->sym_a_fetch_or &&
       name != p->sym_a_fetch_xor && name != p->sym_a_fetch_nand &&
       name != p->sym_a_cas_n && name != p->sym_a_always_lock_free &&
       name != p->sym_a_is_lock_free && name != p->sym_a_thread_fence &&
       name != p->sym_a_signal_fence && name != p->sym_sync_synchronize) {
     return 0;
   }
   advance(p); /* IDENT */
   expect_punct(p, '(', "'(' after builtin");
 
   if (name == p->sym_b_offsetof) {
     const Type* root = parse_type_name(p);
     expect_punct(p, ',', "',' in __builtin_offsetof");
     u32 off = 0;
     (void)offsetof_designator(p, root, &off);
     expect_punct(p, ')', "')' after __builtin_offsetof");
     c_cg_push_int(p, (i64)off, ty_size_t(p));
     return 1;
   }
 
   if (name == p->sym_b_expect) {
     parse_assign_expr(p);
     to_rvalue(p);
     expect_punct(p, ',', "',' in __builtin_expect");
     parse_assign_expr(p);
     c_cg_drop(p);
     expect_punct(p, ')', "')' after __builtin_expect");
     return 1;
   }
 
   if (name == p->sym_b_alloca) {
     parse_assign_expr(p);
     to_rvalue(p);
     expect_punct(p, ')', "')' after __builtin_alloca");
     c_cg_set_loc(p, loc);
     c_cg_alloca(p);
     return 1;
   }
 
   if (name == p->sym_b_ctz || name == p->sym_b_ctzl || name == p->sym_b_ctzll) {
     parse_assign_expr(p);
     to_rvalue(p);
     expect_punct(p, ')', "')' after __builtin_ctz");
     c_cg_set_loc(p, loc);
     c_cg_intrinsic_unary_to_int(p, INTRIN_CTZ);
     return 1;
   }
 
   if (name == p->sym_b_clz || name == p->sym_b_clzl || name == p->sym_b_clzll) {
     parse_assign_expr(p);
     to_rvalue(p);
     expect_punct(p, ')', "')' after __builtin_clz");
     c_cg_set_loc(p, loc);
     /* The operand carries its own type, which drives the sf bit on
      * aarch64 / REX.W on x64 / sf on rv64. Whether the caller used the
      * `l` / `ll` suffix only changes the C-level type the user wrote;
      * kit picks the instruction width from the value type. */
     c_cg_intrinsic_unary_to_int(p, INTRIN_CLZ);
     return 1;
   }
 
   if (name == p->sym_b_trap || name == p->sym_b_unreachable) {
     expect_punct(p, ')', "')' after __builtin_trap/unreachable");
     c_cg_set_loc(p, loc);
     c_cg_intrinsic_void(
         p, name == p->sym_b_trap ? INTRIN_TRAP : INTRIN_UNREACHABLE);
     /* Both are noreturn at the C level. Push a dummy `int 0` so callers
      * that consume an expression value (e.g. ternary, comma) don't see
      * an empty stack — the dead value will be folded out. */
     c_cg_push_int(p, 0, ty_int(p));
     return 1;
   }
 
   if (name == p->sym_b_return_address || name == p->sym_b_frame_address) {
     /* GCC requires the level to be an integer constant expression. */
     int is_return = (name == p->sym_b_return_address);
     i64 level = eval_const_int(p, pp_materialize_loc(p->pp, p->cur.loc));
     expect_punct(p, ')',
                  "')' after __builtin_return_address/__builtin_frame_address");
     if (level < 0)
       perr(p, "__builtin_%s: level must be non-negative",
            is_return ? "return_address" : "frame_address");
     c_cg_set_loc(p, loc);
     c_cg_frame_or_return_address(p, is_return, (u32)level);
     return 1;
   }
 
   if (name == p->sym_b_readcyclecounter) {
     expect_punct(p, ')', "')' after __builtin_readcyclecounter");
     c_cg_set_loc(p, loc);
     c_cg_readcyclecounter(p);
     return 1;
   }
 
   if (name == p->sym_b_va_start) {
     parse_assign_expr(p);
     c_cg_addr(p);
     expect_punct(p, ',', "',' in __builtin_va_start");
     parse_assign_expr(p);
     c_cg_drop(p);
     expect_punct(p, ')', "')' after __builtin_va_start");
     c_cg_set_loc(p, loc);
     c_cg_va_start(p);
     c_cg_push_int(p, 0, ty_int(p));
     return 1;
   }
 
   if (name == p->sym_b_va_end) {
     parse_assign_expr(p);
     c_cg_addr(p);
     expect_punct(p, ')', "')' after __builtin_va_end");
     c_cg_set_loc(p, loc);
     c_cg_va_end(p);
     c_cg_push_int(p, 0, ty_int(p));
     return 1;
   }
 
   if (name == p->sym_b_va_copy) {
     parse_assign_expr(p);
     c_cg_addr(p);
     expect_punct(p, ',', "',' in __builtin_va_copy");
     parse_assign_expr(p);
     c_cg_addr(p);
     expect_punct(p, ')', "')' after __builtin_va_copy");
     c_cg_set_loc(p, loc);
     c_cg_va_copy(p);
     c_cg_push_int(p, 0, ty_int(p));
     return 1;
   }
 
   if (name == p->sym_b_va_arg) {
     parse_assign_expr(p);
     c_cg_addr(p);
     expect_punct(p, ',', "',' in __builtin_va_arg");
     const Type* ty = parse_type_name(p);
     expect_punct(p, ')', "')' after __builtin_va_arg");
     c_cg_set_loc(p, loc);
     c_cg_va_arg(p, ty);
     return 1;
   }
 
   if (name == p->sym_a_load_n) {
     parse_assign_expr(p);
     to_rvalue(p);
     expect_punct(p, ',', "',' in __atomic_load_n");
     MemOrder ord = parse_atomic_mem_order(p);
     expect_punct(p, ')', "')' after __atomic_load_n");
     c_cg_set_loc(p, loc);
     c_cg_atomic_load(p, ord);
     return 1;
   }
 
   if (name == p->sym_a_store_n) {
     parse_assign_expr(p);
     to_rvalue(p);
     const Type* val_ty =
         atomic_pointee_type(p, c_cg_top_type(p), "__atomic_store_n");
     expect_punct(p, ',', "',' in __atomic_store_n");
     parse_assign_expr(p);
     to_rvalue(p);
     coerce_top_to_type(p, val_ty);
     expect_punct(p, ',', "',' in __atomic_store_n");
     MemOrder ord = parse_atomic_mem_order(p);
     expect_punct(p, ')', "')' after __atomic_store_n");
     c_cg_set_loc(p, loc);
     c_cg_atomic_store(p, ord);
     c_cg_push_int(p, 0, ty_int(p));
     return 1;
   }
 
   if (name == p->sym_a_thread_fence || name == p->sym_a_signal_fence) {
     MemOrder ord = parse_atomic_mem_order(p);
     expect_punct(p, ')', "')' after atomic fence");
     c_cg_set_loc(p, loc);
     c_cg_fence(p, ord);
     c_cg_push_int(p, 0, ty_int(p));
     return 1;
   }
 
   /* __sync_synchronize(): the legacy GCC full barrier. No operands; always a
    * sequentially-consistent fence (the __sync_* family is implicitly seq-cst).
    */
   if (name == p->sym_sync_synchronize) {
     expect_punct(p, ')', "')' after __sync_synchronize");
     c_cg_set_loc(p, loc);
     c_cg_fence(p, MO_SEQ_CST);
     c_cg_push_int(p, 0, ty_int(p));
     return 1;
   }
 
   if (name == p->sym_a_always_lock_free || name == p->sym_a_is_lock_free) {
     i64 size = eval_const_int(p, pp_materialize_loc(p->pp, p->cur.loc));
     expect_punct(p, ',', "',' in atomic lock-free builtin");
     parse_assign_expr(p);
     to_rvalue(p);
     c_cg_drop(p);
     expect_punct(p, ')', "')' after atomic lock-free builtin");
     c_cg_push_int(p, atomic_lock_free_for_const_size(p, size), ty_int(p));
     return 1;
   }
 
   if (name == p->sym_a_cas_n) {
     parse_assign_expr(p);
     to_rvalue(p); /* ptr */
     const Type* obj_ty =
         atomic_pointee_type(p, c_cg_top_type(p), "__atomic_compare_exchange_n");
     expect_punct(p, ',', "',' in __atomic_compare_exchange_n");
 
     parse_assign_expr(p);
     to_rvalue(p); /* &expected */
     const Type* eptr_ty = c_cg_top_type(p);
     if (!eptr_ty || eptr_ty->kind != TY_PTR) {
       perr(p, "__atomic_compare_exchange_n: arg 2 must be a pointer");
     }
     const Type* val_ty = eptr_ty->ptr.pointee;
     if (val_ty != obj_ty) {
       val_ty = obj_ty;
     }
 
     FrameSlotDesc fsd;
     memset(&fsd, 0, sizeof fsd);
     fsd.type = eptr_ty;
     fsd.size = c_abi_sizeof(p->abi, p->pool, eptr_ty);
     fsd.align = c_abi_alignof(p->abi, p->pool, eptr_ty);
     fsd.kind = FS_LOCAL;
     FrameSlot eslot = c_cg_local(p, &fsd);
     c_cg_push_local_typed(p, eslot, eptr_ty);
     c_cg_swap(p);
     c_cg_store_void(p);
 
     c_cg_push_local_typed(p, eslot, eptr_ty);
     c_cg_load(p);
     c_cg_deref(p, val_ty);
     c_cg_load(p);
 
     expect_punct(p, ',', "',' in __atomic_compare_exchange_n");
     parse_assign_expr(p);
     to_rvalue(p); /* desired */
     coerce_top_to_type(p, val_ty);
     expect_punct(p, ',', "',' in __atomic_compare_exchange_n");
 
     (void)eval_const_int(p, pp_materialize_loc(p->pp, p->cur.loc)); /* weak */
     expect_punct(p, ',', "',' in __atomic_compare_exchange_n");
     MemOrder succ = parse_atomic_mem_order(p);
     expect_punct(p, ',', "',' in __atomic_compare_exchange_n");
     MemOrder fail = parse_atomic_mem_order(p);
     expect_punct(p, ')', "')' after __atomic_compare_exchange_n");
 
     c_cg_set_loc(p, loc);
     c_cg_atomic_cas(p, succ, fail);
 
     const Type* ok_ty = c_cg_top_type(p);
     FrameSlotDesc okd;
     memset(&okd, 0, sizeof okd);
     okd.type = ok_ty;
     okd.size = c_abi_sizeof(p->abi, p->pool, ok_ty);
     okd.align = c_abi_alignof(p->abi, p->pool, ok_ty);
     okd.kind = FS_LOCAL;
     FrameSlot okslot = c_cg_local(p, &okd);
     c_cg_push_local_typed(p, okslot, ok_ty);
     c_cg_swap(p);
     c_cg_store_void(p);
 
     FrameSlotDesc pd;
     memset(&pd, 0, sizeof pd);
     pd.type = val_ty;
     pd.size = c_abi_sizeof(p->abi, p->pool, val_ty);
     pd.align = c_abi_alignof(p->abi, p->pool, val_ty);
     pd.kind = FS_LOCAL;
     FrameSlot pslot = c_cg_local(p, &pd);
     c_cg_push_local_typed(p, pslot, val_ty);
     c_cg_swap(p);
     c_cg_store_void(p);
 
     c_cg_push_local_typed(p, okslot, ok_ty);
     c_cg_load(p);
     CGLabel L_done = c_cg_label_new(p);
     c_cg_branch_true(p, L_done);
     c_cg_push_local_typed(p, eslot, eptr_ty);
     c_cg_load(p);
     c_cg_deref(p, val_ty);
     c_cg_push_local_typed(p, pslot, val_ty);
     c_cg_load(p);
     c_cg_store_void(p);
     c_cg_label_place(p, L_done);
 
     c_cg_push_local_typed(p, okslot, ok_ty);
     c_cg_load(p);
     return 1;
   }
 
   AtomicOp op;
   if (name == p->sym_a_exchange_n)
     op = AO_XCHG;
   else if (name == p->sym_a_fetch_add)
     op = AO_ADD;
   else if (name == p->sym_a_fetch_sub)
     op = AO_SUB;
   else if (name == p->sym_a_fetch_and)
     op = AO_AND;
   else if (name == p->sym_a_fetch_or)
     op = AO_OR;
   else if (name == p->sym_a_fetch_xor)
     op = AO_XOR;
   else if (name == p->sym_a_fetch_nand)
     op = AO_NAND;
   else {
     perr(p, "internal: unhandled builtin");
   }
 
   parse_assign_expr(p);
   to_rvalue(p);
   const Type* val_ty =
       atomic_pointee_type(p, c_cg_top_type(p), "__atomic read-modify-write");
   expect_punct(p, ',', "',' in atomic builtin");
   parse_assign_expr(p);
   to_rvalue(p);
   coerce_top_to_type(p, val_ty);
   expect_punct(p, ',', "',' in atomic builtin");
   MemOrder ord = parse_atomic_mem_order(p);
   expect_punct(p, ')', "')' after atomic builtin");
   c_cg_set_loc(p, loc);
   c_cg_atomic_rmw(p, op, ord);
   return 1;
 }
 
 /* ============================================================
  * parse_primary, parse_postfix, parse_unary
  * ============================================================ */
 
 static void parse_primary(Parser* p) {
   Tok t = p->cur;
   if (t.kind == TOK_NUM) {
     i64 v = parse_int_literal(p, &t);
     const Type* lty = int_literal_type(p, &t);
     advance(p);
     c_cg_push_int(p, v, lty);
     return;
   }
   if (t.kind == TOK_FLT) {
     reject_general_regs_only_fp(p, "floating-point literals");
     double v = parse_float_literal(p, &t);
     const Type* lty = float_literal_type(p, &t);
     c_const_guard_note_at(p, pp_materialize_loc(p->pp, t.loc),
                           "integer constant expression required");
     advance(p);
     c_cg_push_float(p, v, lty);
     return;
   }
   if (is_punct(&t, '(')) {
     advance(p);
     parse_expr(p);
     expect_punct(p, ')', "')'");
     return;
   }
   if (t.kind == TOK_IDENT) {
     SymEntry* e;
     if (ident_kw_inline(p, tok_ident(&t)) != KW_NONE) {
       perr(p, "unexpected keyword in expression");
     }
     {
       Tok n = peek1(p);
       if (is_punct(&n, '(') && try_parse_builtin_call(p)) return;
     }
     /* try_parse_builtin_call may rewrite the current ident in-place
      * (e.g. __builtin_memcpy → memcpy) and return 0, asking us to
      * resume normal lookup with the rewritten name. */
     t = p->cur;
     /* C99 §6.4.2.2: `__func__` inside a function-body acts as
      *   static const char __func__[] = "<function-name>";
      * GCC also exposes `__FUNCTION__` and `__PRETTY_FUNCTION__` with
      * the same value. We synthesize the string lazily — the symbol
      * lives in .rodata and the resulting type is `char[N+1]` (with the
      * trailing NUL). */
     if (tok_ident(&t) == p->sym_func || tok_ident(&t) == p->sym_func_gcc ||
         tok_ident(&t) == p->sym_pretty_func_gcc) {
       c_const_guard_note_at(p, pp_materialize_loc(p->pp, t.loc),
                             "non-constant identifier in constant expression");
       if (p->cur_func_name == 0) {
         compiler_panic(
             p->c, pp_materialize_loc(p->pp, t.loc),
             "'%.*s' used outside a function",
             KIT_SLICE_ARG(kit_slice_cstr(
                 tok_ident(&t) == p->sym_func       ? "__func__"
                 : tok_ident(&t) == p->sym_func_gcc ? "__FUNCTION__"
                                                    : "__PRETTY_FUNCTION__")));
       }
       KitSlice fn_name_sl = kit_sym_str(p->pool->c, p->cur_func_name);
       size_t nlen = fn_name_sl.len;
       const char* fn_name = fn_name_sl.s;
       Heap* h = kit_compiler_context(p->c)->heap;
       u8* bytes = (u8*)h->alloc(h, nlen + 1u, 1u);
       ObjSymId sym;
       for (size_t i = 0; i < nlen; ++i) bytes[i] = (u8)fn_name[i];
       bytes[nlen] = 0;
       sym = c_cg_emit_enabled(p) ? emit_string_to_rodata(p, bytes, nlen + 1u)
                                  : OBJ_SYM_NONE;
       h->free(h, bytes, 0);
       advance(p);
       const Type* char_ty = type_prim(p->pool, TY_CHAR);
       const Type* arr_ty = type_array(p->pool, char_ty, (u32)(nlen + 1u), 0);
       c_cg_push_global(p, sym, arr_ty);
       return;
     }
     e = scope_lookup(p, tok_ident(&t));
     if (!e) {
       KitSlice ident_sl = kit_sym_str(p->pool->c, tok_ident(&t));
       size_t nlen = ident_sl.len;
       const char* nm = ident_sl.s;
       compiler_panic(p->c, pp_materialize_loc(p->pp, t.loc),
                      "undeclared identifier '%.*s'", (int)nlen, nm ? nm : "?");
     }
     if (e->kind != SEK_ENUM_CST) {
       c_const_guard_note_at(p, pp_materialize_loc(p->pp, t.loc),
                             "non-constant identifier in constant expression");
     }
     advance(p);
     switch (e->kind) {
       case SEK_LOCAL:
         c_cg_push_local_typed(p, e->v.slot, e->type);
         if (e->storage == DS_REGISTER) c_cg_set_top_register(p);
         if (e->vla_byte_slot != FRAME_SLOT_NONE) {
           p->last_pushed_vla_slot = e->vla_byte_slot;
         }
         if (e->vla_bounds) {
           p->last_pushed_vla_bounds = e->vla_bounds;
         }
         return;
       case SEK_GLOBAL:
       case SEK_FUNC:
         c_cg_push_global(p, e->v.sym, e->type);
         return;
       case SEK_ENUM_CST:
         c_cg_push_int(p, e->v.enum_value, e->type);
         return;
       case SEK_TYPEDEF:
       default:
         perr(p, "identifier is not a value");
     }
   }
   if (t.kind == TOK_CHR) {
     i64 v = decode_char_literal(p, &t);
     const Type* lty = char_literal_type(p, &t);
     advance(p);
     c_cg_push_int(p, v, lty);
     return;
   }
   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);
     u32 elem_size = c_abi_sizeof(p->abi, p->pool, elem_ty);
     ObjSymId sym = c_cg_emit_enabled(p)
                        ? emit_string_literal_to_rodata(p, bytes, n, elem_ty)
                        : OBJ_SYM_NONE;
     c_const_guard_note_at(
         p, pp_materialize_loc(p->pp, t.loc),
         "address constant is not an integer constant expression");
     kit_compiler_context(p->c)->heap->free(kit_compiler_context(p->c)->heap,
                                            bytes, 0);
     advance(p);
     {
       const Type* arr_ty =
           type_array(p->pool, elem_ty, elem_size ? (u32)(n / elem_size) : 0, 0);
       c_cg_push_global(p, sym, arr_ty);
     }
     return;
   }
   perr(p, "expected expression");
 }
 
 /* Resolve `mname` inside `rec_ty`, recursing through anonymous struct/union
  * members to arbitrary depth (like offsetof_find_member / find_field). On
  * success accumulates the cumulative byte offset into *out_off, records the
  * matched member type, and — for a bit-field leaf — the bit-field metadata
  * pulled from the final ABIFieldLayout. */
 static int find_record_member_path(Parser* p, const Type* rec_ty, Sym mname,
                                    const Type** out_ty, i64* out_off,
                                    u16* out_bf_off, u16* out_bf_w,
                                    u32* out_bf_ss) {
   const ABIRecordLayout* L;
   rec_ty = type_unqual(p->pool, rec_ty);
   if (!rec_ty || (rec_ty->kind != TY_STRUCT && rec_ty->kind != TY_UNION))
     return 0;
   L = c_abi_record_layout(p->abi, p->pool, rec_ty);
   if (!L) return 0;
   for (u16 i = 0; i < rec_ty->rec.nfields; ++i) {
     const Field* f = &rec_ty->rec.fields[i];
     if (f->name == mname && mname != 0) {
       const ABIFieldLayout* fl = &L->fields[i];
       *out_ty = f->type;
       *out_off += (i64)fl->offset;
       if (f->flags & FIELD_BITFIELD) {
         *out_bf_off = fl->bit_offset;
         *out_bf_w = fl->bit_width;
         *out_bf_ss = fl->storage_size;
       }
       return 1;
     }
   }
   for (u16 i = 0; i < rec_ty->rec.nfields; ++i) {
     const Field* f = &rec_ty->rec.fields[i];
     const Type* fty = type_unqual(p->pool, f->type);
     i64 nested_off;
     if (!((f->flags & FIELD_ANON) &&
           (fty->kind == TY_STRUCT || fty->kind == TY_UNION))) {
       continue;
     }
     nested_off = *out_off + (i64)L->fields[i].offset;
     if (find_record_member_path(p, fty, mname, out_ty, &nested_off, out_bf_off,
                                 out_bf_w, out_bf_ss)) {
       *out_off = nested_off;
       return 1;
     }
   }
   return 0;
 }
 
 static void parse_postfix(Parser* p) {
   VLABound* vla_bounds;
   p->last_pushed_vla_slot = FRAME_SLOT_NONE;
   p->last_pushed_vla_bounds = NULL;
   parse_primary(p);
   vla_bounds = p->last_pushed_vla_bounds;
   for (;;) {
     Tok t = p->cur;
     if (is_punct(&t, P_INC)) {
       c_const_guard_note_at(
           p, pp_materialize_loc(p->pp, t.loc),
           "increment/decrement in integer constant expression");
       advance(p);
       if (!c_cg_top_is_modifiable_lvalue(p)) {
         perr(p, "increment/decrement requires modifiable lvalue");
       }
       if (!c_type_is_scalar(c_cg_top_type(p))) {
         perr(p, "increment/decrement requires scalar operand");
       }
       c_cg_inc_dec(p, BO_IADD, /*post=*/1);
       continue;
     }
     if (is_punct(&t, P_DEC)) {
       c_const_guard_note_at(
           p, pp_materialize_loc(p->pp, t.loc),
           "increment/decrement in integer constant expression");
       advance(p);
       if (!c_cg_top_is_modifiable_lvalue(p)) {
         perr(p, "increment/decrement requires modifiable lvalue");
       }
       if (!c_type_is_scalar(c_cg_top_type(p))) {
         perr(p, "increment/decrement requires scalar operand");
       }
       c_cg_inc_dec(p, BO_ISUB, /*post=*/1);
       continue;
     }
     if (is_punct(&t, '(')) {
       const Type* top = c_cg_top_type(p);
       const Type* fn_type;
       c_const_guard_note_at(p, pp_materialize_loc(p->pp, t.loc),
                             "function call in integer constant expression");
       if (top && top->kind == TY_FUNC) {
         fn_type = top;
       } else if (top && top->kind == TY_PTR && top->ptr.pointee &&
                  top->ptr.pointee->kind == TY_FUNC) {
         fn_type = top->ptr.pointee;
         if (c_cg_top_is_lvalue(p)) c_cg_load(p);
       } else {
         perr(p, "called object is not a function");
       }
       advance(p); /* '(' */
       u32 nargs = 0;
       if (!is_punct(&p->cur, ')')) {
         for (;;) {
           const Type* param_ty =
               (nargs < fn_type->fn.nparams) ? fn_type->fn.params[nargs] : NULL;
           parse_assign_expr(p);
           to_rvalue(p);
           if (param_ty) {
             CSemCheck chk =
                 c_sem_check_assignment(p->pool, param_ty, c_cg_top_type(p));
             if (!chk.ok)
               perr(p, "%.*s", KIT_SLICE_ARG(kit_slice_cstr(chk.message)));
             coerce_top_to_type(p, param_ty);
           }
           ++nargs;
           if (!accept_punct(p, ',')) break;
         }
       }
       expect_punct(p, ')', "')' after argument list");
       if (fn_type->fn.nparams != nargs && !fn_type->fn.variadic) {
         perr(p, "wrong number of arguments");
       }
       if (fn_type->fn.variadic && nargs < fn_type->fn.nparams) {
         perr(p, "too few arguments to variadic function");
       }
       c_cg_call(p, nargs, fn_type);
       if (fn_type->fn.ret && fn_type->fn.ret->kind == TY_VOID) {
         c_cg_push_int(p, 0, ty_int(p));
       }
       continue;
     }
     if (is_punct(&t, '[')) {
       const Type* lt0 = c_cg_top_type(p);
       advance(p); /* '[' */
       if (lt0 && lt0->kind == TY_ARRAY) {
         decay_array_to_pointer(p, lt0);
       } else if (lt0 && lt0->kind == TY_PTR) {
         if (c_cg_top_is_lvalue(p)) c_cg_load(p);
       }
       parse_expr(p);
       {
         const Type* it0 = c_cg_top_type(p);
         if (it0 && it0->kind == TY_ARRAY) {
           decay_array_to_pointer(p, it0);
         } else {
           to_rvalue(p);
         }
       }
       expect_punct(p, ']', "']' after subscript");
       {
         const Type* lt = c_cg_top2_type(p);
         const Type* it = c_cg_top_type(p);
         const Type* elem;
         if (lt && lt->kind == TY_PTR && type_is_int(it)) {
           elem = lt->ptr.pointee;
         } else if (it && it->kind == TY_PTR && type_is_int(lt)) {
           c_cg_swap(p);
           elem = it->ptr.pointee;
         } else {
           perr(p, "invalid subscript: needs one pointer and one integer");
         }
         if (!elem) perr(p, "subscript on incomplete pointee");
         coerce_top_to_type(p, c_abi_ptrdiff_type(p->abi, p->pool));
         {
           FrameSlot elem_vla_slot = vla_size_slot_for_type(vla_bounds, elem);
           if (elem_vla_slot != FRAME_SLOT_NONE) {
             c_cg_push_local_typed(p, elem_vla_slot, ty_size_t(p));
             c_cg_load(p);
             c_cg_binop(p, BO_IMUL);
             c_cg_binop(p, BO_IADD);
             c_cg_deref(p, elem);
             p->last_pushed_vla_slot = elem_vla_slot;
             p->last_pushed_vla_bounds = vla_bounds;
           } else {
             u32 elem_size = c_abi_sizeof(p->abi, p->pool, elem);
             c_cg_lv_subscript(p, elem_size, elem);
           }
         }
       }
       continue;
     }
     if (is_punct(&t, '.')) {
       const Type* lt = c_cg_top_type(p);
       Sym mname;
       const Type* mty = NULL;
       i64 off = 0;
       u16 bf_off = 0, bf_w = 0;
       u32 bf_ss = 0;
       advance(p); /* '.' */
       if (!lt || (lt->kind != TY_STRUCT && lt->kind != TY_UNION)) {
         perr(p,
              "request for member in something that is not a struct or union");
       }
       if (p->cur.kind != TOK_IDENT ||
           ident_kw_inline(p, tok_ident(&p->cur)) != KW_NONE) {
         perr(p, "expected member name after '.'");
       }
       mname = tok_ident(&p->cur);
       advance(p);
       lt = type_unqual(p->pool, lt);
       if (!find_record_member_path(p, lt, mname, &mty, &off, &bf_off, &bf_w,
                                    &bf_ss))
         perr(p, "no such member");
       c_cg_lv_member(p, off, mty, bf_off, bf_w, bf_ss);
       continue;
     }
     if (is_punct(&t, P_ARROW)) {
       const Type* lt0;
       const Type* rec_ty;
       Sym mname;
       const Type* mty = NULL;
       i64 off = 0;
       u16 bf_off = 0, bf_w = 0;
       u32 bf_ss = 0;
       advance(p); /* `->` */
       to_rvalue(p);
       lt0 = c_cg_top_type(p);
       if (!lt0 || lt0->kind != TY_PTR) {
         perr(p, "'->' requires a pointer operand");
       }
       rec_ty = type_unqual(p->pool, lt0->ptr.pointee);
       if (!rec_ty || (rec_ty->kind != TY_STRUCT && rec_ty->kind != TY_UNION)) {
         perr(p, "'->' on pointer to non-struct/union");
       }
       if (p->cur.kind != TOK_IDENT ||
           ident_kw_inline(p, tok_ident(&p->cur)) != KW_NONE) {
         perr(p, "expected member name after '->'");
       }
       mname = tok_ident(&p->cur);
       advance(p);
       if (!find_record_member_path(p, rec_ty, mname, &mty, &off, &bf_off, &bf_w,
                                    &bf_ss))
         perr(p, "no such member");
       c_cg_deref(p, rec_ty);
       c_cg_lv_member(p, off, mty, bf_off, bf_w, bf_ss);
       continue;
     }
     break;
   }
 }
 
 void parse_unary(Parser* p) {
   Tok t = p->cur;
   if (is_punct(&t, '(')) {
     Tok n = peek1(p);
     if (starts_type_name(p, &n)) {
       const Type* dst;
       const Type* src;
       advance(p); /* '(' */
       dst = parse_type_name(p);
       expect_punct(p, ')', "')' after type-name");
       if (is_punct(&p->cur, '{')) {
         FrameSlotDesc fsd;
         FrameSlot slot;
         const Type* lit_ty = dst;
         if (lit_ty && lit_ty->kind == TY_ARRAY && lit_ty->arr.incomplete) {
           lit_ty = complete_incomplete_array(p, lit_ty);
         }
         memset(&fsd, 0, sizeof fsd);
         fsd.type = lit_ty;
         fsd.size = c_abi_sizeof(p->abi, p->pool, lit_ty);
         fsd.align = c_abi_alignof(p->abi, p->pool, lit_ty);
         fsd.kind = FS_LOCAL;
         fsd.flags = FSF_NONE;
         slot = c_cg_local(p, &fsd);
         init_at(p, slot, lit_ty, 0, lit_ty);
         c_cg_push_local_typed(p, slot, lit_ty);
         return;
       }
       if (c_const_guard_active(p) && p->cur.kind == TOK_FLT) {
         const Type* tu = type_unqual(p->pool, dst);
         if (tu && type_is_int(tu)) {
           double fv = parse_float_literal(p, &p->cur);
           advance(p);
           c_cg_push_int(p, (i64)fv, tu);
           return;
         }
       }
       parse_unary(p);
       to_rvalue(p);
       src = c_cg_top_type(p);
       if (dst && dst->kind == TY_VOID) {
         c_cg_drop(p);
         c_cg_push_int(p, 0, ty_int(p));
         return;
       }
       if (!c_type_is_scalar(dst) || !c_type_is_scalar(src)) {
         perr(p, "cast requires scalar type");
       }
       if (src && src->kind == TY_PTR && dst->kind == TY_PTR) {
         c_cg_convert(p, dst);
         return;
       }
       c_cg_convert(p, dst);
       return;
     }
   }
   if (is_punct(&t, '+')) {
     advance(p);
     parse_unary(p);
     to_rvalue(p);
     require_arith(p, c_cg_top_type(p), "unary '+'");
     return;
   }
   if (is_punct(&t, '-')) {
     advance(p);
     parse_unary(p);
     to_rvalue(p);
     require_arith(p, c_cg_top_type(p), "unary '-'");
     c_cg_unop(p, UO_NEG);
     return;
   }
   if (is_punct(&t, '!')) {
     advance(p);
     parse_unary(p);
     to_rvalue(p);
     require_scalar(p, c_cg_top_type(p), "unary '!'");
     c_cg_push_int(p, 0, ty_int(p));
     c_cg_cmp(p, CMP_EQ);
     return;
   }
   if (is_punct(&t, '~')) {
     advance(p);
     parse_unary(p);
     to_rvalue(p);
     if (!type_is_int(c_cg_top_type(p))) {
       perr(p, "unary '~' requires integer operand");
     }
     c_cg_unop(p, UO_BNOT);
     return;
   }
   if (is_punct(&t, P_AND)) {
     /* GNU labels-as-values: `&&label` yields the label's address as void*. */
     Sym name;
     SrcLoc loc;
     c_const_guard_note_at(
         p, pp_materialize_loc(p->pp, t.loc),
         "address constant is not an integer constant expression");
     advance(p); /* '&&' */
     if (p->cur.kind != TOK_IDENT ||
         ident_kw_inline(p, tok_ident(&p->cur)) != KW_NONE) {
       perr(p, "expected label name after '&&'");
     }
     name = tok_ident(&p->cur);
     loc = pp_materialize_loc(p->pp, p->cur.loc);
     advance(p);
     c_cg_push_label_addr(p, take_label_addr(p, name, loc));
     return;
   }
   if (is_punct(&t, '&')) {
     c_const_guard_note_at(
         p, pp_materialize_loc(p->pp, t.loc),
         "address constant is not an integer constant expression");
     advance(p);
     parse_unary(p);
     if (!c_cg_top_is_lvalue(p) &&
         !(c_cg_top_type(p) && c_cg_top_type(p)->kind == TY_FUNC)) {
       perr(p, "address-of requires lvalue operand");
     }
     if (c_cg_top_is_bitfield(p)) perr(p, "cannot take address of bit-field");
     if (c_cg_top_is_register(p))
       perr(p, "cannot take address of register object");
     c_stack_protector_note_address(p);
     c_cg_addr(p);
     return;
   }
   if (is_punct(&t, '*')) {
     const Type* pty;
     const Type* pointee;
     advance(p);
     parse_unary(p);
     to_rvalue(p);
     pty = c_cg_top_type(p);
     if (!pty || pty->kind != TY_PTR) {
       perr(p, "indirection requires pointer operand");
     }
     pointee = pty->ptr.pointee;
     if (pointee && pointee->kind == TY_VOID) {
       perr(p, "dereferencing pointer to incomplete type");
     }
     c_cg_deref(p, pointee);
     return;
   }
   if (is_punct(&t, P_INC) || is_punct(&t, P_DEC)) {
     BinOp bop = is_punct(&t, P_INC) ? BO_IADD : BO_ISUB;
     c_const_guard_note_at(p, pp_materialize_loc(p->pp, t.loc),
                           "increment/decrement in integer constant expression");
     advance(p);
     parse_unary(p);
     if (!c_cg_top_is_modifiable_lvalue(p)) {
       perr(p, "increment/decrement requires modifiable lvalue");
     }
     if (!c_type_is_scalar(c_cg_top_type(p))) {
       perr(p, "increment/decrement requires scalar operand");
     }
     c_cg_inc_dec(p, bop, /*post=*/0);
     return;
   }
   if (is_kw(p, &t, KW_SIZEOF)) {
     const Type* ty = NULL;
     FrameSlot vla_slot = FRAME_SLOT_NONE;
     advance(p);
     if (is_punct(&p->cur, '(')) {
       Tok n = peek1(p);
       if (starts_type_name(p, &n)) {
         advance(p);
         ty = parse_type_name(p);
         expect_punct(p, ')', "')'");
       } else {
         p->last_pushed_vla_slot = FRAME_SLOT_NONE;
         c_const_guard_not_eval_push(p);
         c_cg_codegen_suppress_push(p);
         parse_unary(p);
         ty = c_cg_top_type(p);
         vla_slot = p->last_pushed_vla_slot;
         if (c_cg_top_is_bitfield(p)) perr(p, "sizeof bit-field");
         c_cg_drop(p);
         c_cg_codegen_suppress_pop(p);
         c_const_guard_not_eval_pop(p);
       }
     } else {
       p->last_pushed_vla_slot = FRAME_SLOT_NONE;
       c_const_guard_not_eval_push(p);
       c_cg_codegen_suppress_push(p);
       parse_unary(p);
       ty = c_cg_top_type(p);
       vla_slot = p->last_pushed_vla_slot;
       if (c_cg_top_is_bitfield(p)) perr(p, "sizeof bit-field");
       c_cg_drop(p);
       c_cg_codegen_suppress_pop(p);
       c_const_guard_not_eval_pop(p);
     }
     if (vla_slot != FRAME_SLOT_NONE) {
       c_cg_push_local_typed(p, vla_slot, ty_size_t(p));
       c_cg_load(p);
     } else {
       require_sizeof_type(p, ty);
       c_cg_push_int(p, (i64)c_abi_sizeof(p->abi, p->pool, ty), ty_size_t(p));
     }
     return;
   }
   if (is_kw(p, &t, KW_GENERIC)) {
     advance(p);
     expect_punct(p, '(', "'('");
     c_const_guard_not_eval_push(p);
     c_cg_codegen_suppress_push(p);
     parse_assign_expr(p);
     to_rvalue(p);
     const Type* ctl_ty = c_cg_top_type(p);
     c_cg_drop(p);
     c_cg_codegen_suppress_pop(p);
     c_const_guard_not_eval_pop(p);
     expect_punct(p, ',', "','");
     int emitted = 0;
     Tok* default_buf = NULL;
     u32 default_len = 0;
     const Type** assoc_types = NULL;
     u32 assoc_n = 0;
     u32 assoc_cap = 0;
     int saw_default = 0;
     for (;;) {
       const Type* assoc_ty = NULL;
       int is_default = 0;
       if (is_kw(p, &p->cur, KW_DEFAULT)) {
         advance(p);
         is_default = 1;
         if (saw_default) perr(p, "_Generic has duplicate default association");
         saw_default = 1;
       } else {
         assoc_ty = parse_type_name(p);
         {
           const Type* au = type_unqual(p->pool, assoc_ty);
           for (u32 ai = 0; ai < assoc_n; ++ai) {
             if (type_compatible(assoc_types[ai], au)) {
               perr(p, "_Generic association type is duplicated");
             }
           }
           if (assoc_n == assoc_cap) {
             u32 nc = assoc_cap ? assoc_cap * 2u : 8u;
             const Type** nb = arena_array(p->pool->arena, const Type*, nc);
             if (!nb) perr(p, "out of memory recording _Generic associations");
             if (assoc_n) memcpy(nb, assoc_types, assoc_n * sizeof(*nb));
             assoc_types = nb;
             assoc_cap = nc;
           }
           assoc_types[assoc_n++] = au;
         }
       }
       expect_punct(p, ':', "':' in _Generic association");
       int take = 0;
       if (!emitted && !is_default && ctl_ty && assoc_ty &&
           type_compatible(type_unqual(p->pool, ctl_ty),
                           type_unqual(p->pool, assoc_ty))) {
         take = 1;
       }
       if (take) {
         parse_assign_expr(p);
         emitted = 1;
       } else if (is_default && !default_buf) {
         u32 cap = 16;
         Tok* buf = arena_array(p->pool->arena, Tok, cap);
         u32 len = 0;
         int paren_depth = 0, brack_depth = 0, brace_depth = 0;
         while (p->cur.kind != TOK_EOF) {
           if (paren_depth == 0 && brack_depth == 0 && brace_depth == 0) {
             if (is_punct(&p->cur, ',') || is_punct(&p->cur, ')')) break;
           }
           if (len == cap) {
             u32 new_cap = cap * 2;
             Tok* nv = arena_array(p->pool->arena, Tok, new_cap);
             if (!nv) perr(p, "out of memory recording _Generic default");
             memcpy(nv, buf, len * sizeof(Tok));
             buf = nv;
             cap = new_cap;
           }
           buf[len++] = p->cur;
           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);
         }
         if (len == cap) {
           u32 new_cap = cap + 1;
           Tok* nv = arena_array(p->pool->arena, Tok, new_cap);
           if (!nv) perr(p, "out of memory recording _Generic default");
           memcpy(nv, buf, len * sizeof(Tok));
           buf = nv;
           cap = new_cap;
         }
         memset(&buf[len], 0, sizeof(Tok));
         buf[len].kind = TOK_PUNCT;
         buf[len].aux = ',';
         ++len;
         default_buf = buf;
         default_len = len;
       } else {
         int paren_depth = 0;
         int brack_depth = 0;
         int brace_depth = 0;
         while (p->cur.kind != TOK_EOF) {
           if (paren_depth == 0 && brack_depth == 0 && brace_depth == 0) {
             if (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);
         }
       }
       if (!accept_punct(p, ',')) break;
     }
     if (!emitted && default_buf) {
       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 save_cur = p->cur;
       int save_has_next = p->has_next;
       p->replay = default_buf;
       p->replay_cap = default_len;
       p->replay_len = default_len;
       p->replay_pos = 1;
       p->replay_active = 1;
       p->cur = default_buf[0];
       p->has_next = 0;
       parse_assign_expr(p);
       emitted = 1;
       p->replay = save_replay;
       p->replay_cap = save_cap;
       p->replay_len = save_len;
       p->replay_pos = save_pos;
       p->replay_active = save_active;
       p->cur = save_cur;
       p->has_next = save_has_next;
     }
     expect_punct(p, ')', "')' after _Generic");
     if (!emitted) {
       perr(p, "_Generic: no association matched and no default present");
     }
     return;
   }
   if (is_kw(p, &t, KW_ALIGNOF)) {
     const Type* ty;
     advance(p);
     expect_punct(p, '(', "'('");
     if (starts_type_name(p, &p->cur)) {
       ty = parse_type_name(p);
     } else {
       c_const_guard_not_eval_push(p);
       c_cg_codegen_suppress_push(p);
       parse_unary(p);
       ty = c_cg_top_type(p);
       c_cg_drop(p);
       c_cg_codegen_suppress_pop(p);
       c_const_guard_not_eval_pop(p);
     }
     expect_punct(p, ')', "')'");
     c_cg_push_int(p, (i64)c_abi_alignof(p->abi, p->pool, ty), ty_size_t(p));
     return;
   }
   parse_postfix(p);
 }
 
 /* ============================================================
  * Binary operator levels
  * ============================================================ */
 
 static int type_is_fp(const Type* t) {
   return t &&
          (t->kind == TY_FLOAT || t->kind == TY_DOUBLE || t->kind == TY_LDOUBLE);
 }
 
 static const Type* common_fp_type(Parser* p, const Type* a, const Type* b) {
   if (!type_is_fp(a) && !type_is_fp(b)) return NULL;
   if ((a && a->kind == TY_LDOUBLE) || (b && b->kind == TY_LDOUBLE)) {
     return type_prim(p->pool, TY_LDOUBLE);
   }
   if ((a && a->kind == TY_DOUBLE) || (b && b->kind == TY_DOUBLE)) {
     return type_prim(p->pool, TY_DOUBLE);
   }
   return type_prim(p->pool, TY_FLOAT);
 }
 
 static void emit_fp_binop(Parser* p, BinOp bop, const Type* common) {
   if (c_cg_top_type(p) != common) c_cg_convert(p, common);
   c_cg_swap(p);
   if (c_cg_top_type(p) != common) c_cg_convert(p, common);
   c_cg_swap(p);
   BinOp fop;
   switch (bop) {
     case BO_IADD:
       fop = BO_FADD;
       break;
     case BO_ISUB:
       fop = BO_FSUB;
       break;
     case BO_IMUL:
       fop = BO_FMUL;
       break;
     case BO_SDIV:
       fop = BO_FDIV;
       break;
     default:
       perr(p, "operator does not apply to floating types");
       return;
   }
   c_cg_binop(p, fop);
 }
 
 static void coerce_fp_cmp_operands(Parser* p, const Type* common) {
   if (c_cg_top_type(p) != common) c_cg_convert(p, common);
   c_cg_swap(p);
   if (c_cg_top_type(p) != common) c_cg_convert(p, common);
   c_cg_swap(p);
 }
 
 static void coerce_arith_operands(Parser* p, const Type* common) {
   if (!common) return;
   if (c_cg_top_type(p) != common) c_cg_convert(p, common);
   c_cg_swap(p);
   if (c_cg_top_type(p) != common) c_cg_convert(p, common);
   c_cg_swap(p);
 }
 
 static CmpOp unsigned_rel_cmp(CmpOp cop) {
   switch (cop) {
     case CMP_LT_S:
       return CMP_LT_U;
     case CMP_LE_S:
       return CMP_LE_U;
     case CMP_GT_S:
       return CMP_GT_U;
     case CMP_GE_S:
       return CMP_GE_U;
     default:
       return cop;
   }
 }
 
 static BinOp int_div_rem_binop(BinOp op, const Type* common) {
   if (c_cg_type_is_signed(common)) return op;
   switch (op) {
     case BO_SDIV:
       return BO_UDIV;
     case BO_SREM:
       return BO_UREM;
     default:
       return op;
   }
 }
 
 static void parse_mul(Parser* p) {
   parse_unary(p);
   for (;;) {
     Tok t = p->cur;
     SrcLoc op_loc;
     BinOp bop;
     if (is_punct(&t, '*')) {
       bop = BO_IMUL;
     } else if (is_punct(&t, '/')) {
       bop = BO_SDIV;
     } else if (is_punct(&t, '%')) {
       bop = BO_SREM;
     } else {
       break;
     }
     op_loc = pp_materialize_loc(p->pp, t.loc);
     advance(p);
     to_rvalue(p);
     parse_unary(p);
     to_rvalue(p);
     const Type* lt = c_cg_top2_type(p);
     const Type* rt = c_cg_top_type(p);
     const Type* common = common_fp_type(p, lt, rt);
     if (bop == BO_SREM) {
       if (!type_is_int(lt) || !type_is_int(rt))
         perr(p, "operator '%' requires integer operands");
     } else if (!type_is_arith(lt) || !type_is_arith(rt)) {
       perr(p, "multiplicative operator requires arithmetic operands");
     }
     if (common) {
       emit_fp_binop(p, bop, common);
     } else {
       const Type* icommon = integer_common_type(p, lt, rt);
       BinOp ibop;
       coerce_arith_operands(p, icommon);
       ibop = int_div_rem_binop(bop, icommon);
       c_const_check_divrem(p, ibop, op_loc);
       c_cg_binop(p, ibop);
     }
   }
 }
 
 static void scale_pointer_index(Parser* p, u32 elem_size) {
   const Type* idx_ty = c_abi_ptrdiff_type(p->abi, p->pool);
   coerce_top_to_type(p, idx_ty);
   if (elem_size != 1) {
     c_cg_push_int(p, (i64)elem_size, idx_ty);
     c_cg_binop(p, BO_IMUL);
   }
 }
 
 static void emit_add_or_sub(Parser* p, BinOp bop) {
   const Type* lt = c_cg_top2_type(p);
   const Type* rt = c_cg_top_type(p);
   int l_is_ptr = lt && lt->kind == TY_PTR;
   int r_is_ptr = rt && rt->kind == TY_PTR;
   if (bop == BO_IADD) {
     if (l_is_ptr && r_is_ptr) {
       perr(p, "invalid operands to binary +");
     }
     if (l_is_ptr && type_is_int(rt)) {
       if (lt->ptr.pointee && lt->ptr.pointee->kind == TY_VOID)
         perr(p, "pointer arithmetic on void pointer");
       u32 esz = c_abi_sizeof(p->abi, p->pool, lt->ptr.pointee);
       scale_pointer_index(p, esz);
       c_cg_binop(p, BO_IADD);
       return;
     }
     if (r_is_ptr && type_is_int(lt)) {
       if (rt->ptr.pointee && rt->ptr.pointee->kind == TY_VOID)
         perr(p, "pointer arithmetic on void pointer");
       c_cg_swap(p);
       u32 esz = c_abi_sizeof(p->abi, p->pool, rt->ptr.pointee);
       scale_pointer_index(p, esz);
       c_cg_binop(p, BO_IADD);
       return;
     }
   } else { /* BO_ISUB */
     if (l_is_ptr && type_is_int(rt)) {
       if (lt->ptr.pointee && lt->ptr.pointee->kind == TY_VOID)
         perr(p, "pointer arithmetic on void pointer");
       u32 esz = c_abi_sizeof(p->abi, p->pool, lt->ptr.pointee);
       scale_pointer_index(p, esz);
       c_cg_binop(p, BO_ISUB);
       return;
     }
     if (l_is_ptr && r_is_ptr) {
       if (!pointer_pointees_compatible(p, lt, rt)) {
         perr(p, "subtraction of incompatible pointer types");
       }
       u32 esz = c_abi_sizeof(p->abi, p->pool, lt->ptr.pointee);
       c_cg_binop(p, BO_ISUB);
       if (esz != 1) {
         c_cg_push_int(p, (i64)esz, ty_size_t(p));
         c_cg_binop(p, BO_SDIV);
       }
       c_cg_convert(p, c_abi_ptrdiff_type(p->abi, p->pool));
       return;
     }
   }
   if (l_is_ptr || r_is_ptr) {
     perr(p, "invalid operands to additive operator");
   }
   const Type* common = common_fp_type(p, lt, rt);
   if (!common && (!type_is_arith(lt) || !type_is_arith(rt))) {
     perr(p, "additive operator requires arithmetic operands");
   }
   if (common) {
     emit_fp_binop(p, bop, common);
     return;
   }
   common = integer_common_type(p, lt, rt);
   coerce_arith_operands(p, common);
   c_cg_binop(p, bop);
 }
 
 static void parse_add(Parser* p) {
   parse_mul(p);
   for (;;) {
     Tok t = p->cur;
     BinOp bop;
     if (is_punct(&t, '+')) {
       bop = BO_IADD;
     } else if (is_punct(&t, '-')) {
       bop = BO_ISUB;
     } else {
       break;
     }
     advance(p);
     to_rvalue(p);
     parse_mul(p);
     to_rvalue(p);
     emit_add_or_sub(p, bop);
   }
 }
 
 static void parse_shift(Parser* p) {
   parse_add(p);
   for (;;) {
     Tok t = p->cur;
     SrcLoc op_loc;
     BinOp bop;
     if (is_punct(&t, P_SHL)) {
       bop = BO_SHL;
     } else if (is_punct(&t, P_SHR)) {
       bop = BO_SHR_S;
     } else {
       break;
     }
     op_loc = pp_materialize_loc(p->pp, t.loc);
     advance(p);
     to_rvalue(p);
     {
       const Type* lt = c_cg_top_type(p);
       const Type* lp = integer_promote_type(p, lt);
       if (!type_is_int(lt)) perr(p, "shift operator requires integer operands");
       if (c_cg_top_type(p) != lp) c_cg_convert(p, lp);
       if (bop == BO_SHR_S && !type_is_signed_integer(lp)) bop = BO_SHR_U;
     }
     parse_add(p);
     to_rvalue(p);
     {
       const Type* rt = c_cg_top_type(p);
       const Type* rp = integer_promote_type(p, rt);
       if (!type_is_int(rt)) perr(p, "shift operator requires integer operands");
       if (c_cg_top_type(p) != rp) c_cg_convert(p, rp);
     }
     if (!type_is_int(c_cg_top2_type(p)) || !type_is_int(c_cg_top_type(p))) {
       perr(p, "shift operator requires integer operands");
     }
     c_const_check_shift(p, bop, op_loc);
     c_cg_binop(p, bop);
   }
 }
 
 static void parse_rel(Parser* p) {
   parse_shift(p);
   for (;;) {
     Tok t = p->cur;
     CmpOp cop;
     if (is_punct(&t, '<')) {
       cop = CMP_LT_S;
     } else if (is_punct(&t, '>')) {
       cop = CMP_GT_S;
     } else if (is_punct(&t, P_LE)) {
       cop = CMP_LE_S;
     } else if (is_punct(&t, P_GE)) {
       cop = CMP_GE_S;
     } else {
       break;
     }
     advance(p);
     to_rvalue(p);
     parse_shift(p);
     to_rvalue(p);
     {
       const Type* lt = c_cg_top2_type(p);
       const Type* rt = c_cg_top_type(p);
       const Type* common = common_fp_type(p, lt, rt);
       if (lt && lt->kind == TY_PTR && rt && rt->kind == TY_PTR) {
         if (!pointer_pointees_compatible(p, lt, rt)) {
           perr(p, "comparison of incompatible pointer types");
         }
       } else if (!type_is_arith(lt) || !type_is_arith(rt)) {
         perr(p,
              "relational operator requires arithmetic or compatible pointer "
              "operands");
       }
       if (common) {
         coerce_fp_cmp_operands(p, common);
         switch (cop) {
           case CMP_LT_S:
             cop = CMP_LT_F;
             break;
           case CMP_LE_S:
             cop = CMP_LE_F;
             break;
           case CMP_GT_S:
             cop = CMP_GT_F;
             break;
           case CMP_GE_S:
             cop = CMP_GE_F;
             break;
           default:
             break;
         }
       } else if (type_is_arith(lt) && type_is_arith(rt)) {
         common = integer_common_type(p, lt, rt);
         coerce_arith_operands(p, common);
         if (!integer_type_signed(p, common)) cop = unsigned_rel_cmp(cop);
       }
     }
     c_cg_cmp(p, cop);
   }
 }
 
 static void parse_eq(Parser* p) {
   parse_rel(p);
   for (;;) {
     Tok t = p->cur;
     CmpOp cop;
     if (is_punct(&t, P_EQ)) {
       cop = CMP_EQ;
     } else if (is_punct(&t, P_NE)) {
       cop = CMP_NE;
     } else {
       break;
     }
     int lhs_null = null_pointer_constant(p, c_cg_top_type(p));
     advance(p);
     to_rvalue(p);
     parse_rel(p);
     to_rvalue(p);
     {
       const Type* lt = c_cg_top2_type(p);
       const Type* rt = c_cg_top_type(p);
       const Type* common = common_fp_type(p, lt, rt);
       int lnull = lhs_null;
       int rnull = null_pointer_constant(p, rt);
       if (lt && lt->kind == TY_PTR && rt && rt->kind == TY_PTR) {
         if (!type_is_void_ptr(lt) && !type_is_void_ptr(rt) &&
             !pointer_pointees_compatible(p, lt, rt)) {
           perr(p, "comparison of incompatible pointer types");
         }
       } else if ((lt && lt->kind == TY_PTR) || (rt && rt->kind == TY_PTR)) {
         if (!lnull && !rnull) perr(p, "comparison between pointer and integer");
       } else if (!type_is_arith(lt) || !type_is_arith(rt)) {
         perr(p, "equality operator requires scalar operands");
       }
       if (common)
         coerce_fp_cmp_operands(p, common);
       else if (type_is_arith(lt) && type_is_arith(rt)) {
         common = integer_common_type(p, lt, rt);
         coerce_arith_operands(p, common);
       }
     }
     c_cg_cmp(p, cop);
   }
 }
 
 static void parse_band(Parser* p) {
   parse_eq(p);
   while (is_punct(&p->cur, '&')) {
     advance(p);
     to_rvalue(p);
     parse_eq(p);
     to_rvalue(p);
     if (!type_is_int(c_cg_top2_type(p)) || !type_is_int(c_cg_top_type(p))) {
       perr(p, "bitwise operator requires integer operands");
     }
     coerce_arith_operands(
         p, integer_common_type(p, c_cg_top2_type(p), c_cg_top_type(p)));
     c_cg_binop(p, BO_AND);
   }
 }
 
 static void parse_bxor(Parser* p) {
   parse_band(p);
   while (is_punct(&p->cur, '^')) {
     advance(p);
     to_rvalue(p);
     parse_band(p);
     to_rvalue(p);
     if (!type_is_int(c_cg_top2_type(p)) || !type_is_int(c_cg_top_type(p))) {
       perr(p, "bitwise operator requires integer operands");
     }
     coerce_arith_operands(
         p, integer_common_type(p, c_cg_top2_type(p), c_cg_top_type(p)));
     c_cg_binop(p, BO_XOR);
   }
 }
 
 static void parse_bor(Parser* p) {
   parse_bxor(p);
   while (is_punct(&p->cur, '|')) {
     advance(p);
     to_rvalue(p);
     parse_bxor(p);
     to_rvalue(p);
     if (!type_is_int(c_cg_top2_type(p)) || !type_is_int(c_cg_top_type(p))) {
       perr(p, "bitwise operator requires integer operands");
     }
     coerce_arith_operands(
         p, integer_common_type(p, c_cg_top2_type(p), c_cg_top_type(p)));
     c_cg_binop(p, BO_OR);
   }
 }
 
 static FrameSlot ll_tmp_slot(Parser* p, const Type* ty) {
   FrameSlotDesc fsd;
   memset(&fsd, 0, sizeof fsd);
   fsd.type = ty;
   fsd.size = c_abi_sizeof(p->abi, p->pool, ty);
   fsd.align = c_abi_alignof(p->abi, p->pool, ty);
   fsd.kind = FS_LOCAL;
   fsd.flags = FSF_NONE;
   return c_cg_local(p, &fsd);
 }
 
 static void ll_store_const(Parser* p, FrameSlot tmp, const Type* ty, i64 v) {
   c_cg_push_local_typed(p, tmp, ty);
   c_cg_push_int(p, v, ty);
   c_cg_store_void(p);
 }
 
 static void parse_land(Parser* p) {
   parse_bor(p);
   while (is_punct(&p->cur, P_AND)) {
     CGLabel L_false = c_cg_label_new(p);
     CGLabel L_end = c_cg_label_new(p);
     const Type* result_ty = ty_int(p);
     FrameSlot tmp = ll_tmp_slot(p, result_ty);
     int lhs_known;
     int lhs_truth = 0;
     int rhs_truth = 0;
     advance(p);
     to_rvalue(p);
     require_scalar(p, c_cg_top_type(p), "logical '&&'");
     lhs_known = cg_top_const_truth(p, &lhs_truth);
     if (lhs_known && !lhs_truth) {
       c_cg_drop(p);
       c_const_guard_not_eval_push(p);
       c_cg_codegen_suppress_push(p);
       parse_bor(p);
       to_rvalue(p);
       require_scalar(p, c_cg_top_type(p), "logical '&&'");
       c_cg_drop(p);
       c_cg_codegen_suppress_pop(p);
       c_const_guard_not_eval_pop(p);
       c_cg_push_int(p, 0, result_ty);
       continue;
     }
     c_cg_branch_false(p, L_false);
     parse_bor(p);
     to_rvalue(p);
     require_scalar(p, c_cg_top_type(p), "logical '&&'");
     if (lhs_known && lhs_truth && cg_top_const_truth(p, &rhs_truth)) {
       c_cg_drop(p);
       c_cg_push_int(p, rhs_truth ? 1 : 0, result_ty);
       continue;
     }
     c_cg_branch_false(p, L_false);
     ll_store_const(p, tmp, result_ty, 1);
     c_cg_jump(p, L_end);
     c_cg_label_place(p, L_false);
     ll_store_const(p, tmp, result_ty, 0);
     c_cg_label_place(p, L_end);
     c_cg_push_local_typed(p, tmp, result_ty);
   }
 }
 
 static void parse_lor(Parser* p) {
   parse_land(p);
   while (is_punct(&p->cur, P_OR)) {
     CGLabel L_true = c_cg_label_new(p);
     CGLabel L_end = c_cg_label_new(p);
     const Type* result_ty = ty_int(p);
     FrameSlot tmp = ll_tmp_slot(p, result_ty);
     int lhs_known;
     int lhs_truth = 0;
     int rhs_truth = 0;
     advance(p);
     to_rvalue(p);
     require_scalar(p, c_cg_top_type(p), "logical '||'");
     lhs_known = cg_top_const_truth(p, &lhs_truth);
     if (lhs_known && lhs_truth) {
       c_cg_drop(p);
       c_const_guard_not_eval_push(p);
       c_cg_codegen_suppress_push(p);
       parse_land(p);
       to_rvalue(p);
       require_scalar(p, c_cg_top_type(p), "logical '||'");
       c_cg_drop(p);
       c_cg_codegen_suppress_pop(p);
       c_const_guard_not_eval_pop(p);
       c_cg_push_int(p, 1, result_ty);
       continue;
     }
     c_cg_branch_true(p, L_true);
     parse_land(p);
     to_rvalue(p);
     require_scalar(p, c_cg_top_type(p), "logical '||'");
     if (lhs_known && !lhs_truth && cg_top_const_truth(p, &rhs_truth)) {
       c_cg_drop(p);
       c_cg_push_int(p, rhs_truth ? 1 : 0, result_ty);
       continue;
     }
     c_cg_branch_true(p, L_true);
     ll_store_const(p, tmp, result_ty, 0);
     c_cg_jump(p, L_end);
     c_cg_label_place(p, L_true);
     ll_store_const(p, tmp, result_ty, 1);
     c_cg_label_place(p, L_end);
     c_cg_push_local_typed(p, tmp, result_ty);
   }
 }
 
 static void parse_ternary(Parser* p) {
   parse_lor(p);
   if (!is_punct(&p->cur, '?')) return;
   CGLabel L_else = c_cg_label_new(p);
   CGLabel L_then = c_cg_label_new(p);
   CGLabel L_end = c_cg_label_new(p);
   const Type* result_ty = ty_int(p);
   const Type* then_store_ty;
   int then_null = 0;
   FrameSlot then_tmp;
   FrameSlotDesc fsd;
   advance(p); /* '?' */
   to_rvalue(p);
   require_scalar(p, c_cg_top_type(p), "conditional operator");
   {
     int cond_truth = 0;
     if (c_const_guard_active(p) && cg_top_const_truth(p, &cond_truth)) {
       const Type* selected_ty;
       const Type* other_ty;
       const Type* common;
       c_cg_drop(p);
       if (cond_truth) {
         parse_expr(p);
         to_rvalue(p);
         selected_ty = c_cg_top_type(p);
         expect_punct(p, ':', "':' in ternary");
         c_const_guard_not_eval_push(p);
         c_cg_codegen_suppress_push(p);
         parse_assign_expr(p);
         to_rvalue(p);
         other_ty = c_cg_top_type(p);
         c_cg_drop(p);
         c_cg_codegen_suppress_pop(p);
         c_const_guard_not_eval_pop(p);
       } else {
         c_const_guard_not_eval_push(p);
         c_cg_codegen_suppress_push(p);
         parse_expr(p);
         to_rvalue(p);
         other_ty = c_cg_top_type(p);
         c_cg_drop(p);
         c_cg_codegen_suppress_pop(p);
         c_const_guard_not_eval_pop(p);
         expect_punct(p, ':', "':' in ternary");
         parse_assign_expr(p);
         to_rvalue(p);
         selected_ty = c_cg_top_type(p);
       }
       common = common_fp_type(p, selected_ty, other_ty);
       if (!common && type_is_int(selected_ty) && type_is_int(other_ty))
         common = integer_common_type(p, selected_ty, other_ty);
       if (common && c_cg_top_type(p) != common) c_cg_convert(p, common);
       return;
     }
   }
   c_cg_branch_false(p, L_else);
   parse_expr(p);
   to_rvalue(p);
   result_ty = c_cg_top_type(p);
   then_null = null_pointer_constant(p, result_ty);
   if (!result_ty) result_ty = ty_int(p);
   if (type_is_int(result_ty)) {
     result_ty = type_promoted(p->pool, result_ty);
     if (c_cg_top_type(p) != result_ty) c_cg_convert(p, result_ty);
   }
   then_store_ty = result_ty;
   memset(&fsd, 0, sizeof fsd);
   fsd.type = then_store_ty;
   fsd.size = c_abi_sizeof(p->abi, p->pool, then_store_ty);
   fsd.align = c_abi_alignof(p->abi, p->pool, then_store_ty);
   fsd.kind = FS_LOCAL;
   fsd.flags = FSF_NONE;
   then_tmp = c_cg_local(p, &fsd);
   if (c_cg_top_type(p) != then_store_ty) c_cg_convert(p, then_store_ty);
   c_cg_push_local_typed(p, then_tmp, then_store_ty);
   c_cg_swap(p);
   c_cg_store_void(p);
   c_cg_jump(p, L_then);
   c_cg_label_place(p, L_else);
   expect_punct(p, ':', "':' in ternary");
   parse_assign_expr(p);
   to_rvalue(p);
   {
     const Type* else_ty = c_cg_top_type(p);
     int else_null = null_pointer_constant(p, else_ty);
     const Type* common = common_fp_type(p, then_store_ty, else_ty);
     const Type* ptr_result = conditional_pointer_type(
         p, then_store_ty, then_null, else_ty, else_null);
     const Type* final_ty = then_store_ty;
     FrameSlot final_tmp = then_tmp;
     int use_final_tmp = 0;
 
     if (!common && type_is_int(then_store_ty) && type_is_int(else_ty))
       common = integer_common_type(p, then_store_ty, else_ty);
     if ((then_store_ty && then_store_ty->kind == TY_PTR) ||
         (else_ty && else_ty->kind == TY_PTR)) {
       if (!ptr_result) perr(p, "conditional operator pointer type mismatch");
       final_ty = ptr_result;
     } else if (type_is_arith(then_store_ty) && type_is_arith(else_ty)) {
       if (common) final_ty = common;
     } else if (!type_compatible(then_store_ty, else_ty)) {
       perr(p, "conditional operator type mismatch");
     }
 
     if (final_ty != then_store_ty) {
       FrameSlotDesc ffsd;
       memset(&ffsd, 0, sizeof ffsd);
       ffsd.type = final_ty;
       ffsd.size = c_abi_sizeof(p->abi, p->pool, final_ty);
       ffsd.align = c_abi_alignof(p->abi, p->pool, final_ty);
       ffsd.kind = FS_LOCAL;
       ffsd.flags = FSF_NONE;
       final_tmp = c_cg_local(p, &ffsd);
       use_final_tmp = 1;
     }
 
     if (c_cg_top_type(p) != final_ty) c_cg_convert(p, final_ty);
     c_cg_push_local_typed(p, final_tmp, final_ty);
     c_cg_swap(p);
     c_cg_store_void(p);
     c_cg_jump(p, L_end);
 
     c_cg_label_place(p, L_then);
     if (use_final_tmp) {
       c_cg_push_local_typed(p, then_tmp, then_store_ty);
       c_cg_load(p);
       if (c_cg_top_type(p) != final_ty) c_cg_convert(p, final_ty);
       c_cg_push_local_typed(p, final_tmp, final_ty);
       c_cg_swap(p);
       c_cg_store_void(p);
     }
 
     c_cg_label_place(p, L_end);
     c_cg_push_local_typed(p, final_tmp, final_ty);
     return;
   }
 }
 
 void parse_assign_expr(Parser* p) {
   parse_ternary(p);
   Tok t = p->cur;
   SrcLoc op_loc = pp_materialize_loc(p->pp, t.loc);
   BinOp compound;
   int is_simple_assign;
   if (is_punct(&t, '=')) {
     is_simple_assign = 1;
     compound = (BinOp)0;
   } else if (is_punct(&t, P_ADD_ASSIGN)) {
     is_simple_assign = 0;
     compound = BO_IADD;
   } else if (is_punct(&t, P_SUB_ASSIGN)) {
     is_simple_assign = 0;
     compound = BO_ISUB;
   } else if (is_punct(&t, P_MUL_ASSIGN)) {
     is_simple_assign = 0;
     compound = BO_IMUL;
   } else if (is_punct(&t, P_DIV_ASSIGN)) {
     is_simple_assign = 0;
     compound = BO_SDIV;
   } else if (is_punct(&t, P_MOD_ASSIGN)) {
     is_simple_assign = 0;
     compound = BO_SREM;
   } else if (is_punct(&t, P_AND_ASSIGN)) {
     is_simple_assign = 0;
     compound = BO_AND;
   } else if (is_punct(&t, P_OR_ASSIGN)) {
     is_simple_assign = 0;
     compound = BO_OR;
   } else if (is_punct(&t, P_XOR_ASSIGN)) {
     is_simple_assign = 0;
     compound = BO_XOR;
   } else if (is_punct(&t, P_SHL_ASSIGN)) {
     is_simple_assign = 0;
     compound = BO_SHL;
   } else if (is_punct(&t, P_SHR_ASSIGN)) {
     is_simple_assign = 0;
     compound = BO_SHR_S;
   } else {
     return;
   }
   c_const_guard_note_at(p, op_loc, "assignment in integer constant expression");
   if (!c_cg_top_is_modifiable_lvalue(p)) {
     perr(p, "assignment requires modifiable lvalue");
   }
   advance(p);
   const Type* lhs = c_cg_top_type(p);
   if (compound == BO_SHR_S && !type_is_signed_integer(lhs)) compound = BO_SHR_U;
   {
     if (lhs && (lhs->qual & Q_CONST)) {
       perr(p, "assignment to const-qualified object");
     }
   }
   if (is_simple_assign) {
     parse_assign_expr(p);
     to_rvalue(p);
     {
       const Type* rhs = c_cg_top_type(p);
       CSemCheck chk = c_sem_check_assignment(p->pool, lhs, rhs);
       if (!chk.ok) perr(p, "%.*s", KIT_SLICE_ARG(kit_slice_cstr(chk.message)));
     }
     coerce_top_to_lvalue(p);
     c_cg_store(p);
     return;
   }
   c_cg_dup(p);
   c_cg_load(p);
   parse_assign_expr(p);
   to_rvalue(p);
   {
     const Type* rhs = c_cg_top_type(p);
     int op = '+';
     switch (compound) {
       case BO_IADD:
         op = '+';
         break;
       case BO_ISUB:
         op = '-';
         break;
       case BO_IMUL:
         op = '*';
         break;
       case BO_SDIV:
         op = '/';
         break;
       case BO_SREM:
         op = '%';
         break;
       case BO_AND:
         op = '&';
         break;
       case BO_OR:
         op = '|';
         break;
       case BO_XOR:
         op = '^';
         break;
       case BO_SHL:
         op = '<';
         break;
       case BO_SHR_S:
         op = '>';
         break;
       case BO_SHR_U:
         op = '>';
         break;
       default:
         op = 0;
         break;
     }
     CSemCheck chk = c_sem_check_compound_assignment(p->pool, lhs, rhs, op);
     if (!chk.ok) perr(p, "%.*s", KIT_SLICE_ARG(kit_slice_cstr(chk.message)));
   }
   if (compound == BO_IADD || compound == BO_ISUB) {
     emit_add_or_sub(p, compound);
   } else {
     const Type* lt = c_cg_top2_type(p);
     const Type* rt = c_cg_top_type(p);
     const Type* common = common_fp_type(p, lt, rt);
     if (common) {
       if (compound == BO_SREM)
         perr(p, "operator '%%=' requires integer operands");
       emit_fp_binop(p, compound, common);
     } else {
       const Type* icommon = integer_common_type(p, lt, rt);
       coerce_arith_operands(p, icommon);
       c_cg_binop(p, int_div_rem_binop(compound, icommon));
     }
   }
   coerce_top_to_type(p, lhs);
   c_cg_retag_keep_flags(p, 1, lhs);
   c_cg_store(p);
 }
 
 void parse_expr(Parser* p) {
   parse_assign_expr(p);
   while (is_punct(&p->cur, ',')) {
     c_const_guard_note(p, "comma operator in integer constant expression");
     advance(p);
     c_cg_drop(p);
     parse_assign_expr(p);
   }
 }
 
 /* parse_cond_expr is the ternary level, provided for completeness */
 void parse_cond_expr(Parser* p) { parse_ternary(p); }