kit

internal.h (16769B)

---

 #ifndef KIT_ARCH_WASM_INTERNAL_H
 #define KIT_ARCH_WASM_INTERNAL_H
 
 /* Wasm CGTarget.
  *
  * Produces a tool-conventions-shaped Wasm module from a single Toy/C
  * translation unit. Operates with virtual_regs=1: CG mints fresh Reg ids and
  * the target assigns each Reg a Wasm local on first use, materializing values
  * by `local.get`/`local.set`. The accumulating WasmModule is attached to the
  * ObjBuilder under OBJ_EXT_WASM so emit_wasm can flush it at finalize time.
  *
  * Scope (initial): scalar i32/i64/f32/f64 with locals, params, return, direct
  * calls, structured `scope_begin(LOOP)` + break/continue, label-based
  * forward `if`/`if-else` via the kit_cg_if_begin/else/end pattern, basic
  * binop/unop/cmp/convert, and OPK_IMM constants. Address-taken locals,
  * aggregates, indirect calls, alloca, va_*, intrinsics other than
  * trivial ones, inline asm, TLS, bitfields, switch_, indirect_branch, and
  * load_label_addr all panic with a precise diagnostic; they will land as
  * follow-ups against doc/WASM.md. Atomics (load/store/rmw/cmpxchg/fence)
  * are lowered through the wasm-threads opcodes; the linear memory is
  * promoted to shared on the first atomic emission. */
 
 #include <kit/core.h>
 
 #include "arch/mc.h"
 #include "cg/cgtarget.h" /* WTarget embeds CgTarget base */
 #include "core/core.h"
 #include "obj/obj.h"
 #include "opt/ir.h"
 
 typedef CgTarget CGTarget;
 typedef struct CgIrModule CgIrModule;
 
 typedef struct WasmOptCGSwitchDesc {
   Operand selector;
   KitCgTypeId selector_type;
   Label default_label;
   const CGSwitchCase* cases;
   u32 ncases;
   u8 hint;
   u8 opt_level;
   u8 pad[2];
 } WasmOptCGSwitchDesc;
 #define CGSwitchDesc WasmOptCGSwitchDesc
 
 /* Forward references into the shared src/wasm module representation. The
  * target reuses that model so emit_wasm can flush through wasm_encode. */
 struct WasmModule;
 struct WasmFunc;
 
 /* Per-instruction kinds we record, then linearize at func_end. Keeping the
  * record list separate from the WasmFunc body lets us run the deferred
  * label/jump → wasm-block resolution without baking forward-only structure
  * into the recording side. */
 typedef enum WIROp {
   WIR_LOAD_IMM,      /* dst, imm, type */
   WIR_LOAD_CONST_F,  /* dst, fp_imm, type */
   WIR_COPY,          /* dst, src */
   WIR_BINOP,         /* dst, a, b, BinOp */
   WIR_UNOP,          /* dst, a, UnOp */
   WIR_CMP,           /* dst, a, b, CmpOp */
   WIR_CONVERT,       /* dst, src, ConvKind */
   WIR_LABEL,         /* place label[0] */
   WIR_JUMP,          /* jump to label[0] */
   WIR_CMP_BRANCH,    /* cmp_branch op a b -> label[0] */
   WIR_CALL,          /* callee_sym, nargs, args[], ret_reg (or REG_NONE) */
   WIR_CALL_INDIRECT, /* callee in `a` (i32 table index), typeidx in `imm`,
                         nargs/args[]/ret_reg same shape as WIR_CALL */
   WIR_RET,           /* val (or REG_NONE) */
   WIR_SCOPE_OPEN,    /* scope_id; kind == SCOPE_LOOP/BLOCK */
   WIR_SCOPE_CLOSE,   /* scope_id */
   WIR_UNREACHABLE,
   WIR_SWITCH,       /* selector operand + dense label table at lowering */
   WIR_LOAD_LOCAL,   /* dst, frame_slot in `imm`, type */
   WIR_STORE_LOCAL,  /* frame_slot in `imm`, src (a/imm_a/imm_kind), type */
   WIR_LOAD_MEM,     /* dst = load addr */
   WIR_STORE_MEM,    /* store src -> addr */
   WIR_ADDR_OF,      /* dst = address of addr */
   WIR_ALLOCA,       /* dst = stack allocation of size operand */
   WIR_COPY_BYTES,   /* memcpy-like byte copy */
   WIR_SET_BYTES,    /* memset-like byte set */
   WIR_ATOMIC_LOAD,  /* dst = atomic.load(addr_reg), mem holds access info */
   WIR_ATOMIC_STORE, /* atomic.store(addr_reg, src) */
   WIR_ATOMIC_RMW, /* dst = atomic.rmw_<op>(addr_reg, val); cgop = KitCgAtomicOp
                    */
   WIR_ATOMIC_CAS, /* dst = prior; dst2 = ok (i32 0/1); a=addr_reg,
                      b/imm_kind_b=expected, op_c/imm_kind_c=desired */
   WIR_FENCE,      /* atomic.fence (memory order ignored, wasm has seq_cst) */
   WIR_VA_START,   /* addr = ap_addr; stores va_ptr_param_local i32 at *ap */
   WIR_VA_ARG,     /* dst = load of `type` from *(*addr); advance *addr by 8 */
   WIR_VA_COPY,    /* addr = dst_ap_addr; call_sret_addr = src_ap_addr */
   WIR_INTRINSIC,  /* cgop = IntrinKind; operand layout per kind:
                      - bit ops (CLZ/CTZ/POPCOUNT/BSWAP): one
                        register operand in `a`, single dst in `dst`,
                        `type` carries the operand/result type.
                      - overflow arith (S/U{ADD,SUB,MUL}_OVERFLOW): two
                        value operands captured into a/imm_a/imm_kind and
                        b/imm_b/imm_kind_b, dst = value reg, dst2 = i32
                        overflow flag reg, `type` = value type. */
   WIR_ASM_BLOCK,  /* inline asm block. raw_insns[0..raw_ninsns) is the
                      pre-parsed body; local.get/set/tee indices in
                      [0, asm_nin) are remapped to freshly allocated wasm
                      locals at linearize time. Input bindings are
                      captured into asm_in_kinds/asm_in_imms/asm_in_regs;
                      output bindings into asm_out_regs. */
 } WIROp;
 
 typedef struct WIR {
   u8 op;
   u8 cls;  /* RegClass for the produced value or branch operand */
   u8 cgop; /* BinOp/UnOp/CmpOp/ConvKind discriminator */
   u8 pad;
   KitCgTypeId type;  /* type of dst (or operand type for cmp/store) */
   KitCgTypeId type2; /* operand type for convert/cmp */
   Reg dst;
   Reg a;
   Reg b;
   i64 imm;
   double fp_imm;
   Label labels[1]; /* used by LABEL/JUMP/CMP_BRANCH */
   u32 scope_id;
   u32 imm_kind; /* 0=reg, 1=imm — operand variant for a/b */
   u32 imm_kind_b;
   i64 imm_a;
   i64 imm_b;
   ObjSymId call_sym;
   u32 call_narg;
   Operand addr;
   MemAccess mem;
   AggregateAccess agg;
   /* Per-arg captured operand. kind: 0=REG (value=arg_regs[i]), 1=IMM
    * (value=arg_imms[i]), 4=ADDR (the i32 address of an aggregate source —
    * call_arg_addrs[i] holds the original Operand). Heap-allocated when
    * nargs>0; freed at func_end. */
   Reg* call_args;
   i64* call_arg_imms;
   u8* call_arg_kinds;
   KitCgTypeId* call_arg_types;
   Operand* call_arg_addrs;
   /* Sret return slot: when the called function returns indirectly, the caller
    * prepends an i32 pointer to a caller-allocated buffer. call_sret_addr is
    * that buffer's address operand; emit-time pushes its i32 first. */
   u8 call_has_sret;
   u8 call_variadic; /* callee is variadic; pack call_var_* into linear-memory
                      * buffer and push its addr as hidden trailing i32 arg. */
   u8 call_tail;     /* emit as return_call / return_call_indirect */
   u8 pad_call[1];
   Operand call_sret_addr;
   /* Variadic args (those past d->abi->nparams when callee is variadic). Stored
    * separately from call_args because they don't appear in the wasm signature
    * at all — they go into a caller-packed linear-memory buffer, each in an
    * 8-byte slot. kinds are WOP_REG / WOP_IMM only; aggregate variadic args
    * diagnose in wasm_call. */
   u32 call_nvar;
   Reg* call_var_regs;
   i64* call_var_imms;
   u8* call_var_kinds;
   KitCgTypeId* call_var_types;
   CGSwitchCase* switch_cases;
   u32 switch_ncases;
   /* Atomic CAS extras: third value-operand (desired) plus a second result reg
    * (ok bool). For the other atomic ops these stay 0. */
   Reg dst2;
   Reg op_c;
   u32 imm_kind_c;
   i64 imm_c;
   /* WIR_ASM_BLOCK payload. Heap-allocated arrays owned by the WIR (freed at
    * per-func teardown). raw_insns is the parsed body; the *_in_* arrays hold
    * one entry per input operand (declaration order, including inout duplicates
    * appended at the end); the *_out_* arrays hold one entry per output. */
   struct WasmInsn* raw_insns;
   u32 raw_ninsns;
   u32 asm_nin;
   u32 asm_nout;
   u8* asm_in_kinds; /* WOP_REG / WOP_IMM / WOP_LOCAL */
   i64* asm_in_imms;
   Reg* asm_in_regs;
   KitCgTypeId* asm_in_types;
   /* For each input i: index of the matching output (numeric tieback "N" or
    * +r inout duplicate); -1 if the input is independent. Inputs that share
    * an output's wasm local materialize into the OUTPUT's local. */
   i32* asm_in_share_out;
   Reg* asm_out_regs;
   KitCgTypeId* asm_out_types;
 } WIR;
 
 typedef struct WScope {
   u8 cg_kind;       /* ScopeKind */
   u8 placed_in_wir; /* WIR_SCOPE_OPEN emitted */
   u8 break_seen;    /* break_label_place arrived */
   u8 cont_seen;     /* continue_label_place arrived */
   u32 id;
   Label break_lbl;
   Label cont_lbl;
   KitCgTypeId result_type;
 } WScope;
 
 typedef enum WLabelKind {
   WLBL_UNBOUND = 0,
   WLBL_SCOPE_BREAK,
   WLBL_SCOPE_CONT,
   WLBL_FORWARD, /* placed via label_place but not tied to a scope */
 } WLabelKind;
 
 typedef struct WLabel {
   u8 kind;
   u8 placed;
   u8 pad[2];
   u32 scope_id;  /* for SCOPE_BREAK/SCOPE_CONT */
   u32 wir_index; /* WIR_LABEL position once placed */
 } WLabel;
 
 typedef struct WFunc {
   ObjSymId sym;
   u32 wasm_func_idx; /* index into WasmModule.funcs */
   KitCgTypeId fn_type;
   u8 has_export_name;
   u8 pad[3];
 } WFunc;
 
 typedef enum WSlotKind {
   W_SLOT_LOCAL = 0,
   W_SLOT_STACK = 1,
 } WSlotKind;
 
 /* For each ABI_ARG_INDIRECT (byval) param the callee receives an i32 pointer
  * in a wasm function param and must copy the pointed-to aggregate into a
  * caller-isolated buffer in the linear-memory stack frame. We queue these at
  * wasm_param time and emit the byte copies in the prologue, after frame setup
  * and before the user body. */
 typedef struct WByvalCopy {
   u32 ptr_wasm_local; /* wasm-local holding the source pointer (param slot) */
   u32 dst_slot_id;    /* index into WTarget.slots; slot is W_SLOT_STACK */
 } WByvalCopy;
 
 typedef struct WSlot {
   u8 kind;
   u8 pad[3];
   KitCgTypeId type;
   u32 wasm_local;
   u32 size;
   u32 align;
   u32 frame_offset;
 } WSlot;
 
 /* Deferred symbol-address fixup. emit_addr_operand for OPK_GLOBAL pushes
  * `i32.const 0` placeholder and queues a WSymFixup. wasm_materialize_data
  * computes the compact section base layout and rewrites in.imm with the
  * absolute linear-memory address (section_base[sym->section_id] + sym->value
  * + addend). Static-data relocations are applied directly to the linear
  * memory image via the same section_base table. */
 typedef struct WSymFixup {
   u32 wasm_func_idx;
   u32 insn_idx;
   ObjSymId sym;
   i64 addend;
 } WSymFixup;
 
 /* Function-pointer fixup. emit_addr_operand for an OPK_GLOBAL pointing at a
  * function symbol pushes `i32.const 0` and queues a WFuncTableFixup. At
  * finalize, wasm_materialize_functable assigns each address-taken function a
  * sequential index (starting at 1; slot 0 is reserved as null) into the
  * single funcref table and rewrites in.imm with the assigned table index. */
 typedef struct WFuncTableFixup {
   u32 wasm_func_idx;
   u32 insn_idx;
   ObjSymId sym;
 } WFuncTableFixup;
 
 typedef struct WTarget {
   CgTarget base;
 
   Compiler* c;
   ObjBuilder* obj;
   struct WasmModule* module;
 
   /* TU-wide: ObjSymId -> (wasm_func_idx + 1); 0 means "not yet a wasm func".
    * Lazily grown as ObjSymIds appear via call() or func_begin(). */
   u32* sym_to_func;
   u32 sym_to_func_cap;
   WFunc* funcs;
   u32 nfuncs;
   u32 funcs_cap;
 
   /* Per-function state. Reset on func_begin. */
   const CGFuncDesc* cur_fn_desc;
   /* Most recent SrcLoc the frontend told us about via wasm_set_loc. Used by
    * cur_loc so diagnostics attribute to the actual failing statement
    * rather than the function-definition location. Zeroed at func_begin;
    * a zero line falls back to cur_fn_desc->loc. */
   SrcLoc cur_stmt_loc;
   u32 cur_func_idx;
   struct WasmFunc* cur_func;
 
   /* SSA Reg -> Wasm local index (0..nparams=params, then locals). 0xffffffffu
    * means "not assigned yet". reg_cap grows monotonically across the TU;
    * reg_hwm tracks one past the highest Reg actually bound in any function so
    * far, so func_begin only needs to wipe [0, reg_hwm) rather than reg_cap. */
   u32* reg_to_local;
   KitCgTypeId* reg_type;
   u8* reg_cls;
   u32 reg_cap;
   u32 reg_hwm;
 
   /* WIR record list for the current function. */
   WIR* wir;
   u32 nwir;
   u32 wir_cap;
 
   /* Labels minted by label_new. */
   WLabel* labels;
   u32 nlabels;
   u32 labels_cap;
 
   /* CG scope stack. */
   WScope scopes[32];
   u32 nscopes;
   u32 next_scope_id;
 
   /* Per-function frame slots. Scalar slots stay as Wasm locals; addressable
    * slots are assigned offsets in a downward-growing linear-memory frame. */
   WSlot* slots;
   u32 nslots;
   u32 slots_cap;
   u32 frame_size;
   u32 frame_align;
   u32 frame_base_local;
   u32 frame_saved_sp_local;
   u8 has_stack_frame;
   u8 has_memory;
   u8 has_stack_pointer;
   u8 cur_has_sret;
   u32 stack_pointer_global;
   u32 stack_size;
   u32 data_end;
 
   /* Compact section -> linear memory base. Populated lazily in
    * wasm_materialize_data; 0xFFFFFFFFu means "not assigned yet". The
    * compact layout reserves a small null guard at low memory and walks
    * SF_ALLOC sections in id order, giving each section an aligned base. */
   u32* section_base;
   u32 section_base_cap;
   /* Common-symbol (SK_COMMON) -> linear memory base, indexed by ObjSymId.
    * Common symbols have section_id == OBJ_SEC_NONE in ObjBuilder; for a
    * single-TU final-module emit we lay them out BSS-style after sections.
    * 0xFFFFFFFFu = no common base assigned. */
   u32* common_base;
   u32 common_base_cap;
 
   /* Deferred symbol-address fixups; see WSymFixup. */
   WSymFixup* sym_fixups;
   u32 sym_fixups_count;
   u32 sym_fixups_cap;
 
   /* Function-pointer table state. ObjSymIds of every function whose address
    * has been taken, in insertion order. The implied table index for entry
    * func_table[i] is (i + 1); slot 0 stays unpopulated as a null/trap guard.
    * Filled lazily by emit_addr_operand and patched into placeholder
    * `i32.const 0` insns at finalize. */
   ObjSymId* func_table;
   u32 func_table_count;
   u32 func_table_cap;
   WFuncTableFixup* func_table_fixups;
   u32 func_table_fixups_count;
   u32 func_table_fixups_cap;
   /* Patched into the linear-memory image at apply_data_relocs time for
    * R_ABS32 relocations whose target symbol is a function (so a static
    * `static fn_t v = &foo;` initializer ends up holding the table index). */
   u8 has_func_table;
 
   /* Per-function aggregate-lowering state. Populated by func_begin and used by
    * wasm_param/ret/call to translate sret + byval through the wasm32 BasicCABI
    * shape (sret pointer as hidden i32 leading param, byval args as i32
    * pointers, callee copy-in into a stack-backed local buffer). */
   u32 sret_param_local; /* wasm-local idx of the sret pointer; 0xffffffffu when
                            none */
   u32 va_ptr_param_local; /* wasm-local idx of the hidden i32 va_ptr trailing
                            * param on variadic functions; 0xffffffffu when none.
                            * Read by wasm_va_start to seed the va_list. */
   u32* param_local_idx;   /* per CG-param idx -> wasm-local idx (0xffffffffu for
                              IGNORE) */
   u32 param_local_idx_cap;
   u32 nparams_cg;     /* count of entries in param_local_idx */
   u8 cur_is_variadic; /* current function declared variadic (abi->variadic) */
   /* Per-function scratch locals for variadic-call packing. Lazily allocated
    * on the first variadic call site; reused across all variadic calls in the
    * same function (each call's save/restore window is self-contained, so a
    * single pair of locals is safe). 0xffffffffu when not yet allocated. */
   u32 varcall_saved_sp_local;
   u32 varcall_buf_local;
   /* Scratch i32 local used by va_arg to remember the va_list address across
    * the load-current-slot / advance-pointer sequence. Lazily allocated on
    * first va_arg in the function. 0xffffffffu when not allocated. */
   u32 va_arg_tmp_addr_local;
   WByvalCopy* byval_copies;
   u32 nbyval_copies;
   u32 byval_copies_cap;
 
   /* Body has been terminated unconditionally — skip further insns until the
    * next label_place. Lets us emit dead code that the parser may produce
    * without breaking wasm validation. */
   u8 dead;
 } WTarget;
 
 CgTarget* wasm_cgtarget_new(Compiler* c, ObjBuilder* o, MCEmitter* mc);
 WTarget* wasm_emit_target_new(Compiler* c, ObjBuilder* o, MCEmitter* mc);
 void wasm_emit_ir_module(WTarget* t, const CgIrModule* module);
 void wasm_finalize(CGTarget*);
 void wasm_destroy(CGTarget*);
 
 /* CFG structurer (src/arch/wasm/structure.c). Rewrites the recorded WIR
  * list so every free WIR_LABEL becomes the break/continue of a synthetic
  * SCOPE_BLOCK / SCOPE_LOOP. Called from emit.c's linearize() before the
  * WIR walk; after this returns, br_to_label resolves every jump through
  * the existing scope-bound machinery. Switch islands are pre-reordered
  * (selector + WIR_SWITCH + case bodies) so their case labels become
  * forward refs the same synthetic-scope structuring handles. */
 void wasm_structurize(WTarget* t);
 
 #endif