kit

runtime_abi.h (5450B)

---

 #ifndef KIT_LANG_WASM_RUNTIME_ABI_H
 #define KIT_LANG_WASM_RUNTIME_ABI_H
 
 #include <stdint.h>
 
 typedef struct KitWasmMemory {
   uint8_t* data;
   uint64_t pages;
   uint64_t max_pages;
   uint32_t flags;
 } KitWasmMemory;
 
 #ifndef KIT_WASM_MEMORY_FLAG_TYPES
 #define KIT_WASM_MEMORY_FLAG_TYPES
 enum {
   KIT_WASM_MEMORY_SHARED = 1u << 0,
   KIT_WASM_MEMORY_64 = 1u << 1,
 };
 #endif
 
 #ifndef KIT_WASM_IMPORT_KIND_TYPES
 #define KIT_WASM_IMPORT_KIND_TYPES
 typedef enum KitWasmImportKind {
   KIT_WASM_IMPORT_FUNC = 0,
   KIT_WASM_IMPORT_TABLE = 1,
   KIT_WASM_IMPORT_MEMORY = 2,
   KIT_WASM_IMPORT_GLOBAL = 3,
 } KitWasmImportKind;
 #endif
 
 #ifndef KIT_WASM_RUNTIME_LAYOUT_TYPES
 #define KIT_WASM_RUNTIME_LAYOUT_TYPES
 typedef struct KitWasmMemoryLayout {
   uint64_t offset;
   uint64_t min_pages;
   uint64_t max_pages;
   uint32_t flags;
   uint32_t reserved;
 } KitWasmMemoryLayout;
 
 typedef struct KitWasmRuntimeLayout {
   uint64_t instance_size;
   const KitWasmMemoryLayout* memories;
   uint32_t nmemories;
 } KitWasmRuntimeLayout;
 #endif
 
 typedef struct KitWasmFuncImport {
   void* fn;
 } KitWasmFuncImport;
 
 typedef struct KitWasmGlobalImport {
   void* addr;
 } KitWasmGlobalImport;
 
 typedef struct KitWasmTableEntry {
   void* fn;
   uint32_t typeidx;
 } KitWasmTableEntry;
 
 typedef struct KitWasmTable {
   KitWasmTableEntry* entries;
   uint32_t len;
   uint32_t max;
 } KitWasmTable;
 
 /* Bulk-memory passive data segment slot. Populated by __kit_wasm_init from
  * the module's WASM_SEG_PASSIVE data segments. `base` points to a const data
  * symbol interned by codegen; `len` is the segment's byte length. data.drop
  * sets `len = 0`. memory.init copies from this region into linear memory. */
 typedef struct KitWasmPassiveDataSegment {
   const uint8_t* base;
   uint64_t len;
 } KitWasmPassiveDataSegment;
 
 /* Bulk-memory passive elem segment slot. Populated by __kit_wasm_init from
  * the module's WASM_SEG_PASSIVE element segments. `entries` points to a const
  * array of {fn, typeidx} table-entry records; `length` is the entry count.
  * elem.drop sets `length = 0`. table.init copies entries into a table. */
 typedef struct KitWasmPassiveElemSegment {
   const KitWasmTableEntry* entries;
   uint32_t length;
 } KitWasmPassiveElemSegment;
 
 /* Opaque to C callers for now. The compiler emits a module-specific instance
  * layout with KitWasmMemory first, followed by import slots, runtime tables,
  * and lowered global slots. Table entry storage is instance-owned for
  * defined tables; embedders fill import slots before calling the init hook. */
 typedef struct KitWasmInstance KitWasmInstance;
 
 typedef void (*KitWasmInitFn)(KitWasmInstance*);
 
 /* ---- Host-import metadata (subagent C) ----
  *
  * Each module that the wasm frontend lowers emits readonly symbols alongside
  * __kit_wasm_init so a runtime can resolve imports by (module, field) without
  * needing the source WasmModule struct:
  *
  *   __kit_wasm_imports   : KitWasmImportDesc[]  (one per declared
  *                                                    import; if the module has
  *                                                    none, the symbol is
  *                                                    absent)
  *   __kit_wasm_nimports  : uint32_t               (array length)
  *   __kit_wasm_nfunc_import_types : uint32_t      (unique function import
  *                                                    signature count)
  *   __kit_wasm_types     : KitWasmTypeDesc[]    (unique WasmFuncType
  *                                                    signatures referenced by
  *                                                    imported functions;
  *                                                    absent when no functions
  *                                                    are imported)
  *   __kit_wasm_memory_import_types : KitWasmMemoryImportDesc[]
  *   __kit_wasm_table_import_types  : KitWasmTableImportDesc[]
  *   __kit_wasm_global_import_types : KitWasmGlobalImportDesc[]
  *
  * The wire format below is the C ABI the JIT/AOT image exposes. Param/result
  * bytes use the raw wasm WasmValType encoding (I32=0x7f, I64=0x7e, F32=0x7d,
  * F64=0x7c, FUNCREF=0x70, EXTERNREF=0x6f) — the binder translates these to
  * the public KitWasmValType enum when invoking host resolvers. */
 
 typedef struct KitWasmImportDesc {
   const char* module;    /* image-owned, NUL-terminated */
   const char* field;     /* image-owned, NUL-terminated */
   uint32_t kind;         /* KitWasmImportKind */
   uint32_t desc_index;   /* index into the kind-specific descriptor array */
   uint32_t slot_offset;  /* byte offset of the instance slot for this import */
   uint32_t reserved;
 } KitWasmImportDesc;
 
 typedef struct KitWasmTypeDesc {
   const uint8_t* params; /* nparams WasmValType bytes */
   uint32_t nparams;
   const uint8_t* results; /* nresults WasmValType bytes */
   uint32_t nresults;
 } KitWasmTypeDesc;
 
 typedef struct KitWasmMemoryImportDesc {
   uint64_t min_pages;
   uint64_t max_pages;
   uint32_t flags;   /* KIT_WASM_MEMORY_* */
   uint32_t has_max; /* nonzero when the import declared an explicit maximum */
 } KitWasmMemoryImportDesc;
 
 typedef struct KitWasmTableImportDesc {
   uint32_t elem_type; /* raw WasmValType byte */
   uint32_t min;
   uint32_t max;
   uint32_t has_max; /* nonzero when the import declared an explicit maximum */
 } KitWasmTableImportDesc;
 
 typedef struct KitWasmGlobalImportDesc {
   uint32_t type; /* raw WasmValType byte */
   uint32_t mutable_;
 } KitWasmGlobalImportDesc;
 
 #endif