/* =========================================================================== * sleela_artifact.c -- persistent Sleela Core runnable artifact support. * * This translation unit intentionally includes the core implementation so the * artifact serializer/loader can use the VM's private program representation * without exposing mutable execution state in the public ABI. * * A .sleela artifact is compiled Core bytecode, not Sleela source. It can be * loaded directly by the Sleela runtime and therefore does not require a * second front-end compilation pass. * =========================================================================== */ #define SLEELA_ARTIFACT_EMBED_CORE 1 #include "sleela_core.c" #include #include #include #define SLART_MAGIC "SLEELA-ART\x01" #define SLART_MAGIC_LEN 11 /* Artifact format v2 adds struct layouts; v3 adds lossless UTF-16 constants * and globals; v4 adds validated per-function @native method identity. * Versions 1-3 remain loadable, with native metadata disabled. */ /* v5 (2026-11-13): each struct type also carries its extends parent and its * further supertypes (implemented interfaces, SLEELA.syntax 43.7). */ /* v6 (2026-11-13): the fault function index (SLEELA.syntax 37.5) follows * the struct table. */ #define SLART_VERSION 6u static int wr(FILE* f, const void* p, size_t n) { return fwrite(p, 1, n, f) == n; } static int rd(FILE* f, void* p, size_t n) { return fread(p, 1, n, f) == n; } static int wr_u32(FILE* f, uint32_t v) { return wr(f, &v, sizeof(v)); } static int rd_u32(FILE* f, uint32_t* v) { return rd(f, v, sizeof(*v)); } static int wr_i32(FILE* f, int32_t v) { return wr(f, &v, sizeof(v)); } static int wr_u32_le(FILE* f, uint32_t v) { uint8_t b[4]={(uint8_t)v,(uint8_t)(v>>8),(uint8_t)(v>>16),(uint8_t)(v>>24)}; return wr(f,b,4); } static int rd_u32_le(FILE* f, uint32_t* v) { uint8_t b[4]; if(!rd(f,b,4)) return 0; *v=(uint32_t)b[0]|((uint32_t)b[1]<<8)|((uint32_t)b[2]<<16)|((uint32_t)b[3]<<24); return 1; } static int wr_u16_le(FILE* f, uint16_t v) { uint8_t b[2]={(uint8_t)v,(uint8_t)(v>>8)}; return wr(f,b,2); } static int rd_u16_le(FILE* f, uint16_t* v) { uint8_t b[2]; if(!rd(f,b,2)) return 0; *v=(uint16_t)b[0]|((uint16_t)b[1]<<8); return 1; } static int rd_i32(FILE* f, int32_t* v) { return rd(f, v, sizeof(*v)); } static int wr_u64(FILE* f, uint64_t v) { return wr(f, &v, sizeof(v)); } static int rd_u64(FILE* f, uint64_t* v) { return rd(f, v, sizeof(*v)); } static int wr_string(FILE* f, const char* s) { uint32_t n = s ? (uint32_t)strlen(s) : 0u; return wr_u32(f, n) && (!n || wr(f, s, n)); } static char* rd_string(FILE* f) { uint32_t n = 0; if (!rd_u32(f, &n) || n > (16u * 1024u * 1024u)) return NULL; char* s = (char*)malloc((size_t)n + 1u); if (!s) return NULL; if (n && !rd(f, s, n)) { free(s); return NULL; } s[n] = '\0'; return s; } static int wr_value(FILE* f, SLVM* vm, SLValue v) { if (!wr_i32(f, (int32_t)v.type)) return 0; switch (v.type) { case SL_INT: return wr_u64(f, (uint64_t)v.as.i); case SL_DOUBLE: return wr(f, &v.as.d, sizeof(v.as.d)); case SL_BOOL: return wr_i32(f, (int32_t)v.as.b); case SL_STR: return wr_i32(f, v.as.s); /* A live struct handle is VM-local runtime state (like a socket/file * handle) and is not persisted; a global holding one saves as null. */ case SL_STRUCT: return 1; case SL_UTF16: { SLJavaStringInstance *instance = java_string_get(vm, v); if (!instance || instance->value.length > INT32_MAX || !wr_u32_le(f, (uint32_t)instance->value.length)) return 0; for (size_t i = 0; i < instance->value.length; ++i) if (!wr_u16_le(f, instance->value.units[i])) return 0; return 1; } case SL_NULL: return 1; default: return 0; } } static int rd_value(FILE* f, SLVM* vm, SLValue* v, uint32_t artifact_version) { int32_t t = 0; if (!rd_i32(f, &t) || t < SL_NULL || t > (artifact_version >= 3u ? SL_UTF16 : SL_STRUCT)) return 0; memset(v, 0, sizeof(*v)); v->type = (SLType)t; switch (v->type) { case SL_INT: { uint64_t x; if (!rd_u64(f, &x)) return 0; v->as.i = (int64_t)x; return 1; } case SL_DOUBLE: return rd(f, &v->as.d, sizeof(v->as.d)); case SL_BOOL: { int32_t x; if (!rd_i32(f, &x)) return 0; v->as.b = x ? 1 : 0; return 1; } case SL_STR: return rd_i32(f, &v->as.s); /* A persisted struct-typed value is loaded as null: the handle it once * named is not meaningful in a freshly loaded VM. */ case SL_STRUCT: v->type = SL_NULL; v->as.i = 0; return 1; case SL_UTF16: { uint32_t length = 0; uint16_t *units = NULL; if (!rd_u32_le(f, &length) || length > INT32_MAX || (size_t)length > SIZE_MAX / sizeof(uint16_t)) return 0; if (length) { units = (uint16_t *)malloc((size_t)length * sizeof(uint16_t)); if (!units) return 0; } for (uint32_t i = 0; i < length; ++i) { if (!rd_u16_le(f, &units[i])) { free(units); return 0; } } *v = slvm_java_string_new(vm, units, length); free(units); return v->type == SL_UTF16; } case SL_NULL: return 1; default: return 0; } } static int sane_count(uint32_t n, uint32_t max) { return n <= max; } static void abi_error(char* error, size_t error_size, const char* msg) { if (error && error_size) { snprintf(error, error_size, "%s", msg ? msg : "artifact ABI validation failed"); } } static int validate_loaded_vm(const SLVM* vm, char* error, size_t error_size) { if (!vm) { abi_error(error, error_size, "null VM"); return 0; } if (vm->entry < 0 || vm->entry >= vm->nfunc) { abi_error(error,error_size,"entry function is outside function table"); return 0; } for (int i=0;infunc;i++) { const SLFunc* fn=&vm->funcs[i]; if (fn->entry < 0 || fn->entry >= vm->codelen) { abi_error(error,error_size,"function entry is outside code"); return 0; } /* nlocals counts the operand-STACK slots a frame lays down at entry * (args + body locals), so it is bounded by the stack[] buffer * (STACK_MAX), NOT by the frames[] buffer (FRAMES_MAX, the call-DEPTH * limit). Validating nlocals against FRAMES_MAX wrongly rejected an * otherwise-legal artifact whose entry (e.g. a local, non-/lib `main`) * declared 1025..STACK_MAX locals -- a file that runs fine straight from * source but failed to load once compiled to a Core artifact. */ if (fn->nargs < 0 || fn->nlocals < fn->nargs || fn->nlocals > STACK_MAX) { abi_error(error,error_size,"function local count exceeds operand-stack limit"); return 0; } if (!native_method_metadata_valid(fn)) { abi_error(error,error_size,"invalid native method metadata"); return 0; } if (fn->native_flags) { for (int j = 0; j < i; ++j) { const SLFunc* prior = &vm->funcs[j]; if (prior->native_flags && prior->native_signature_id == fn->native_signature_id) { abi_error(error,error_size,"duplicate native method signature identity"); return 0; } } } } for (int i=0;icodelen;i++) { const SLInstr* in=&vm->code[i]; if ((unsigned)in->op >= (unsigned)OP__COUNT) { abi_error(error,error_size,"unknown opcode in artifact"); return 0; } switch (in->op) { case OP_CONST: if (in->a < 0 || in->a >= vm->nconst) { abi_error(error,error_size,"constant index outside constant table"); return 0; } break; case OP_LOADG: case OP_STOREG: if (in->a < 0 || in->a >= vm->nglobal) { abi_error(error,error_size,"global index outside global table"); return 0; } break; case OP_CALL: case OP_SPAWN: if (in->a < 0 || in->a >= vm->nfunc) { abi_error(error,error_size,"call target outside function table"); return 0; } break; case OP_MATH_CALL: if (in->a < 0 || in->a >= SL_MATH_FUNCTION_COUNT) { abi_error(error,error_size,"math function ID outside stable scalar math table"); return 0; } break; case OP_NATIVE_CALL: if (in->a < 0 || in->a > STACK_MAX - 2) { abi_error(error,error_size,"native-call argument count outside operand-stack range"); return 0; } break; case OP_IPC_CALL: if (in->a < 0 || in->a > STACK_MAX - 2) { abi_error(error,error_size,"IPC-call argument count outside operand-stack range"); return 0; } break; case OP_IPC_OPEN: case OP_IPC_CLOSE: if (in->a != 0) { abi_error(error,error_size,"IPC open/close opcode has an unexpected operand"); return 0; } break; case OP_JMP: case OP_JMPF: case OP_TRY_PUSH: if (in->a < 0 || in->a >= vm->codelen) { abi_error(error,error_size,"control-flow target outside code"); return 0; } break; case OP_TRY_POP: case OP_THROW: if (in->a != 0) { abi_error(error,error_size,"exception opcode has an unexpected operand"); return 0; } break; case OP_NEWSTRUCT: case OP_STRUCTUNPACK: if (in->a < 0 || in->a >= vm->nstruct_types) { abi_error(error,error_size,"struct type index outside struct table"); return 0; } break; case OP_GETFIELD: case OP_SETFIELD: if (in->a < 0 || in->a >= SL_MAX_STRUCT_FIELDS) { abi_error(error,error_size,"field operand outside ABI field range"); return 0; } break; case OP_LOCK: case OP_UNLOCK: case OP_SEND: case OP_RECV: if (in->a < 0 || in->a >= SL_MAX_LOCKS) { abi_error(error,error_size,"synchronization slot outside ABI range"); return 0; } break; case OP_REF: if (in->a < 0 || SLREF_SEL(in->a) >= SLREF_COUNT) { abi_error(error,error_size,"ref selector outside ABI range"); return 0; } if (SLREF_SEL(in->a) == SLREF_DEREF && SLREF_TYPEIDX(in->a) >= vm->nstruct_types) { abi_error(error,error_size,"ref class operand outside struct table"); return 0; } break; case OP_SYN_STAT: case OP_BEST_STAT: if (in->a < 0 || in->a > 6) { abi_error(error,error_size,"stat selector outside ABI range"); return 0; } break; default: break; } } for (int i=0;instruct_types;i++) { if (vm->struct_types[i].nfields < 0 || vm->struct_types[i].nfields > SL_MAX_STRUCT_FIELDS) { abi_error(error,error_size,"struct field count exceeds ABI limit"); return 0; } } return 1; } uint32_t slvm_artifact_abi_version(void) { return (SLEELA_VM_ABI_MAJOR << 16) | SLEELA_VM_ABI_MINOR; } int slvm_is_artifact_file(const char* path) { if (!path) return 0; FILE* f = fopen(path, "rb"); if (!f) return 0; char magic[SLART_MAGIC_LEN]; int ok = rd(f, magic, sizeof(magic)) && memcmp(magic, SLART_MAGIC, sizeof(magic)) == 0; fclose(f); return ok; } int slvm_save_file(SLVM* vm, const char* path) { if (!vm || !path) return -1; FILE* f = fopen(path, "wb"); if (!f) return -2; int ok = 1; ok = ok && wr(f, SLART_MAGIC, SLART_MAGIC_LEN); ok = ok && wr_u32(f, SLART_VERSION); ok = ok && wr_u32(f, 0x01020304u); /* serialization endian marker */ ok = ok && wr_u32(f, (uint32_t)vm->codelen); ok = ok && wr_u32(f, (uint32_t)vm->nconst); ok = ok && wr_u32(f, (uint32_t)vm->nstr); ok = ok && wr_u32(f, (uint32_t)vm->nglobal); ok = ok && wr_u32(f, (uint32_t)vm->nfunc); ok = ok && wr_u32(f, (uint32_t)vm->nstruct_types); ok = ok && wr_i32(f, (int32_t)vm->entry); for (int i = 0; ok && i < vm->codelen; ++i) { ok = wr(f, &vm->code[i].op, sizeof(vm->code[i].op)) && wr_i32(f, vm->code[i].a); } for (int i = 0; ok && i < vm->nconst; ++i) ok = wr_value(f, vm, vm->consts[i]); for (int i = 0; ok && i < vm->nstr; ++i) ok = wr_string(f, vm->strs[i]); for (int i = 0; ok && i < vm->nglobal; ++i) { ok = wr_string(f, vm->gnames[i]); if (ok) ok = wr_value(f, vm, vm->globals[i]); } for (int i = 0; ok && i < vm->nfunc; ++i) { ok = wr_string(f, vm->funcs[i].name); ok = ok && wr_i32(f, vm->funcs[i].entry); ok = ok && wr_i32(f, vm->funcs[i].nargs); ok = ok && wr_i32(f, vm->funcs[i].nlocals); if (ok) ok = wr_u32(f, vm->funcs[i].native_flags); if (ok) ok = wr_u32(f, vm->funcs[i].native_abi_version); if (ok) ok = wr_u64(f, vm->funcs[i].native_signature_id); if (ok) ok = wr_string(f, vm->funcs[i].native_signature ? vm->funcs[i].native_signature : ""); } for (int i = 0; ok && i < vm->nstruct_types; ++i) { ok = wr_string(f, vm->struct_types[i].name); ok = ok && wr_i32(f, vm->struct_types[i].nfields); for (int j = 0; ok && j < vm->struct_types[i].nfields; ++j) ok = wr_string(f, vm->struct_types[i].fields[j]); ok = ok && wr_i32(f, vm->struct_types[i].parent_type); ok = ok && wr_i32(f, vm->struct_types[i].nsupers); for (int j = 0; ok && j < vm->struct_types[i].nsupers; ++j) ok = wr_i32(f, vm->struct_types[i].supers[j]); } ok = ok && wr_i32(f, vm->fault_func); if (fclose(f) != 0) ok = 0; if (!ok) remove(path); return ok ? 0 : -3; } SLVM* slvm_load_file(const char* path) { if (!path) return NULL; FILE* f = fopen(path, "rb"); if (!f) return NULL; char magic[SLART_MAGIC_LEN]; uint32_t version = 0, endian = 0, codelen = 0, nconst = 0, nstr = 0; uint32_t nglobal = 0, nfunc = 0, nstruct = 0; int32_t entry = -1; if (!rd(f, magic, sizeof(magic)) || memcmp(magic, SLART_MAGIC, sizeof(magic)) != 0 || !rd_u32(f, &version) || !rd_u32(f, &endian) || (version < 1u || version > SLART_VERSION) || endian != 0x01020304u || !rd_u32(f, &codelen) || !rd_u32(f, &nconst) || !rd_u32(f, &nstr) || !rd_u32(f, &nglobal) || !rd_u32(f, &nfunc) || (version >= 2u && !rd_u32(f, &nstruct)) || !rd_i32(f, &entry) || !sane_count(codelen, 10000000u) || !sane_count(nconst, 1000000u) || !sane_count(nstr, 1000000u) || !sane_count(nglobal, 100000u) || !sane_count(nfunc, 100000u) || !sane_count(nstruct, SL_MAX_STRUCT_TYPES)) { fclose(f); return NULL; } SLVM* vm = slvm_new(); if (!vm) { fclose(f); return NULL; } int ok = 1; vm->code = codelen ? (SLInstr*)calloc(codelen, sizeof(SLInstr)) : NULL; vm->consts = nconst ? (SLValue*)calloc(nconst, sizeof(SLValue)) : NULL; vm->strs = nstr ? (char**)calloc(nstr, sizeof(char*)) : NULL; vm->globals = nglobal ? (SLValue*)calloc(nglobal, sizeof(SLValue)) : NULL; vm->gnames = nglobal ? (char**)calloc(nglobal, sizeof(char*)) : NULL; vm->funcs = nfunc ? (SLFunc*)calloc(nfunc, sizeof(SLFunc)) : NULL; /* The layout table is a growable heap array (slvm_new leaves it NULL); the * loader sizes it exactly to the artifact's struct-type count, which * sane_count already bounded by the SL_MAX_STRUCT_TYPES ceiling. */ vm->struct_types = nstruct ? (SLStructType*)calloc(nstruct, sizeof(SLStructType)) : NULL; vm->struct_typecap = (int)nstruct; if ((codelen && !vm->code) || (nconst && !vm->consts) || (nstr && !vm->strs) || (nglobal && (!vm->globals || !vm->gnames)) || (nfunc && !vm->funcs) || (nstruct && !vm->struct_types)) ok = 0; if (ok) { for (uint32_t i = 0; ok && i < codelen; ++i) ok = rd(f, &vm->code[i].op, sizeof(vm->code[i].op)) && rd_i32(f, &vm->code[i].a); for (uint32_t i = 0; ok && i < nconst; ++i) ok = rd_value(f, vm, &vm->consts[i], version); for (uint32_t i = 0; ok && i < nstr; ++i) vm->strs[i] = rd_string(f), ok = vm->strs[i] != NULL; for (uint32_t i = 0; ok && i < nglobal; ++i) { vm->gnames[i] = rd_string(f); ok = vm->gnames[i] != NULL; if (ok) ok = rd_value(f, vm, &vm->globals[i], version); } for (uint32_t i = 0; ok && i < nfunc; ++i) { vm->funcs[i].name = rd_string(f); ok = vm->funcs[i].name != NULL; if (ok) ok = rd_i32(f, &vm->funcs[i].entry); if (ok) ok = rd_i32(f, &vm->funcs[i].nargs); if (ok) ok = rd_i32(f, &vm->funcs[i].nlocals); if (ok && version >= 4u) { char* signature = NULL; ok = rd_u32(f, &vm->funcs[i].native_flags) && rd_u32(f, &vm->funcs[i].native_abi_version) && rd_u64(f, &vm->funcs[i].native_signature_id); if (ok) { signature = rd_string(f); ok = signature != NULL; } if (ok && signature[0]) vm->funcs[i].native_signature = signature; else free(signature); } /* v1-v3 artifacts are deliberately interpreted-only. calloc left * every native metadata field zeroed; no annotation sidecar or * inferred source name can authorize native execution. */ } for (uint32_t i = 0; ok && i < nstruct; ++i) { SLStructType* st = &vm->struct_types[i]; st->name = rd_string(f); ok = st->name != NULL; int32_t nf = 0; if (ok) ok = rd_i32(f, &nf); if (ok && (nf < 0 || nf > SL_MAX_STRUCT_FIELDS)) ok = 0; if (ok) { st->nfields = nf; for (int32_t j = 0; ok && j < nf; ++j) { st->fields[j] = rd_string(f); ok = st->fields[j] != NULL; } } /* v1-v4 carried no hierarchy: every type is a root. */ st->parent_type = -1; if (ok && version >= 5u) { int32_t parent = -1, ns = 0; ok = rd_i32(f, &parent) && rd_i32(f, &ns); if (ok && (parent < -1 || parent >= (int32_t)nstruct || ns < 0 || ns > (int32_t)nstruct)) ok = 0; if (ok) st->parent_type = parent; if (ok && ns > 0) { st->supers = (int*)calloc((size_t)ns, sizeof(int)); ok = st->supers != NULL; for (int32_t j = 0; ok && j < ns; ++j) { int32_t sup = -1; ok = rd_i32(f, &sup) && sup >= 0 && sup < (int32_t)nstruct; if (ok) st->supers[j] = sup; st->nsupers = j + (ok ? 1 : 0); } } } } if (ok) vm->nstruct_types = (int)nstruct; /* v1-v5 carried no fault function: faults throw their message. */ vm->fault_func = -1; if (ok && version >= 6u) { int32_t ff = -1; ok = rd_i32(f, &ff) && ff >= -1 && ff < (int32_t)nfunc && (ff < 0 || vm->funcs[ff].nargs == 2); if (ok) vm->fault_func = ff; } } fclose(f); if (!ok || entry < 0 || entry >= (int32_t)nfunc) { slvm_free(vm); return NULL; } vm->codelen = vm->codecap = (int)codelen; vm->nconst = vm->constcap = (int)nconst; vm->nstr = vm->strcap = (int)nstr; vm->nglobal = vm->globalcap = (int)nglobal; vm->nfunc = vm->funccap = (int)nfunc; vm->entry = entry; vm->cur_func = -1; { char abi_error_text[256]; if (!validate_loaded_vm(vm, abi_error_text, sizeof(abi_error_text))) { slvm_free(vm); return NULL; } } return vm; } int slvm_validate_artifact_file(const char* path, char* error, size_t error_size) { if (!path) { abi_error(error,error_size,"artifact path is null"); return 0; } SLVM* vm = slvm_load_file(path); if (!vm) { abi_error(error,error_size,"artifact failed format/ABI validation"); return 0; } int ok = validate_loaded_vm(vm,error,error_size); slvm_free(vm); return ok; }