kit

builtins.c (61761B)

---

 #include <string.h>
 
 #include "internal.h"
 
 static KitCgMemAccess toy_mem_access_align(ToyParser* p, KitCgTypeId type,
                                            uint32_t align) {
   KitCgMemAccess access = toy_mem_access(p, type);
   access.align = align;
   return access;
 }
 
 static int toy_parse_mem_flags_tail(ToyParser* p, KitCgMemAccess* access) {
   static const ToyConstRow rows[] = {{"volatile", KIT_CG_MEM_VOLATILE}};
   return toy_parse_flag_set(p, rows, sizeof rows / sizeof rows[0],
                             "memory access flag", 1, &access->flags);
 }
 
 static void toy_store_top_to_local(ToyParser* p, KitCgLocal local,
                                    KitCgTypeId ty) {
   kit_cg_push_local(p->cg, local);
   kit_cg_swap(p->cg);
   kit_cg_store(p->cg, toy_mem_access(p, ty));
 }
 
 static void toy_store_const_to_local(ToyParser* p, KitCgLocal local,
                                      KitCgTypeId ty, uint64_t value) {
   kit_cg_push_local(p->cg, local);
   kit_cg_push_int(p->cg, value, ty);
   kit_cg_store(p->cg, toy_mem_access(p, ty));
 }
 
 static void toy_push_loaded_local(ToyParser* p, KitCgLocal local,
                                   KitCgTypeId ty) {
   kit_cg_push_local(p->cg, local);
   kit_cg_load(p->cg, toy_mem_access(p, ty));
 }
 
 static void toy_emit_dynamic_memory_loop(ToyParser* p, KitCgLocal dst_local,
                                          KitCgLocal src_local,
                                          KitCgLocal size_local, int is_memset,
                                          uint8_t set_value) {
   KitCgTypeId u8_ty = toy_builtin_type(p, KIT_CG_BUILTIN_I8);
   KitCgTypeId u8_ptr_ty = kit_cg_type_ptr(p->c, u8_ty, 0);
   KitCgLocal index_local = kit_cg_local(p->cg, p->size_type, toy_slot_attrs(0));
   KitCgLabel loop_label = kit_cg_label_new(p->cg);
   KitCgLabel end_label = kit_cg_label_new(p->cg);
 
   toy_store_const_to_local(p, index_local, p->size_type, 0);
   kit_cg_label_place(p->cg, loop_label);
 
   toy_push_loaded_local(p, index_local, p->size_type);
   toy_push_loaded_local(p, size_local, p->size_type);
   kit_cg_int_cmp(p->cg, KIT_CG_INT_LT_U);
   kit_cg_branch_false(p->cg, end_label);
 
   toy_push_loaded_local(p, dst_local, u8_ptr_ty);
   toy_push_loaded_local(p, index_local, p->size_type);
   /* Build the destination element place from [dst_ptr, index]; the element
    * scale = sizeof(u8) = 1 is derived from the base type. The store then
    * consumes [dst_place, value]. */
   kit_cg_elem(p->cg, 0);
   if (is_memset) {
     kit_cg_push_int(p->cg, set_value, u8_ty);
   } else {
     toy_push_loaded_local(p, src_local, u8_ptr_ty);
     toy_push_loaded_local(p, index_local, p->size_type);
     kit_cg_elem(p->cg, 0);
     kit_cg_load(p->cg, toy_mem_access(p, u8_ty));
   }
   kit_cg_store(p->cg, toy_mem_access(p, u8_ty));
 
   kit_cg_push_local(p->cg, index_local);
   toy_push_loaded_local(p, index_local, p->size_type);
   kit_cg_push_int(p->cg, 1, p->size_type);
   kit_cg_int_binop(p->cg, KIT_CG_INT_ADD, 0);
   kit_cg_store(p->cg, toy_mem_access(p, p->size_type));
 
   kit_cg_jump(p->cg, loop_label);
   kit_cg_label_place(p->cg, end_label);
 }
 
 static int toy_parse_memory_align_operand(ToyParser* p, int64_t* align,
                                           int* dynamic) {
   *align = 0;
   *dynamic = 0;
   if (!toy_parser_match(p, TOK_COMMA)) return 1;
   if (p->cur.kind == TOK_NUMBER && !p->cur.is_float)
     return toy_parse_number_arg(p, align);
   {
     KitCgTypeId ty = toy_parse_expr(p);
     if (ty == KIT_CG_TYPE_NONE) return 0;
     if (!toy_type_can_implicitly_cast(p, ty, p->size_type)) {
       toy_error(p, p->cur.loc, "memory alignment must be usize");
       return 0;
     }
     if (!toy_emit_implicit_cast(p, ty, p->size_type)) return 0;
     kit_cg_drop(p->cg);
     *dynamic = 1;
   }
   return 1;
 }
 
 static int toy_parse_access_group(ToyParser* p, KitCgMemAccess* access) {
   KitSym access_name = kit_sym_intern(p->c, KIT_SLICE_LIT("access"));
   if (p->cur.kind != TOK_IDENT || toy_tok_sym(p, p->cur) != access_name)
     return 0;
   toy_parser_advance(p);
   if (!toy_parser_expect(p, TOK_LPAREN)) {
     toy_error(p, p->cur.loc, "expected '(' after access");
     return 0;
   }
   while (p->cur.kind != TOK_RPAREN && p->cur.kind != TOK_EOF) {
     KitSym name;
     int64_t int_arg;
     if (!toy_parse_attr_dot_name(p, &name)) return 0;
     if (toy_sym_is(p, name, "align")) {
       if (!toy_parse_attr_int_arg(p, &int_arg) || int_arg < 0) return 0;
       access->align = (uint32_t)int_arg;
     } else if (toy_sym_is(p, name, "addrspace")) {
       if (!toy_parse_attr_int_arg(p, &int_arg) || int_arg < 0) return 0;
       access->address_space = (uint32_t)int_arg;
     } else if (toy_sym_is(p, name, "volatile")) {
       access->flags |= KIT_CG_MEM_VOLATILE;
     } else {
       toy_error(p, p->cur.loc, "unknown access entry");
       return 0;
     }
     if (!toy_parser_match(p, TOK_COMMA)) break;
   }
   if (!toy_parser_expect(p, TOK_RPAREN)) {
     toy_error(p, p->cur.loc, "expected ')' after access group");
     return 0;
   }
   return 1;
 }
 
 static int toy_parse_optional_access_arg(ToyParser* p, KitCgMemAccess* access) {
   if (!toy_parser_match(p, TOK_COMMA)) return 1;
   if (!toy_parse_access_group(p, access)) {
     toy_error(p, p->cur.loc, "expected access group");
     return 0;
   }
   return 1;
 }
 
 static int toy_parse_mem_order(ToyParser* p, KitCgMemOrder* out) {
   static const ToyConstRow rows[] = {
       {"relaxed", KIT_CG_MO_RELAXED}, {"consume", KIT_CG_MO_CONSUME},
       {"acquire", KIT_CG_MO_ACQUIRE}, {"release", KIT_CG_MO_RELEASE},
       {"acq_rel", KIT_CG_MO_ACQ_REL}, {"seq_cst", KIT_CG_MO_SEQ_CST},
   };
   uint64_t v;
   if (!toy_parse_dot_const(p, rows, sizeof rows / sizeof rows[0], 1,
                            "memory order", "memory order", &v))
     return 0;
   *out = (KitCgMemOrder)v;
   return 1;
 }
 
 static int toy_parse_atomic_op(ToyParser* p, KitCgAtomicOp* out) {
   static const ToyConstRow rows[] = {
       {"xchg", KIT_CG_ATOMIC_XCHG}, {"add", KIT_CG_ATOMIC_ADD},
       {"sub", KIT_CG_ATOMIC_SUB},   {"and", KIT_CG_ATOMIC_AND},
       {"or", KIT_CG_ATOMIC_OR},     {"xor", KIT_CG_ATOMIC_XOR},
       {"nand", KIT_CG_ATOMIC_NAND},
   };
   uint64_t v;
   if (!toy_parse_dot_const(p, rows, sizeof rows / sizeof rows[0], 0, NULL,
                            "atomic op", &v))
     return 0;
   *out = (KitCgAtomicOp)v;
   return 1;
 }
 
 static int toy_parse_cmpxchg_strength(ToyParser* p, int* weak_out) {
   static const ToyConstRow rows[] = {
       {"strong", 0},
       {"weak", 1},
   };
   uint64_t v;
   if (!toy_parse_dot_const(p, rows, sizeof rows / sizeof rows[0], 1,
                            "compare-exchange strength",
                            "compare-exchange strength", &v))
     return 0;
   *weak_out = (int)v;
   return 1;
 }
 
 static int toy_parse_call_attr(ToyParser* p, KitCgCallAttrs* attrs) {
   KitSym name;
   if (!toy_parse_attr_dot_name(p, &name)) return 0;
   if (toy_sym_is(p, name, "cold")) {
     attrs->flags |= KIT_CG_CALL_COLD;
   } else if (toy_sym_is(p, name, "tail") ||
              toy_sym_is(p, name, "tail_allowed")) {
     attrs->tail = KIT_CG_TAIL_ALLOWED;
   } else if (toy_sym_is(p, name, "musttail")) {
     attrs->tail = KIT_CG_TAIL_MUST;
   } else if (toy_sym_is(p, name, "notail") ||
              toy_sym_is(p, name, "tail_never")) {
     attrs->tail = KIT_CG_TAIL_DEFAULT;
   } else if (toy_sym_is(p, name, "inline")) {
     attrs->inline_policy = KIT_CG_INLINE_HINT;
   } else if (toy_sym_is(p, name, "always_inline")) {
     attrs->inline_policy = KIT_CG_INLINE_ALWAYS;
   } else if (toy_sym_is(p, name, "noinline")) {
     attrs->inline_policy = KIT_CG_INLINE_NEVER;
   } else {
     toy_error(p, p->cur.loc, "unknown call attribute");
     return 0;
   }
   return 1;
 }
 
 static int toy_parse_call_attr_tail(ToyParser* p, KitCgCallAttrs* attrs) {
   while (toy_parser_match(p, TOK_COMMA)) {
     if (p->cur.kind != TOK_DOT) {
       toy_error(p, p->cur.loc, "expected call attribute");
       return 0;
     }
     if (!toy_parse_call_attr(p, attrs)) return 0;
   }
   return 1;
 }
 
 static int toy_reject_tail_call_operand(ToyParser* p) {
   if (!p->tail_call_expr) return 0;
   toy_error(p, p->cur.loc, "tail @call must be returned directly");
   return 1;
 }
 
 static int toy_parse_call_braced_args(ToyParser* p, ToyToken call_tok,
                                       KitCgTypeId fn_ty,
                                       const ToyTypeId* toy_params,
                                       size_t toy_nparams, size_t* out_nargs) {
   uint32_t nparams = kit_cg_type_func_nparams(p->c, fn_ty);
   int variadic = kit_cg_type_func_is_variadic(p->c, fn_ty);
   size_t nargs = 0;
   if (!toy_parser_expect(p, TOK_LBRACE)) {
     toy_error(p, p->cur.loc, "expected braced call arguments");
     return 0;
   }
   if (p->cur.kind != TOK_RBRACE) {
     for (;;) {
       KitCgTypeId arg_ty = toy_parse_expr(p);
       if (arg_ty == KIT_CG_TYPE_NONE) return 0;
       if (toy_reject_tail_call_operand(p)) return 0;
       if (nargs < nparams) {
         KitCgFuncParam param =
             kit_cg_type_func_param(p->c, fn_ty, (uint32_t)nargs);
         ToyTypeId expected = (toy_params && nargs < toy_nparams)
                                  ? toy_params[nargs]
                                  : TOY_TYPE_NONE;
         ToyTypeId actual = p->last_type;
         if (expected != TOY_TYPE_NONE &&
             !toy_type_accepts_type(p, expected, actual)) {
           toy_error(p, call_tok.loc, "function argument type mismatch");
           return 0;
         }
         if (expected == TOY_TYPE_NONE &&
             !toy_type_can_implicitly_cast(p, arg_ty, param.type)) {
           toy_error(p, call_tok.loc, "function argument type mismatch");
           return 0;
         }
         if (arg_ty != param.type) {
           if (expected != TOY_TYPE_NONE) {
             if (!toy_emit_checked_cast(p, arg_ty, param.type)) return 0;
           } else if (!toy_emit_implicit_cast(p, arg_ty, param.type)) {
             return 0;
           }
         }
       } else if (!variadic) {
         toy_error(p, call_tok.loc, "too many arguments");
         return 0;
       }
       ++nargs;
       if (!toy_parser_match(p, TOK_COMMA)) break;
       if (p->cur.kind == TOK_RBRACE) break;
     }
   }
   if (!toy_parser_expect(p, TOK_RBRACE)) {
     toy_error(p, p->cur.loc, "expected '}' after call arguments");
     return 0;
   }
   if (nargs < nparams) {
     toy_error(p, call_tok.loc, "too few arguments");
     return 0;
   }
   *out_nargs = nargs;
   return 1;
 }
 
 static KitCgTypeId toy_parse_call_builtin(ToyParser* p) {
   KitCgCallAttrs attrs;
   ToyFn* fn = NULL;
   KitCgTypeId fn_ty = KIT_CG_TYPE_NONE;
   KitCgTypeId ret_ty;
   const ToyType* source_fn_type = NULL;
   ToyTypeId ret_toy_type = TOY_TYPE_NONE;
   ToyToken call_tok;
   int direct = 0;
   size_t nargs = 0;
   int tail;
   memset(&attrs, 0, sizeof attrs);
   if (!toy_parser_expect(p, TOK_LPAREN)) return KIT_CG_TYPE_NONE;
   call_tok = p->cur;
   if (p->cur.kind == TOK_IDENT) {
     KitSym callee_name = toy_tok_sym(p, p->cur);
     fn = toy_find_fn(p, callee_name);
     if (fn) {
       direct = 1;
       fn_ty = fn->type;
       ret_toy_type = fn->toy_ret;
       toy_parser_advance(p);
     }
   }
   if (!direct) {
     KitCgTypeId callee_ty = toy_parse_expr(p);
     ToyTypeId callee_toy_type = p->last_type;
     if (callee_ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (toy_reject_tail_call_operand(p)) return KIT_CG_TYPE_NONE;
     fn_ty = toy_ptr_pointee_func_type(p, callee_ty);
     if (fn_ty == KIT_CG_TYPE_NONE) {
       toy_error(p, call_tok.loc, "@call callee is not a function pointer");
       return KIT_CG_TYPE_NONE;
     }
     source_fn_type = toy_type_get(p, toy_type_pointee(p, callee_toy_type));
     if (source_fn_type && source_fn_type->kind != TOY_TYPE_FUNC)
       source_fn_type = NULL;
     if (source_fn_type) ret_toy_type = source_fn_type->ret;
   }
   if (!toy_expect_comma(p)) return KIT_CG_TYPE_NONE;
   if (!toy_parse_call_braced_args(
           p, call_tok, fn_ty,
           direct ? fn->toy_params
                  : (source_fn_type ? source_fn_type->params : NULL),
           direct ? fn->nparams : (source_fn_type ? source_fn_type->nparams : 0),
           &nargs)) {
     return KIT_CG_TYPE_NONE;
   }
   if (!toy_parse_call_attr_tail(p, &attrs)) return KIT_CG_TYPE_NONE;
   if (!toy_parser_expect(p, TOK_RPAREN)) return KIT_CG_TYPE_NONE;
 
   ret_ty = toy_cg_func_ret(p, fn_ty);
   tail = attrs.tail == KIT_CG_TAIL_ALLOWED || attrs.tail == KIT_CG_TAIL_MUST;
   if (tail && !p->allow_tail_call_expr) {
     toy_error(p, call_tok.loc, "tail @call requires return");
     return KIT_CG_TYPE_NONE;
   }
 
   if (!ret_toy_type) ret_toy_type = toy_type_from_cg(p, ret_ty);
   if (tail) {
     p->tail_call_expr = 1;
     p->tail_call_ret_toy = ret_toy_type;
     if (p->cur_fn_ret_toy != TOY_TYPE_NONE && ret_toy_type != TOY_TYPE_NONE &&
         !toy_type_accepts_type(p, p->cur_fn_ret_toy, ret_toy_type)) {
       p->last_type = ret_toy_type;
       return ret_ty;
     }
   }
 
   if (direct)
     kit_cg_call_symbol(p->cg, toy_fn_cur_sym(p, fn), (uint32_t)nargs, attrs);
   else
     kit_cg_call(p->cg, (uint32_t)nargs, fn_ty, attrs);
   p->last_type = ret_toy_type;
   return ret_ty;
 }
 
 static int toy_parse_barrier_scope(ToyParser* p, KitCgBarrierScope* out) {
   static const ToyConstRow rows[] = {
       {"full", KIT_CG_BARRIER_FULL},
       {"inner", KIT_CG_BARRIER_INNER},
       {"inner_store", KIT_CG_BARRIER_INNER_STORE},
       {"outer", KIT_CG_BARRIER_OUTER},
       {"outer_store", KIT_CG_BARRIER_OUTER_STORE},
       {"non_share", KIT_CG_BARRIER_NON_SHARE},
   };
   uint64_t v;
   if (!toy_parse_dot_const(p, rows, sizeof rows / sizeof rows[0], 0, NULL,
                            "barrier scope", &v))
     return 0;
   *out = (KitCgBarrierScope)v;
   return 1;
 }
 
 static KitCgTypeId toy_unsupported_intrinsic(ToyParser* p) {
   toy_error(p, p->cur.loc, "unsupported target intrinsic");
   return KIT_CG_TYPE_NONE;
 }
 
 KitCgTypeId toy_parse_builtin_call(ToyParser* p, KitSym name, int* recognized) {
   *recognized = 1;
 
   if (toy_sym_is(p, name, "call")) return toy_parse_call_builtin(p);
 
   if (toy_sym_is(p, name, "popcount") || toy_sym_is(p, name, "ctz") ||
       toy_sym_is(p, name, "clz") || toy_sym_is(p, name, "bswap")) {
     KitCgIntrinsic intrin = KIT_CG_INTRIN_POPCOUNT;
     KitCgTypeId ty;
     if (toy_sym_is(p, name, "ctz"))
       intrin = KIT_CG_INTRIN_CTZ;
     else if (toy_sym_is(p, name, "clz"))
       intrin = KIT_CG_INTRIN_CLZ;
     else if (toy_sym_is(p, name, "bswap"))
       intrin = KIT_CG_INTRIN_BSWAP;
     toy_parser_advance(p); /* ( */
     ty = toy_parse_expr(p);
     if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (!toy_parser_expect(p, TOK_RPAREN)) {
       toy_error(p, p->cur.loc, "expected ')'");
       return KIT_CG_TYPE_NONE;
     }
     if (!toy_type_is_intlike(p, ty)) {
       toy_error(p, p->cur.loc, "integer intrinsic expects integer operand");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_intrinsic(p->cg, intrin, 1, ty);
     return ty;
   }
 
   if (toy_sym_is(p, name, "frame_address") ||
       toy_sym_is(p, name, "return_address")) {
     /* __builtin_frame_address / __builtin_return_address. The constant level
      * rides as a single immediate operand; the result is a void*. */
     KitCgIntrinsic intrin = toy_sym_is(p, name, "return_address")
                                 ? KIT_CG_INTRIN_RETURN_ADDRESS
                                 : KIT_CG_INTRIN_FRAME_ADDRESS;
     KitCgTypeId void_ptr =
         kit_cg_type_ptr(p->c, toy_builtin_type(p, KIT_CG_BUILTIN_VOID), 0);
     KitCgTypeId level_ty;
     if (!toy_parser_expect(p, TOK_LPAREN)) return KIT_CG_TYPE_NONE;
     level_ty = toy_parse_expr(p);
     if (level_ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (!toy_type_is_intlike(p, level_ty)) {
       toy_error(p, p->cur.loc, "frame/return address level must be integer");
       return KIT_CG_TYPE_NONE;
     }
     if (!toy_parser_expect(p, TOK_RPAREN)) {
       toy_error(p, p->cur.loc, "expected ')'");
       return KIT_CG_TYPE_NONE;
     }
     if (!kit_cg_target_supports_intrinsic(p->c, intrin))
       return toy_unsupported_intrinsic(p);
     kit_cg_intrinsic(p->cg, intrin, 1, void_ptr);
     return void_ptr;
   }
 
   if (toy_sym_is(p, name, "expect")) {
     KitCgTypeId a, b;
     toy_parser_advance(p);
     a = toy_parse_expr(p);
     if (a == KIT_CG_TYPE_NONE || !toy_expect_comma(p)) return KIT_CG_TYPE_NONE;
     b = toy_parse_expr(p);
     if (b == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (!toy_parser_expect(p, TOK_RPAREN)) return KIT_CG_TYPE_NONE;
     if (a != b) {
       toy_error(p, p->cur.loc, "expect operands must have matching type");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_intrinsic(p->cg, KIT_CG_INTRIN_EXPECT, 2, a);
     return a;
   }
 
   if (toy_sym_is(p, name, "trap")) {
     if (!toy_parser_expect(p, TOK_LPAREN) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_intrinsic(p->cg, KIT_CG_INTRIN_TRAP, 0,
                      toy_builtin_type(p, KIT_CG_BUILTIN_VOID));
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
 
   if (toy_sym_is(p, name, "cpu_nop") || toy_sym_is(p, name, "cpu_yield") ||
       toy_sym_is(p, name, "irq_disable") || toy_sym_is(p, name, "irq_enable") ||
       toy_sym_is(p, name, "isb")) {
     KitCgIntrinsic intrin = KIT_CG_INTRIN_CPU_NOP;
     if (toy_sym_is(p, name, "cpu_yield"))
       intrin = KIT_CG_INTRIN_CPU_YIELD;
     else if (toy_sym_is(p, name, "irq_disable"))
       intrin = KIT_CG_INTRIN_IRQ_DISABLE;
     else if (toy_sym_is(p, name, "irq_enable"))
       intrin = KIT_CG_INTRIN_IRQ_ENABLE;
     else if (toy_sym_is(p, name, "isb"))
       intrin = KIT_CG_INTRIN_ISB;
     if (!toy_parser_expect(p, TOK_LPAREN) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!kit_cg_target_supports_intrinsic(p->c, intrin))
       return toy_unsupported_intrinsic(p);
     kit_cg_intrinsic(p->cg, intrin, 0,
                      toy_builtin_type(p, KIT_CG_BUILTIN_VOID));
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
 
   /* C99-style floating comparison builtins (Route A). Five map directly to an
    * ordered FP predicate (NaN -> false); @islessgreater is ordered-and-not-
    * equal (ONE), reachable only here (toy `!=` is the unordered UNE). The
    * unordered duals are reached separately via `!(a < b)` etc. (Route B).
    * @isunordered has no standalone predicate, so it is synthesized as
    * isnan(a) || isnan(b), where UNE(x, x) is isnan(x). */
   if (toy_sym_is(p, name, "isless") || toy_sym_is(p, name, "islessequal") ||
       toy_sym_is(p, name, "isgreater") ||
       toy_sym_is(p, name, "isgreaterequal") ||
       toy_sym_is(p, name, "islessgreater") ||
       toy_sym_is(p, name, "isunordered")) {
     KitCgTypeId a, b;
     KitCgFpCmpOp pred = KIT_CG_FP_OLT;
     int is_unordered = toy_sym_is(p, name, "isunordered");
     if (toy_sym_is(p, name, "islessequal"))
       pred = KIT_CG_FP_OLE;
     else if (toy_sym_is(p, name, "isgreater"))
       pred = KIT_CG_FP_OGT;
     else if (toy_sym_is(p, name, "isgreaterequal"))
       pred = KIT_CG_FP_OGE;
     else if (toy_sym_is(p, name, "islessgreater"))
       pred = KIT_CG_FP_ONE;
     if (!toy_parser_expect(p, TOK_LPAREN)) return KIT_CG_TYPE_NONE;
     a = toy_parse_expr(p);
     if (a == KIT_CG_TYPE_NONE || !toy_expect_comma(p)) return KIT_CG_TYPE_NONE;
     b = toy_parse_expr(p);
     if (b == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (a != b || !toy_type_is_float(p, a)) {
       toy_error(p, p->cur.loc,
                 "floating comparison builtin expects two floating operands of "
                 "the same type");
       return KIT_CG_TYPE_NONE;
     }
     if (is_unordered) {
       /* stack: [a, b] -> isnan(b) then isnan(a), OR'd. */
       kit_cg_dup(p->cg);                   /* [a, b, b] */
       kit_cg_fp_cmp(p->cg, KIT_CG_FP_UNE); /* [a, isnan_b] */
       kit_cg_swap(p->cg);                  /* [isnan_b, a] */
       kit_cg_dup(p->cg);                   /* [isnan_b, a, a] */
       kit_cg_fp_cmp(p->cg, KIT_CG_FP_UNE); /* [isnan_b, isnan_a] */
       kit_cg_int_binop(p->cg, KIT_CG_INT_OR, 0);
     } else {
       kit_cg_fp_cmp(p->cg, pred);
     }
     /* Widen the i32 0/1 to the toy int type, matching the comparison operators
      * (toy_parse_expr_cmp zext's its result), so the builtin composes in
      * arithmetic the same way `a < b` does. */
     kit_cg_zext(p->cg, p->int_type);
     return p->int_type;
   }
 
   {
     int low_level_recognized = 0;
     KitCgTypeId low_level_ty =
         toy_parse_low_level_builtin_call(p, name, &low_level_recognized);
     if (low_level_recognized) return low_level_ty;
   }
 
   if (toy_sym_is(p, name, "compile_error")) {
     KitSym msg;
     size_t msg_len;
     KitSlice text;
     if (!toy_parser_expect(p, TOK_LPAREN) ||
         !toy_parse_string_sym(p, &msg, &msg_len) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     text = kit_sym_str(p->c, msg);
     toy_error(p, p->cur.loc, "compile_error: %.*s", KIT_SLICE_ARG(text));
     kit_cg_push_int(p->cg, 0, p->int_type);
     return p->int_type;
   }
 
   if (toy_sym_is(p, name, "unreachable")) {
     if (!toy_parser_expect(p, TOK_LPAREN) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_unreachable(p->cg);
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
 
   if (toy_sym_is(p, name, "bitget")) {
     KitCgTypeId ty;
     int64_t lo, width;
     toy_parser_advance(p);
     ty = toy_parse_expr(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p) ||
         !toy_parse_number_arg(p, &lo) || !toy_expect_comma(p) ||
         !toy_parse_number_arg(p, &width) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_validate_bit_range(p, ty, lo, width, 1)) {
       toy_error(p, p->cur.loc, "invalid bitget arguments");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_bitget(p->cg, ty, (uint32_t)lo, (uint32_t)width);
     return ty;
   }
 
   if (toy_sym_is(p, name, "bitset")) {
     KitCgTypeId dst_ty, src_ty;
     int64_t lo, width;
     KitCgLocal dst_slot, src_slot;
     uint64_t src_mask, field_mask, clear_mask;
     toy_parser_advance(p);
     dst_ty = toy_parse_expr(p);
     if (dst_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     src_ty = toy_parse_expr(p);
     if (src_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p) ||
         !toy_parse_number_arg(p, &lo) || !toy_expect_comma(p) ||
         !toy_parse_number_arg(p, &width) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (dst_ty != src_ty || !toy_validate_bit_range(p, dst_ty, lo, width, 0)) {
       toy_error(p, p->cur.loc, "invalid bitset arguments");
       return KIT_CG_TYPE_NONE;
     }
     src_mask = (1ULL << (uint32_t)width) - 1u;
     field_mask = src_mask << (uint32_t)lo;
     clear_mask = ~field_mask;
     src_slot = kit_cg_local(p->cg, src_ty, toy_slot_attrs(0));
     dst_slot = kit_cg_local(p->cg, dst_ty, toy_slot_attrs(0));
     kit_cg_push_local(p->cg, src_slot);
     kit_cg_swap(p->cg);
     kit_cg_store(p->cg, toy_mem_access(p, src_ty));
     kit_cg_push_local(p->cg, dst_slot);
     kit_cg_swap(p->cg);
     kit_cg_store(p->cg, toy_mem_access(p, dst_ty));
 
     kit_cg_push_local(p->cg, dst_slot);
     kit_cg_load(p->cg, toy_mem_access(p, dst_ty));
     kit_cg_push_int(p->cg, clear_mask, dst_ty);
     kit_cg_int_binop(p->cg, KIT_CG_INT_AND, 0);
     kit_cg_push_local(p->cg, src_slot);
     kit_cg_load(p->cg, toy_mem_access(p, src_ty));
     kit_cg_push_int(p->cg, src_mask, src_ty);
     kit_cg_int_binop(p->cg, KIT_CG_INT_AND, 0);
     if (lo > 0) {
       kit_cg_push_int(p->cg, (uint64_t)lo, src_ty);
       kit_cg_int_binop(p->cg, KIT_CG_INT_SHL, 0);
     }
     kit_cg_int_binop(p->cg, KIT_CG_INT_OR, 0);
     return dst_ty;
   }
 
   if (toy_sym_is(p, name, "fma")) {
     KitCgTypeId a, b, c;
     toy_parser_advance(p);
     a = toy_parse_expr(p);
     if (a == KIT_CG_TYPE_NONE || !toy_expect_comma(p)) return KIT_CG_TYPE_NONE;
     b = toy_parse_expr(p);
     if (b == KIT_CG_TYPE_NONE || !toy_expect_comma(p)) return KIT_CG_TYPE_NONE;
     c = toy_parse_expr(p);
     if (c == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (a != b || a != c || !toy_type_is_float(p, a)) {
       toy_error(p, p->cur.loc, "fma expects matching float operands");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_rot3(p->cg); /* [b, c, a] */
     kit_cg_rot3(p->cg); /* [c, a, b] */
     kit_cg_fp_binop(p->cg, KIT_CG_FP_MUL, 0);
     kit_cg_swap(p->cg);
     kit_cg_fp_binop(p->cg, KIT_CG_FP_ADD, 0);
     return a;
   }
 
   if (toy_sym_is(p, name, "prefetch")) {
     KitCgTypeId ptr_ty;
     toy_parser_advance(p);
     ptr_ty = toy_parse_expr(p);
     if (ptr_ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_is_ptr(p, ptr_ty)) {
       toy_error(p, p->cur.loc, "prefetch expects pointer");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_intrinsic(p->cg, KIT_CG_INTRIN_PREFETCH, 1,
                      toy_builtin_type(p, KIT_CG_BUILTIN_VOID));
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
 
   {
     int memory_recognized = 0;
     KitCgTypeId memory_ty =
         toy_parse_memory_builtin_call(p, name, &memory_recognized);
     if (memory_recognized) return memory_ty;
   }
 
   if (toy_sym_is(p, name, "labeladdr")) {
     KitSym label_name;
     ToyLabel* label;
     KitCgTypeId ptr_ty =
         kit_cg_type_ptr(p->c, toy_builtin_type(p, KIT_CG_BUILTIN_VOID), 0);
     if (!toy_parser_expect(p, TOK_LPAREN) || p->cur.kind != TOK_IDENT) {
       toy_error(p, p->cur.loc, "expected label name");
       return KIT_CG_TYPE_NONE;
     }
     label_name = toy_tok_sym(p, p->cur);
     toy_parser_advance(p);
     if (!toy_parser_expect(p, TOK_RPAREN)) return KIT_CG_TYPE_NONE;
     label = toy_find_label(p, label_name);
     if (!label) {
       toy_error(p, p->cur.loc, "unknown label");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_push_label_addr(p->cg, label->label, ptr_ty);
     return ptr_ty;
   }
 
   if (toy_sym_is(p, name, "target_arch")) {
     if (!toy_parser_expect(p, TOK_LPAREN) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_push_int(p->cg, (uint64_t)toy_target_code(p), p->int_type);
     return p->int_type;
   }
 
   if (toy_sym_is(p, name, "supports_callconv")) {
     KitCgCallConv cc;
     if (!toy_parser_expect(p, TOK_LPAREN) ||
         !toy_parse_callconv_const(p, &cc) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_push_int(p->cg, kit_cg_target_supports_call_conv(p->c, cc) ? 1u : 0u,
                     toy_builtin_type(p, KIT_CG_BUILTIN_BOOL));
     return toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
   }
 
   if (toy_sym_is(p, name, "supports_symbol_feature")) {
     KitCgSymbolFeature feature;
     if (!toy_parser_expect(p, TOK_LPAREN) ||
         !toy_parse_symbol_feature_const(p, &feature) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_push_int(
         p->cg, kit_cg_target_supports_symbol_feature(p->c, feature) ? 1u : 0u,
         toy_builtin_type(p, KIT_CG_BUILTIN_BOOL));
     return toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
   }
 
   if (toy_sym_is(p, name, "supports_intrinsic")) {
     KitCgIntrinsic intrin;
     if (!toy_parser_expect(p, TOK_LPAREN) ||
         !toy_parse_intrinsic_const(p, &intrin) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_push_int(p->cg,
                     kit_cg_target_supports_intrinsic(p->c, intrin) ? 1u : 0u,
                     toy_builtin_type(p, KIT_CG_BUILTIN_BOOL));
     return toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
   }
 
   if (toy_sym_is(p, name, "has_backend_feature")) {
     uint64_t feature;
     if (!toy_parser_expect(p, TOK_LPAREN) ||
         !toy_parse_backend_feature_const(p, &feature) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_push_int(p->cg,
                     (kit_cg_target_backend_features(p->c) & feature) ? 1u : 0u,
                     toy_builtin_type(p, KIT_CG_BUILTIN_BOOL));
     return toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
   }
 
   if (toy_sym_is(p, name, "va_start")) {
     if (!toy_parser_expect(p, TOK_LPAREN) || !toy_parse_va_list_addr_arg(p) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_vararg_start(p->cg);
     kit_cg_push_int(p->cg, 0, p->int_type);
     return p->int_type;
   }
 
   if (toy_sym_is(p, name, "va_end")) {
     if (!toy_parser_expect(p, TOK_LPAREN) || !toy_parse_va_list_addr_arg(p) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_vararg_end(p->cg);
     kit_cg_push_int(p->cg, 0, p->int_type);
     return p->int_type;
   }
 
   if (toy_sym_is(p, name, "va_copy")) {
     if (!toy_parser_expect(p, TOK_LPAREN) || !toy_parse_va_list_addr_arg(p) ||
         !toy_expect_comma(p) || !toy_parse_va_list_addr_arg(p) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_vararg_copy(p->cg);
     kit_cg_push_int(p->cg, 0, p->int_type);
     return p->int_type;
   }
 
   *recognized = 0;
   return KIT_CG_TYPE_NONE;
 }
 
 KitCgTypeId toy_parse_generic_builtin(ToyParser* p, KitSym name,
                                       int* recognized) {
   KitCgTypeId ty;
   *recognized = 1;
 
   if (toy_sym_is(p, name, "alloca")) {
     KitCgTypeId count_ty;
     KitCgTypeId ptr_ty;
     ToyTypeId elem_toy_type;
     int64_t align;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     elem_toy_type = p->last_type;
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN))
       return KIT_CG_TYPE_NONE;
     count_ty = toy_parse_expr(p);
     if (count_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p) ||
         !toy_parse_number_arg(p, &align) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_can_implicitly_cast(p, count_ty, p->size_type) ||
         align <= 0) {
       toy_error(p, p->cur.loc, "invalid alloca arguments");
       return KIT_CG_TYPE_NONE;
     }
     if (!toy_emit_implicit_cast(p, count_ty, p->size_type))
       return KIT_CG_TYPE_NONE;
     kit_cg_push_int(p->cg, kit_cg_type_size(p->c, ty), p->size_type);
     kit_cg_int_binop(p->cg, KIT_CG_INT_MUL, 0);
     ptr_ty = kit_cg_type_ptr(p->c, ty, 0);
     kit_cg_alloca(p->cg, (uint32_t)align, ptr_ty);
     p->last_type = toy_type_register_ptr(p, ptr_ty, elem_toy_type, 0);
     return ptr_ty;
   }
 
   if (toy_sym_is(p, name, "asm")) {
     KitSym tmpl;
     size_t tmpl_len;
     ToyTypeId result_toy_type;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     result_toy_type = p->last_type;
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN) ||
         !toy_parse_arch_string(p, &tmpl, &tmpl_len)) {
       return KIT_CG_TYPE_NONE;
     }
     if (!toy_parse_typed_asm_tail(p, ty, tmpl, tmpl_len))
       return KIT_CG_TYPE_NONE;
     p->last_type = result_toy_type;
     return ty;
   }
 
   {
     int low_level_recognized = 0;
     KitCgTypeId low_level_ty =
         toy_parse_low_level_generic_builtin(p, name, &low_level_recognized);
     if (low_level_recognized) return low_level_ty;
   }
 
   if (toy_sym_is(p, name, "sext") || toy_sym_is(p, name, "zext") ||
       toy_sym_is(p, name, "trunc") || toy_sym_is(p, name, "ptr_to_int") ||
       toy_sym_is(p, name, "int_to_ptr") || toy_sym_is(p, name, "bitcast") ||
       toy_sym_is(p, name, "fpext") || toy_sym_is(p, name, "fptrunc")) {
     KitCgTypeId src_ty;
     ToyTypeId result_toy_type;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     result_toy_type = p->last_type;
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN))
       return KIT_CG_TYPE_NONE;
     src_ty = toy_parse_expr(p);
     if (src_ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     (void)src_ty;
     if (toy_sym_is(p, name, "sext"))
       kit_cg_sext(p->cg, ty);
     else if (toy_sym_is(p, name, "zext"))
       kit_cg_zext(p->cg, ty);
     else if (toy_sym_is(p, name, "trunc"))
       kit_cg_trunc(p->cg, ty);
     else if (toy_sym_is(p, name, "ptr_to_int"))
       kit_cg_ptr_to_int(p->cg, ty);
     else if (toy_sym_is(p, name, "int_to_ptr"))
       kit_cg_int_to_ptr(p->cg, ty);
     else if (toy_sym_is(p, name, "bitcast"))
       kit_cg_bitcast(p->cg, ty);
     else if (toy_sym_is(p, name, "fpext"))
       kit_cg_fpext(p->cg, ty);
     else if (toy_sym_is(p, name, "fptrunc"))
       kit_cg_fptrunc(p->cg, ty);
     p->last_type = result_toy_type;
     return ty;
   }
 
   if (toy_sym_is(p, name, "sint_to_float") ||
       toy_sym_is(p, name, "uint_to_float") ||
       toy_sym_is(p, name, "float_to_sint") ||
       toy_sym_is(p, name, "float_to_uint")) {
     KitCgTypeId src_ty;
     KitCgRounding rounding;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN))
       return KIT_CG_TYPE_NONE;
     src_ty = toy_parse_expr(p);
     if (src_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p) ||
         !toy_parse_rounding_const(p, &rounding) ||
         !toy_parser_expect(p, TOK_RPAREN)) {
       return KIT_CG_TYPE_NONE;
     }
     (void)src_ty;
     if (toy_sym_is(p, name, "sint_to_float"))
       kit_cg_sint_to_float(p->cg, ty, rounding);
     else if (toy_sym_is(p, name, "uint_to_float"))
       kit_cg_uint_to_float(p->cg, ty, rounding);
     else if (toy_sym_is(p, name, "float_to_sint"))
       kit_cg_float_to_sint(p->cg, ty, rounding);
     else
       kit_cg_float_to_uint(p->cg, ty, rounding);
     return ty;
   }
 
   if (toy_sym_is(p, name, "assume_aligned")) {
     KitCgTypeId ptr_ty;
     int64_t align;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN))
       return KIT_CG_TYPE_NONE;
     ptr_ty = toy_parse_expr(p);
     if (ptr_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p) ||
         !toy_parse_number_arg(p, &align) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (ptr_ty != ty || !toy_type_is_ptr(p, ty) || align <= 0) {
       toy_error(p, p->cur.loc, "invalid assume_aligned arguments");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_push_int(p->cg, (uint64_t)align, p->size_type);
     kit_cg_intrinsic(p->cg, KIT_CG_INTRIN_ASSUME_ALIGNED, 2, ty);
     return ty;
   }
 
   if (toy_sym_is(p, name, "sizeof") || toy_sym_is(p, name, "alignof")) {
     int is_align = toy_sym_is(p, name, "alignof");
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN) ||
         !toy_parser_expect(p, TOK_RPAREN)) {
       toy_error(p, p->cur.loc, "expected type query form");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_push_int(
         p->cg,
         is_align ? kit_cg_type_align(p->c, ty) : kit_cg_type_size(p->c, ty),
         p->size_type);
     return p->size_type;
   }
 
   if (toy_sym_is(p, name, "offsetof")) {
     uint32_t i, nfields;
     uint64_t off = 0;
     int found = 0;
     KitSym field_name = 0;
     int64_t tuple_index = -1;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN) ||
         (p->cur.kind != TOK_IDENT &&
          !(p->cur.kind == TOK_NUMBER && !p->cur.is_float))) {
       toy_error(p, p->cur.loc, "expected offsetof<T>(field)");
       return KIT_CG_TYPE_NONE;
     }
     if (p->cur.kind == TOK_NUMBER)
       tuple_index = p->cur.int_value;
     else
       field_name = toy_tok_sym(p, p->cur);
     toy_parser_advance(p);
     if (!toy_parser_expect(p, TOK_RPAREN)) return KIT_CG_TYPE_NONE;
     if (kit_cg_type_kind(p->c, ty) != KIT_CG_TYPE_RECORD) {
       toy_error(p, p->cur.loc, "offsetof expects a record type");
       return KIT_CG_TYPE_NONE;
     }
     nfields = kit_cg_type_record_nfields(p->c, ty);
     if (tuple_index >= 0) {
       if (tuple_index >= (int64_t)nfields ||
           kit_cg_type_record_field(p->c, ty, (uint32_t)tuple_index, NULL,
                                    &off) != 0) {
         toy_error(p, p->cur.loc, "invalid tuple field");
         return KIT_CG_TYPE_NONE;
       }
       found = 1;
     } else {
       for (i = 0; i < nfields; ++i) {
         KitCgField field;
         uint64_t field_off = 0;
         if (kit_cg_type_record_field(p->c, ty, i, &field, &field_off) == 0 &&
             field.name == field_name) {
           off = field_off;
           found = 1;
           break;
         }
       }
       if (!found) {
         toy_error(p, p->cur.loc, "unknown record field");
         return KIT_CG_TYPE_NONE;
       }
     }
     kit_cg_push_int(p->cg, off, p->size_type);
     return p->size_type;
   }
 
   if (toy_sym_is(p, name, "va_arg")) {
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN) || !toy_parse_va_list_addr_arg(p) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_vararg_next(p->cg, ty);
     return ty;
   }
 
   {
     int atomic_recognized = 0;
     KitCgTypeId atomic_ty =
         toy_parse_atomic_generic_builtin(p, name, &atomic_recognized);
     if (atomic_recognized) return atomic_ty;
   }
 
   if (toy_sym_is(p, name, "add_overflow") ||
       toy_sym_is(p, name, "sub_overflow") ||
       toy_sym_is(p, name, "mul_overflow")) {
     KitCgTypeId lhs_ty, rhs_ty, rec_ty;
     KitCgField fields[2];
     KitCgLocal rec_slot;
     KitCgIntrinsic intrin = KIT_CG_INTRIN_SADD_OVERFLOW;
     if (toy_sym_is(p, name, "sub_overflow"))
       intrin = KIT_CG_INTRIN_SSUB_OVERFLOW;
     else if (toy_sym_is(p, name, "mul_overflow"))
       intrin = KIT_CG_INTRIN_SMUL_OVERFLOW;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN))
       return KIT_CG_TYPE_NONE;
     lhs_ty = toy_parse_expr(p);
     if (lhs_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     rhs_ty = toy_parse_expr(p);
     if (rhs_ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_is_intlike(p, ty) ||
         !toy_type_can_implicitly_cast(p, lhs_ty, ty) ||
         !toy_type_can_implicitly_cast(p, rhs_ty, ty)) {
       toy_error(p, p->cur.loc, "overflow operand type mismatch");
       return KIT_CG_TYPE_NONE;
     }
     if (lhs_ty != ty) {
       kit_cg_swap(p->cg);
       if (!toy_emit_implicit_cast(p, lhs_ty, ty)) return KIT_CG_TYPE_NONE;
       kit_cg_swap(p->cg);
     }
     if (rhs_ty != ty && !toy_emit_implicit_cast(p, rhs_ty, ty))
       return KIT_CG_TYPE_NONE;
     kit_cg_intrinsic(p->cg, intrin, 2, ty);
     memset(fields, 0, sizeof fields);
     fields[0].name = kit_sym_intern(p->c, KIT_SLICE_LIT("value"));
     fields[0].type = ty;
     fields[1].name = kit_sym_intern(p->c, KIT_SLICE_LIT("overflow"));
     fields[1].type = toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
     rec_ty = kit_cg_type_record(p->c, 0, fields, 2);
     rec_slot = kit_cg_local(p->cg, rec_ty, toy_slot_attrs(0));
     {
       uint64_t f0_off = 0, f1_off = 0;
       kit_cg_type_record_field(p->c, rec_ty, 0, NULL, &f0_off);
       kit_cg_type_record_field(p->c, rec_ty, 1, NULL, &f1_off);
       kit_cg_push_local(p->cg, rec_slot);
       kit_cg_addr(p->cg);
       kit_cg_deref(p->cg, (int64_t)f1_off);
       kit_cg_swap(p->cg);
       kit_cg_store(p->cg, toy_mem_access(p, fields[1].type));
       kit_cg_push_local(p->cg, rec_slot);
       kit_cg_addr(p->cg);
       kit_cg_deref(p->cg, (int64_t)f0_off);
       kit_cg_swap(p->cg);
       kit_cg_store(p->cg, toy_mem_access(p, fields[0].type));
     }
     /* Record result lives as a pointer VALUE (its address) on the stack, the
      * shape record field-access / record-copy consume downstream. */
     kit_cg_push_local_addr(p->cg, rec_slot);
     return rec_ty;
   }
 
   *recognized = 0;
   return KIT_CG_TYPE_NONE;
 }
 
 /* memcpy and memmove are identical except for the constant-size emission:
  * memcpy lowers to kit_cg_memcpy, memmove to kit_cg_memmove. The dynamic path
  * is byte-for-byte shared (both emit a forward element loop). */
 static KitCgTypeId toy_parse_mem_copy_move(ToyParser* p, int is_move) {
   KitCgTypeId dst, src;
   int64_t size = 0, align = 0;
   int dynamic_size = 0, dynamic_align = 0;
   KitCgLocal dst_local = KIT_CG_LOCAL_NONE;
   KitCgLocal src_local = KIT_CG_LOCAL_NONE;
   KitCgLocal size_local = KIT_CG_LOCAL_NONE;
   KitCgMemAccess access;
   KitCgTypeId u8_ty = toy_builtin_type(p, KIT_CG_BUILTIN_I8);
   KitCgTypeId u8_ptr_ty = kit_cg_type_ptr(p->c, u8_ty, 0);
   toy_parser_advance(p);
   dst = toy_parse_expr(p);
   if (dst == KIT_CG_TYPE_NONE || !toy_expect_comma(p)) return KIT_CG_TYPE_NONE;
   src = toy_parse_expr(p);
   if (src == KIT_CG_TYPE_NONE || !toy_expect_comma(p)) return KIT_CG_TYPE_NONE;
   if (p->cur.kind == TOK_NUMBER && !p->cur.is_float) {
     if (!toy_parse_number_arg(p, &size)) return KIT_CG_TYPE_NONE;
   } else {
     KitCgTypeId size_ty = toy_parse_expr(p);
     if (size_ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (!toy_type_can_implicitly_cast(p, size_ty, p->size_type)) {
       toy_error(p, p->cur.loc, "memory size must be usize");
       return KIT_CG_TYPE_NONE;
     }
     if (!toy_emit_implicit_cast(p, size_ty, p->size_type))
       return KIT_CG_TYPE_NONE;
     dynamic_size = 1;
     size_local = kit_cg_local(p->cg, p->size_type, toy_slot_attrs(0));
     toy_store_top_to_local(p, size_local, p->size_type);
   }
   if (!toy_parse_memory_align_operand(p, &align, &dynamic_align))
     return KIT_CG_TYPE_NONE;
   access = toy_mem_access_align(p, p->int_type, (uint32_t)align);
   if (!toy_parse_mem_flags_tail(p, &access)) return KIT_CG_TYPE_NONE;
   if (!toy_parser_expect(p, TOK_RPAREN)) return KIT_CG_TYPE_NONE;
   if (dynamic_size || dynamic_align) {
     if (!dynamic_size) {
       size_local = kit_cg_local(p->cg, p->size_type, toy_slot_attrs(0));
       toy_store_const_to_local(p, size_local, p->size_type, (uint64_t)size);
     }
     src_local = kit_cg_local(p->cg, u8_ptr_ty, toy_slot_attrs(0));
     kit_cg_bitcast(p->cg, u8_ptr_ty);
     toy_store_top_to_local(p, src_local, u8_ptr_ty);
     dst_local = kit_cg_local(p->cg, u8_ptr_ty, toy_slot_attrs(0));
     kit_cg_bitcast(p->cg, u8_ptr_ty);
     toy_store_top_to_local(p, dst_local, u8_ptr_ty);
     toy_emit_dynamic_memory_loop(p, dst_local, src_local, size_local, 0, 0);
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
   if (is_move)
     kit_cg_memmove(p->cg, (uint64_t)size, access, access);
   else
     kit_cg_memcpy(p->cg, (uint64_t)size, access, access);
   return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
 }
 
 KitCgTypeId toy_parse_memory_builtin_call(ToyParser* p, KitSym name,
                                           int* recognized) {
   *recognized = 1;
 
   if (toy_sym_is(p, name, "memset")) {
     KitCgTypeId dst;
     int64_t val, size = 0, align = 0;
     int dynamic_size = 0, dynamic_align = 0;
     KitCgLocal dst_local = KIT_CG_LOCAL_NONE;
     KitCgLocal size_local = KIT_CG_LOCAL_NONE;
     KitCgMemAccess access;
     KitCgTypeId u8_ty = toy_builtin_type(p, KIT_CG_BUILTIN_I8);
     KitCgTypeId u8_ptr_ty = kit_cg_type_ptr(p->c, u8_ty, 0);
     toy_parser_advance(p);
     dst = toy_parse_expr(p);
     if (dst == KIT_CG_TYPE_NONE || !toy_expect_comma(p) ||
         !toy_parse_number_arg(p, &val) || !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     if (p->cur.kind == TOK_NUMBER && !p->cur.is_float) {
       if (!toy_parse_number_arg(p, &size)) return KIT_CG_TYPE_NONE;
     } else {
       KitCgTypeId size_ty = toy_parse_expr(p);
       if (size_ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
       if (!toy_type_can_implicitly_cast(p, size_ty, p->size_type)) {
         toy_error(p, p->cur.loc, "memory size must be usize");
         return KIT_CG_TYPE_NONE;
       }
       if (!toy_emit_implicit_cast(p, size_ty, p->size_type))
         return KIT_CG_TYPE_NONE;
       dynamic_size = 1;
       size_local = kit_cg_local(p->cg, p->size_type, toy_slot_attrs(0));
       toy_store_top_to_local(p, size_local, p->size_type);
     }
     if (!toy_parse_memory_align_operand(p, &align, &dynamic_align))
       return KIT_CG_TYPE_NONE;
     access = toy_mem_access_align(p, p->int_type, (uint32_t)align);
     if (!toy_parse_mem_flags_tail(p, &access)) return KIT_CG_TYPE_NONE;
     if (!toy_parser_expect(p, TOK_RPAREN)) return KIT_CG_TYPE_NONE;
     if (dynamic_size || dynamic_align) {
       if (val < 0 || val > 255) {
         toy_error(p, p->cur.loc, "memset value out of range");
         return KIT_CG_TYPE_NONE;
       }
       if (!dynamic_size) {
         size_local = kit_cg_local(p->cg, p->size_type, toy_slot_attrs(0));
         toy_store_const_to_local(p, size_local, p->size_type, (uint64_t)size);
       }
       dst_local = kit_cg_local(p->cg, u8_ptr_ty, toy_slot_attrs(0));
       kit_cg_bitcast(p->cg, u8_ptr_ty);
       toy_store_top_to_local(p, dst_local, u8_ptr_ty);
       toy_emit_dynamic_memory_loop(p, dst_local, KIT_CG_LOCAL_NONE, size_local,
                                    1, (uint8_t)val);
       return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
     }
     kit_cg_memset(p->cg, (uint8_t)val, (uint64_t)size, access);
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
 
   if (toy_sym_is(p, name, "memcpy")) return toy_parse_mem_copy_move(p, 0);
 
   if (toy_sym_is(p, name, "memmove")) return toy_parse_mem_copy_move(p, 1);
 
   if (toy_sym_is(p, name, "atomic_fence")) {
     KitCgMemOrder order;
     if (!toy_parser_expect(p, TOK_LPAREN) || !toy_parse_mem_order(p, &order) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_atomic_fence(p->cg, order);
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
 
   *recognized = 0;
   return KIT_CG_TYPE_NONE;
 }
 
 KitCgTypeId toy_parse_atomic_generic_builtin(ToyParser* p, KitSym name,
                                              int* recognized) {
   KitCgTypeId ty;
   *recognized = 1;
 
   if (toy_sym_is(p, name, "atomic_load")) {
     KitCgTypeId ptr_ty;
     KitCgMemOrder order;
     KitCgMemAccess access;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN))
       return KIT_CG_TYPE_NONE;
     ptr_ty = toy_parse_expr(p);
     if (ptr_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p) ||
         !toy_parse_mem_order(p, &order))
       return KIT_CG_TYPE_NONE;
     access = toy_mem_access(p, ty);
     if (!toy_parse_optional_access_arg(p, &access) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_is_ptr(p, ptr_ty) ||
         kit_cg_type_ptr_pointee(p->c, ptr_ty) != ty) {
       toy_error(p, p->cur.loc, "atomic_load pointer type mismatch");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_atomic_load(p->cg, access, order);
     return ty;
   }
 
   if (toy_sym_is(p, name, "atomic_store")) {
     KitCgTypeId ptr_ty, val_ty;
     KitCgMemOrder order;
     KitCgMemAccess access;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN))
       return KIT_CG_TYPE_NONE;
     ptr_ty = toy_parse_expr(p);
     if (ptr_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     val_ty = toy_parse_expr(p);
     if (val_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p) ||
         !toy_parse_mem_order(p, &order))
       return KIT_CG_TYPE_NONE;
     access = toy_mem_access(p, ty);
     if (!toy_parse_optional_access_arg(p, &access) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_is_ptr(p, ptr_ty) ||
         kit_cg_type_ptr_pointee(p->c, ptr_ty) != ty ||
         !toy_type_can_implicitly_cast(p, val_ty, ty)) {
       toy_error(p, p->cur.loc, "atomic_store type mismatch");
       return KIT_CG_TYPE_NONE;
     }
     if (val_ty != ty && !toy_emit_implicit_cast(p, val_ty, ty))
       return KIT_CG_TYPE_NONE;
     kit_cg_atomic_store(p->cg, access, order);
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
 
   if (toy_sym_is(p, name, "atomic_rmw")) {
     KitCgAtomicOp op;
     KitCgTypeId ptr_ty, val_ty;
     KitCgMemOrder order;
     KitCgMemAccess access;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN) || !toy_parse_atomic_op(p, &op) ||
         !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     ptr_ty = toy_parse_expr(p);
     if (ptr_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     val_ty = toy_parse_expr(p);
     if (val_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p) ||
         !toy_parse_mem_order(p, &order))
       return KIT_CG_TYPE_NONE;
     access = toy_mem_access(p, ty);
     if (!toy_parse_optional_access_arg(p, &access) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_is_ptr(p, ptr_ty) ||
         kit_cg_type_ptr_pointee(p->c, ptr_ty) != ty ||
         !toy_type_can_implicitly_cast(p, val_ty, ty)) {
       toy_error(p, p->cur.loc, "atomic_rmw type mismatch");
       return KIT_CG_TYPE_NONE;
     }
     if (val_ty != ty && !toy_emit_implicit_cast(p, val_ty, ty))
       return KIT_CG_TYPE_NONE;
     kit_cg_atomic_rmw(p->cg, access, op, order);
     return ty;
   }
 
   if (toy_sym_is(p, name, "atomic_cmpxchg")) {
     KitCgTypeId ptr_ty, expected_ty, desired_ty, rec_ty;
     KitCgMemOrder success_order, failure_order;
     int weak;
     KitCgMemAccess access;
     KitCgField fields[2];
     KitCgLocal rec_slot;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN))
       return KIT_CG_TYPE_NONE;
     ptr_ty = toy_parse_expr(p);
     if (ptr_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     expected_ty = toy_parse_expr(p);
     if (expected_ty == KIT_CG_TYPE_NONE)
       return KIT_CG_TYPE_NONE;
     if (!toy_type_can_implicitly_cast(p, expected_ty, ty)) {
       toy_error(p, p->cur.loc, "atomic_cmpxchg type mismatch");
       return KIT_CG_TYPE_NONE;
     }
     if (expected_ty != ty && !toy_emit_implicit_cast(p, expected_ty, ty))
       return KIT_CG_TYPE_NONE;
     expected_ty = ty;
     if (!toy_expect_comma(p)) return KIT_CG_TYPE_NONE;
     desired_ty = toy_parse_expr(p);
     if (desired_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p) ||
         !toy_parse_mem_order(p, &success_order) || !toy_expect_comma(p) ||
         !toy_parse_mem_order(p, &failure_order) || !toy_expect_comma(p) ||
         !toy_parse_cmpxchg_strength(p, &weak))
       return KIT_CG_TYPE_NONE;
     access = toy_mem_access(p, ty);
     if (!toy_parse_optional_access_arg(p, &access) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_is_ptr(p, ptr_ty) ||
         kit_cg_type_ptr_pointee(p->c, ptr_ty) != ty || expected_ty != ty ||
         !toy_type_can_implicitly_cast(p, desired_ty, ty)) {
       toy_error(p, p->cur.loc, "atomic_cmpxchg type mismatch");
       return KIT_CG_TYPE_NONE;
     }
     if (desired_ty != ty && !toy_emit_implicit_cast(p, desired_ty, ty))
       return KIT_CG_TYPE_NONE;
     kit_cg_atomic_cmpxchg(p->cg, access, success_order, failure_order, weak);
     memset(fields, 0, sizeof fields);
     fields[0].name = kit_sym_intern(p->c, KIT_SLICE_LIT("prior"));
     fields[0].type = ty;
     fields[1].name = kit_sym_intern(p->c, KIT_SLICE_LIT("ok"));
     fields[1].type = toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
     rec_ty = kit_cg_type_record(p->c, 0, fields, 2);
     rec_slot = kit_cg_local(p->cg, rec_ty, toy_slot_attrs(0));
     {
       uint64_t f0_off = 0, f1_off = 0;
       kit_cg_type_record_field(p->c, rec_ty, 0, NULL, &f0_off);
       kit_cg_type_record_field(p->c, rec_ty, 1, NULL, &f1_off);
       kit_cg_push_local(p->cg, rec_slot);
       kit_cg_addr(p->cg);
       kit_cg_deref(p->cg, (int64_t)f1_off);
       kit_cg_swap(p->cg);
       kit_cg_store(p->cg, toy_mem_access(p, fields[1].type));
       kit_cg_push_local(p->cg, rec_slot);
       kit_cg_addr(p->cg);
       kit_cg_deref(p->cg, (int64_t)f0_off);
       kit_cg_swap(p->cg);
       kit_cg_store(p->cg, toy_mem_access(p, fields[0].type));
     }
     /* Record result lives as a pointer VALUE (its address) on the stack. */
     kit_cg_push_local_addr(p->cg, rec_slot);
     return rec_ty;
   }
 
   if (toy_sym_is(p, name, "atomic_is_legal")) {
     KitCgMemOrder order;
     KitCgMemAccess access;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN) || !toy_parse_mem_order(p, &order))
       return KIT_CG_TYPE_NONE;
     access = toy_mem_access(p, ty);
     if (!toy_parse_optional_access_arg(p, &access) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     kit_cg_push_int(p->cg,
                     kit_cg_atomic_is_legal(p->c, access, order) ? 1u : 0u,
                     toy_builtin_type(p, KIT_CG_BUILTIN_BOOL));
     return toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
   }
 
   if (toy_sym_is(p, name, "atomic_is_lock_free")) {
     KitCgMemAccess access;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN))
       return KIT_CG_TYPE_NONE;
     access = toy_mem_access(p, ty);
     if (p->cur.kind != TOK_RPAREN && !toy_parse_access_group(p, &access))
       return KIT_CG_TYPE_NONE;
     if (!toy_parser_expect(p, TOK_RPAREN)) return KIT_CG_TYPE_NONE;
     kit_cg_push_int(p->cg, kit_cg_atomic_is_lock_free(p->c, access) ? 1u : 0u,
                     toy_builtin_type(p, KIT_CG_BUILTIN_BOOL));
     return toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
   }
 
   *recognized = 0;
   return KIT_CG_TYPE_NONE;
 }
 
 KitCgTypeId toy_parse_low_level_builtin_call(ToyParser* p, KitSym name,
                                              int* recognized) {
   *recognized = 1;
 
   if (toy_sym_is(p, name, "syscall")) {
     uint32_t nargs = 0;
     KitCgTypeId long_ty = p->int_type;
     if (!toy_parser_expect(p, TOK_LPAREN)) return KIT_CG_TYPE_NONE;
     if (!toy_parser_match(p, TOK_RPAREN)) {
       for (;;) {
         KitCgTypeId arg_ty = toy_parse_expr(p);
         if (arg_ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
         if (!toy_type_is_intlike(p, arg_ty) && !toy_type_is_ptr(p, arg_ty)) {
           toy_error(p, p->cur.loc,
                     "syscall arguments must be integer or pointer");
           return KIT_CG_TYPE_NONE;
         }
         if (arg_ty != long_ty && !toy_emit_cast(p, arg_ty, long_ty))
           return KIT_CG_TYPE_NONE;
         nargs++;
         if (nargs > 7u) {
           toy_error(p, p->cur.loc, "too many syscall arguments");
           return KIT_CG_TYPE_NONE;
         }
         if (!toy_parser_match(p, TOK_COMMA)) break;
       }
       if (!toy_parser_expect(p, TOK_RPAREN)) return KIT_CG_TYPE_NONE;
     }
     if (nargs == 0) {
       toy_error(p, p->cur.loc, "syscall expects a syscall number");
       return KIT_CG_TYPE_NONE;
     }
     if (!kit_cg_target_supports_intrinsic(p->c, KIT_CG_INTRIN_SYSCALL))
       return toy_unsupported_intrinsic(p);
     kit_cg_intrinsic(p->cg, KIT_CG_INTRIN_SYSCALL, nargs, long_ty);
     return long_ty;
   }
 
   if (toy_sym_is(p, name, "setjmp")) {
     KitCgTypeId buf_ty;
     if (!toy_parser_expect(p, TOK_LPAREN)) return KIT_CG_TYPE_NONE;
     buf_ty = toy_parse_expr(p);
     if (buf_ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_is_ptr(p, buf_ty)) {
       toy_error(p, p->cur.loc, "setjmp expects pointer buffer");
       return KIT_CG_TYPE_NONE;
     }
     return toy_unsupported_intrinsic(p);
   }
 
   if (toy_sym_is(p, name, "longjmp")) {
     KitCgTypeId buf_ty, value_ty;
     if (!toy_parser_expect(p, TOK_LPAREN)) return KIT_CG_TYPE_NONE;
     buf_ty = toy_parse_expr(p);
     if (buf_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     value_ty = toy_parse_expr(p);
     if (value_ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_is_ptr(p, buf_ty) || !toy_type_is_intlike(p, value_ty)) {
       toy_error(p, p->cur.loc,
                 "longjmp expects pointer buffer and integer value");
       return KIT_CG_TYPE_NONE;
     }
     return toy_unsupported_intrinsic(p);
   }
 
   if (toy_sym_is(p, name, "wfi") || toy_sym_is(p, name, "wfe") ||
       toy_sym_is(p, name, "sev")) {
     KitCgIntrinsic intrin = KIT_CG_INTRIN_WFI;
     if (toy_sym_is(p, name, "wfe"))
       intrin = KIT_CG_INTRIN_WFE;
     else if (toy_sym_is(p, name, "sev"))
       intrin = KIT_CG_INTRIN_SEV;
     if (!toy_parser_expect(p, TOK_LPAREN) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!kit_cg_target_supports_intrinsic(p->c, intrin))
       return toy_unsupported_intrinsic(p);
     kit_cg_intrinsic(p->cg, intrin, 0,
                      toy_builtin_type(p, KIT_CG_BUILTIN_VOID));
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
 
   if (toy_sym_is(p, name, "irq_save")) {
     if (!toy_parser_expect(p, TOK_LPAREN) || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!kit_cg_target_supports_intrinsic(p->c, KIT_CG_INTRIN_IRQ_SAVE))
       return toy_unsupported_intrinsic(p);
     kit_cg_intrinsic(p->cg, KIT_CG_INTRIN_IRQ_SAVE, 0, p->size_type);
     return p->size_type;
   }
 
   if (toy_sym_is(p, name, "irq_restore")) {
     KitCgTypeId prev_ty;
     if (!toy_parser_expect(p, TOK_LPAREN)) return KIT_CG_TYPE_NONE;
     prev_ty = toy_parse_expr(p);
     if (prev_ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_can_implicitly_cast(p, prev_ty, p->size_type)) {
       toy_error(p, p->cur.loc, "irq_restore expects usize state");
       return KIT_CG_TYPE_NONE;
     }
     if (!toy_emit_implicit_cast(p, prev_ty, p->size_type))
       return KIT_CG_TYPE_NONE;
     if (!kit_cg_target_supports_intrinsic(p->c, KIT_CG_INTRIN_IRQ_RESTORE))
       return toy_unsupported_intrinsic(p);
     kit_cg_intrinsic(p->cg, KIT_CG_INTRIN_IRQ_RESTORE, 1,
                      toy_builtin_type(p, KIT_CG_BUILTIN_VOID));
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
 
   if (toy_sym_is(p, name, "dmb") || toy_sym_is(p, name, "dsb")) {
     KitCgIntrinsic intrin =
         toy_sym_is(p, name, "dsb") ? KIT_CG_INTRIN_DSB : KIT_CG_INTRIN_DMB;
     KitCgBarrierScope scope;
     if (!toy_parser_expect(p, TOK_LPAREN) ||
         !toy_parse_barrier_scope(p, &scope) ||
         !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!kit_cg_target_supports_intrinsic(p->c, intrin))
       return toy_unsupported_intrinsic(p);
     /* The barrier domain rides as an immediate operand the backend maps onto
      * the arch's barrier-option field. */
     kit_cg_push_int(p->cg, (uint64_t)scope, p->int_type);
     kit_cg_intrinsic(p->cg, intrin, 1,
                      toy_builtin_type(p, KIT_CG_BUILTIN_VOID));
     return toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   }
 
   if (toy_sym_is(p, name, "dcache_clean") ||
       toy_sym_is(p, name, "dcache_invalidate") ||
       toy_sym_is(p, name, "dcache_clean_invalidate") ||
       toy_sym_is(p, name, "icache_invalidate")) {
     KitCgTypeId ptr_ty, size_ty;
     if (!toy_parser_expect(p, TOK_LPAREN)) return KIT_CG_TYPE_NONE;
     ptr_ty = toy_parse_expr(p);
     if (ptr_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     size_ty = toy_parse_expr(p);
     if (size_ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_is_ptr(p, ptr_ty) || !toy_type_is_intlike(p, size_ty)) {
       toy_error(p, p->cur.loc,
                 "cache intrinsic expects pointer and integer size");
       return KIT_CG_TYPE_NONE;
     }
     return toy_unsupported_intrinsic(p);
   }
 
   *recognized = 0;
   return KIT_CG_TYPE_NONE;
 }
 
 KitCgTypeId toy_parse_low_level_generic_builtin(ToyParser* p, KitSym name,
                                                 int* recognized) {
   KitCgTypeId ty;
   *recognized = 1;
 
   if (toy_sym_is(p, name, "coro_switch")) {
     KitCgTypeId from_ty, to_ty, value_ty;
     if (!toy_parser_expect(p, TOK_LT)) return KIT_CG_TYPE_NONE;
     ty = toy_parse_type(p);
     if (ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_GT) ||
         !toy_parser_expect(p, TOK_LPAREN))
       return KIT_CG_TYPE_NONE;
     from_ty = toy_parse_expr(p);
     if (from_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     to_ty = toy_parse_expr(p);
     if (to_ty == KIT_CG_TYPE_NONE || !toy_expect_comma(p))
       return KIT_CG_TYPE_NONE;
     value_ty = toy_parse_expr(p);
     if (value_ty == KIT_CG_TYPE_NONE || !toy_parser_expect(p, TOK_RPAREN))
       return KIT_CG_TYPE_NONE;
     if (!toy_type_is_ptr(p, from_ty) || !toy_type_is_ptr(p, to_ty) ||
         value_ty != ty) {
       toy_error(p, p->cur.loc,
                 "coro_switch expects pointer contexts and matching value type");
       return KIT_CG_TYPE_NONE;
     }
     return toy_unsupported_intrinsic(p);
   }
 
   *recognized = 0;
   return KIT_CG_TYPE_NONE;
 }