zzy/spl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

stage0 重命名字段 修复windows函数没有进入宏包装

Browse Source
This commit is contained in:
zzy
2026-08-14 20:41:09 +08:00
parent c06d7247bb
commit 2a7db9e48c
8 changed files with 355 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

172
stage0/spl_vm.c
View File

@@ -99,7 +99,7 @@ static int spl_type_size(spl_type_t t) {
#define PUSH(v) \
do { \
spl_val_t _pv = (spl_val_t)(v); \
spl_vm_val_t _pv = (spl_vm_val_t)(v); \
if (vm->sp >= vm->config.max_stack_depth) \
VM_ERROR("stack overflow"); \
vm->stacks.data[(vm->sp)++] = _pv; \
@@ -121,8 +121,8 @@ static int spl_type_size(spl_type_t t) {
#define ARITH_BINOP(OP) \
do { \
spl_val_t _b = POP(), _a = POP(); \
spl_val_t _r = 0; \
spl_vm_val_t _b = POP(), _a = POP(); \
spl_vm_val_t _r = 0; \
if (spl_is_float((spl_type_t)ins->type)) { \
double _da, _db, _dr; \
if (ins->type == SPL_F32) { \
@@ -145,25 +145,25 @@ static int spl_type_size(spl_type_t t) {
} else { \
switch (ins->type) { \
case SPL_I8: \
_r = (spl_val_t)((int8_t)_a OP(int8_t) _b); \
_r = (spl_vm_val_t)((int8_t)_a OP(int8_t) _b); \
break; \
case SPL_U8: \
_r = (spl_val_t)((uint8_t)_a OP(uint8_t) _b); \
_r = (spl_vm_val_t)((uint8_t)_a OP(uint8_t) _b); \
break; \
case SPL_I16: \
_r = (spl_val_t)((int16_t)_a OP(int16_t) _b); \
_r = (spl_vm_val_t)((int16_t)_a OP(int16_t) _b); \
break; \
case SPL_U16: \
_r = (spl_val_t)((uint16_t)_a OP(uint16_t) _b); \
_r = (spl_vm_val_t)((uint16_t)_a OP(uint16_t) _b); \
break; \
case SPL_I32: \
_r = (spl_val_t)((int32_t)_a OP(int32_t) _b); \
_r = (spl_vm_val_t)((int32_t)_a OP(int32_t) _b); \
break; \
case SPL_U32: \
_r = (spl_val_t)((uint32_t)_a OP(uint32_t) _b); \
_r = (spl_vm_val_t)((uint32_t)_a OP(uint32_t) _b); \
break; \
case SPL_I64: \
_r = (spl_val_t)((int64_t)_a OP(int64_t) _b); \
_r = (spl_vm_val_t)((int64_t)_a OP(int64_t) _b); \
break; \
case SPL_U64: \
case SPL_PTR: \
@@ -181,10 +181,10 @@ static int spl_type_size(spl_type_t t) {
/* signed division / remainder - all types cast to signed */
#define DIV_REM_S(OP) \
do { \
spl_val_t _b = POP(), _a = POP(); \
spl_vm_val_t _b = POP(), _a = POP(); \
if (_b == 0) \
VM_ERROR("division by zero"); \
spl_val_t _r = 0; \
spl_vm_val_t _r = 0; \
if (spl_is_float((spl_type_t)ins->type)) { \
double _da, _db, _dr; \
if (ins->type == SPL_F32) { \
@@ -207,31 +207,31 @@ static int spl_type_size(spl_type_t t) {
} else { \
switch (ins->type) { \
case SPL_I8: \
_r = (spl_val_t)((int8_t)_a OP(int8_t) _b); \
_r = (spl_vm_val_t)((int8_t)_a OP(int8_t) _b); \
break; \
case SPL_U8: \
_r = (spl_val_t)((int8_t)_a OP(int8_t) _b); \
_r = (spl_vm_val_t)((int8_t)_a OP(int8_t) _b); \
break; \
case SPL_I16: \
_r = (spl_val_t)((int16_t)_a OP(int16_t) _b); \
_r = (spl_vm_val_t)((int16_t)_a OP(int16_t) _b); \
break; \
case SPL_U16: \
_r = (spl_val_t)((int16_t)_a OP(int16_t) _b); \
_r = (spl_vm_val_t)((int16_t)_a OP(int16_t) _b); \
break; \
case SPL_I32: \
_r = (spl_val_t)((int32_t)_a OP(int32_t) _b); \
_r = (spl_vm_val_t)((int32_t)_a OP(int32_t) _b); \
break; \
case SPL_U32: \
_r = (spl_val_t)((int32_t)_a OP(int32_t) _b); \
_r = (spl_vm_val_t)((int32_t)_a OP(int32_t) _b); \
break; \
case SPL_I64: \
_r = (spl_val_t)((int64_t)_a OP(int64_t) _b); \
_r = (spl_vm_val_t)((int64_t)_a OP(int64_t) _b); \
break; \
case SPL_U64: \
case SPL_PTR: \
case SPL_USIZE: \
case SPL_ISIZE: \
_r = (spl_val_t)((int64_t)_a OP(int64_t) _b); \
_r = (spl_vm_val_t)((int64_t)_a OP(int64_t) _b); \
break; \
default: \
VM_ERROR("bad type for signed division"); \
@@ -243,31 +243,31 @@ static int spl_type_size(spl_type_t t) {
/* unsigned division / remainder */
#define DIV_REM_U(OP) \
do { \
spl_val_t _b = POP(), _a = POP(); \
spl_vm_val_t _b = POP(), _a = POP(); \
if (_b == 0) \
VM_ERROR("division by zero"); \
spl_val_t _r = 0; \
spl_vm_val_t _r = 0; \
switch (ins->type) { \
case SPL_I8: \
_r = (spl_val_t)((uint8_t)_a OP(uint8_t) _b); \
_r = (spl_vm_val_t)((uint8_t)_a OP(uint8_t) _b); \
break; \
case SPL_U8: \
_r = (spl_val_t)((uint8_t)_a OP(uint8_t) _b); \
_r = (spl_vm_val_t)((uint8_t)_a OP(uint8_t) _b); \
break; \
case SPL_I16: \
_r = (spl_val_t)((uint16_t)_a OP(uint16_t) _b); \
_r = (spl_vm_val_t)((uint16_t)_a OP(uint16_t) _b); \
break; \
case SPL_U16: \
_r = (spl_val_t)((uint16_t)_a OP(uint16_t) _b); \
_r = (spl_vm_val_t)((uint16_t)_a OP(uint16_t) _b); \
break; \
case SPL_I32: \
_r = (spl_val_t)((uint32_t)_a OP(uint32_t) _b); \
_r = (spl_vm_val_t)((uint32_t)_a OP(uint32_t) _b); \
break; \
case SPL_U32: \
_r = (spl_val_t)((uint32_t)_a OP(uint32_t) _b); \
_r = (spl_vm_val_t)((uint32_t)_a OP(uint32_t) _b); \
break; \
case SPL_I64: \
_r = (spl_val_t)((uint64_t)_a OP(uint64_t) _b); \
_r = (spl_vm_val_t)((uint64_t)_a OP(uint64_t) _b); \
break; \
case SPL_U64: \
case SPL_PTR: \
@@ -284,7 +284,7 @@ static int spl_type_size(spl_type_t t) {
/* CMP_ALL - equality comparisons (all types, floats via memcpy) */
#define CMP_ALL(OP) \
do { \
spl_val_t _b = POP(), _a = POP(); \
spl_vm_val_t _b = POP(), _a = POP(); \
intptr_t _r = 0; \
switch (ins->type) { \
case SPL_I8: \
@@ -338,7 +338,7 @@ static int spl_type_size(spl_type_t t) {
/* CMP_S - signed ordering (all ints cast to signed, floats OK) */
#define CMP_S(OP) \
do { \
spl_val_t _b = POP(), _a = POP(); \
spl_vm_val_t _b = POP(), _a = POP(); \
intptr_t _r = 0; \
switch (ins->type) { \
case SPL_I8: \
@@ -392,7 +392,7 @@ static int spl_type_size(spl_type_t t) {
/* CMP_U - unsigned ordering (all ints cast to unsigned, no float) */
#define CMP_U(OP) \
do { \
spl_val_t _b = POP(), _a = POP(); \
spl_vm_val_t _b = POP(), _a = POP(); \
intptr_t _r = 0; \
switch (ins->type) { \
case SPL_I8: \
@@ -478,6 +478,7 @@ const char *ExceptionCodeToString(DWORD code) {
}
// 全局未处理异常过滤器
#ifdef _WIN32
LONG WINAPI UnhandledExceptionFilterImpl(EXCEPTION_POINTERS *pExceptionInfo) {
// 获取异常记录和上下文
PEXCEPTION_RECORD record = pExceptionInfo->ExceptionRecord;
@@ -537,6 +538,7 @@ LONG WINAPI UnhandledExceptionFilterImpl(EXCEPTION_POINTERS *pExceptionInfo) {
// 你可以在这里调用 exit(1) 或直接返回，进程会被终止
return EXCEPTION_EXECUTE_HANDLER;
}
#endif
/* ================================================================
* spl_vm_init / spl_vm_drop
@@ -614,10 +616,10 @@ void spl_vm_skip_breakpoint(spl_vm_t *vm) {
}
/* 前向声明（定义在文件尾部 dump 区域） */
static const char *func_name_by_ip(spl_prog_t *prog, spl_val_t ip);
static const char *func_name_by_ip(spl_prog_t *prog, spl_vm_val_t ip);
/* 函数名断点命中：addr 所在函数名是否在断点表 */
static int fn_breakpoint_hit(spl_vm_t *vm, spl_val_t addr) {
static int fn_breakpoint_hit(spl_vm_t *vm, spl_vm_val_t addr) {
if (!vm || !vm->prog || !vec_size(vm->fn_breakpoints))
return 0;
const char *fn = func_name_by_ip(vm->prog, addr);
@@ -669,7 +671,7 @@ void spl_vm_set_debug(spl_vm_t *vm, int enabled) {
#define STACK_CANARY(vm) (vm)->stacks.data[(vm)->fp - 1]
static inline int spl_vm_call(spl_vm_t *vm, spl_val_t addr, spl_val_t nargs) {
static inline int spl_vm_call(spl_vm_t *vm, spl_vm_val_t addr, spl_vm_val_t nargs) {
if (vm->cp >= vm->config.max_call_depth)
VM_ERROR("CALLI: call stack overflow");
// spl_vm_stackdump(vm, vm->sp);
@@ -696,7 +698,7 @@ int spl_vm_prepare(spl_vm_t *vm, const char *entry, int argc, const char **argv,
if (!vm || !vm->prog) {
return -1;
}
spl_func_t *fn = spl_prog_get_func(vm->prog, entry ? entry : "main");
spl_vm_func_t *fn = spl_prog_get_func(vm->prog, entry ? entry : "main");
if (!fn) {
fprintf(stderr, "vm: entry point '%s' not found\n", entry ? entry : "main");
return -1;
@@ -733,7 +735,7 @@ int spl_vm_prepare(spl_vm_t *vm, const char *entry, int argc, const char **argv,
* ================================================================ */
int spl_vm_run_once(spl_vm_t *vm) {
const spl_ins_t *ins;
const spl_vm_ins_t *ins;
spl_prog_t *prog;
if (!vm || !vm->prog)
@@ -761,7 +763,7 @@ int spl_vm_run_once(spl_vm_t *vm) {
if (vm->trace) {
fprintf(stderr, "vm: ip=%zd op=%s type=%s imm=%zu sp=%zd fp=%zd\n", vm->ip - 1,
spl_opcode_name(ins->opcode), spl_type_tag_name(ins->type), ins->imm, vm->sp,
spl_vm_opcode_name(ins->opcode), spl_vm_type_kind_name(ins->type), ins->imm, vm->sp,
vm->fp);
}
@@ -775,7 +777,7 @@ int spl_vm_run_once(spl_vm_t *vm) {
case SPL_DUP: {
if (vm->sp < 1)
VM_ERROR("DUP: stack underflow");
spl_val_t _v = vm->stacks.data[vm->sp - 1];
spl_vm_val_t _v = vm->stacks.data[vm->sp - 1];
PUSH(_v);
break;
}
@@ -789,7 +791,7 @@ int spl_vm_run_once(spl_vm_t *vm) {
case SPL_SWAP: {
if (vm->sp < 2)
VM_ERROR("SWAP: stack underflow");
spl_val_t _t = vm->stacks.data[vm->sp - 1];
spl_vm_val_t _t = vm->stacks.data[vm->sp - 1];
vm->stacks.data[vm->sp - 1] = vm->stacks.data[vm->sp - 2];
vm->stacks.data[vm->sp - 2] = _t;
break;
@@ -806,9 +808,9 @@ int spl_vm_run_once(spl_vm_t *vm) {
case SPL_ROT: {
if (vm->sp < 3)
VM_ERROR("ROT: stack underflow");
spl_val_t _a = vm->stacks.data[vm->sp - 3];
spl_val_t _b = vm->stacks.data[vm->sp - 2];
spl_val_t _c = vm->stacks.data[vm->sp - 1];
spl_vm_val_t _a = vm->stacks.data[vm->sp - 3];
spl_vm_val_t _b = vm->stacks.data[vm->sp - 2];
spl_vm_val_t _c = vm->stacks.data[vm->sp - 1];
vm->stacks.data[vm->sp - 3] = _b;
vm->stacks.data[vm->sp - 2] = _c;
vm->stacks.data[vm->sp - 1] = _a;
@@ -840,7 +842,7 @@ int spl_vm_run_once(spl_vm_t *vm) {
break;
case SPL_NEG: {
spl_val_t _a = POP();
spl_vm_val_t _a = POP();
if (spl_is_float((spl_type_t)ins->type)) {
double _d;
if (ins->type == SPL_F32) {
@@ -862,17 +864,17 @@ int spl_vm_run_once(spl_vm_t *vm) {
/* ========== Bitwise ========== */
case SPL_AND: {
spl_val_t _b = POP(), _a = POP();
spl_vm_val_t _b = POP(), _a = POP();
PUSH(_a & _b);
break;
}
case SPL_OR: {
spl_val_t _b = POP(), _a = POP();
spl_vm_val_t _b = POP(), _a = POP();
PUSH(_a | _b);
break;
}
case SPL_XOR: {
spl_val_t _b = POP(), _a = POP();
spl_vm_val_t _b = POP(), _a = POP();
PUSH(_a ^ _b);
break;
}
@@ -946,8 +948,8 @@ int spl_vm_run_once(spl_vm_t *vm) {
}
case SPL_CALL: {
spl_val_t _nargs = ins->imm;
spl_val_t _addr = POP();
spl_vm_val_t _nargs = ins->imm;
spl_vm_val_t _addr = POP();
int _hit = fn_breakpoint_hit(vm, _addr);
spl_vm_call(vm, _addr, _nargs);
if (_hit)
@@ -956,8 +958,8 @@ int spl_vm_run_once(spl_vm_t *vm) {
}
case SPL_CALLI: {
spl_val_t _addr = POP();
spl_val_t _nargs = POP();
spl_vm_val_t _addr = POP();
spl_vm_val_t _nargs = POP();
int _hit = fn_breakpoint_hit(vm, _addr);
spl_vm_call(vm, _addr, _nargs);
if (_hit)
@@ -966,7 +968,7 @@ int spl_vm_run_once(spl_vm_t *vm) {
}
case SPL_RET: {
spl_val_t _retval = 0;
spl_vm_val_t _retval = 0;
if (ins->type != SPL_VOID)
_retval = POP();
if (vm->cp <= 0)
@@ -996,7 +998,7 @@ int spl_vm_run_once(spl_vm_t *vm) {
/* ========== Stack / Frame Local Memory ========== */
case SPL_ALLOC: {
spl_val_t _k = ins->imm;
spl_vm_val_t _k = ins->imm;
uintptr_t _new_sp = vm->sp + _k;
if (_new_sp > vm->config.max_stack_depth)
VM_ERROR("ALLOC: stack overflow");
@@ -1007,14 +1009,14 @@ int spl_vm_run_once(spl_vm_t *vm) {
}
case SPL_LADDR:
PUSH((spl_val_t)((char *)(vm->stacks.data + vm->fp) + ins->imm));
PUSH((spl_vm_val_t)((char *)(vm->stacks.data + vm->fp) + ins->imm));
break;
case SPL_GADDR: {
spl_val_t _idx = ins->imm;
spl_vm_val_t _idx = ins->imm;
if (_idx >= vec_size(prog->gdata))
VM_ERROR("GADDR: global data index out of range");
PUSH((spl_val_t)(uintptr_t)vec_at(prog->gdata, _idx).data);
PUSH((spl_vm_val_t)(uintptr_t)vec_at(prog->gdata, _idx).data);
break;
}
@@ -1022,19 +1024,19 @@ int spl_vm_run_once(spl_vm_t *vm) {
case SPL_LOAD: {
void *_addr = (void *)POP();
CHECK_ADDR(_addr, "LOAD");
spl_val_t _v = 0;
spl_vm_val_t _v = 0;
usize _sz = spl_type_size(ins->type);
memcpy(&_v, _addr, _sz);
/* Sign-extend signed integer types smaller than 64 bits */
if (_sz > 0 && _sz < sizeof(spl_val_t) && spl_is_signed(ins->type)) {
usize _shift = (sizeof(spl_val_t) - _sz) * 8;
_v = (spl_val_t)(((isize)(_v << _shift)) >> _shift);
if (_sz > 0 && _sz < sizeof(spl_vm_val_t) && spl_is_signed(ins->type)) {
usize _shift = (sizeof(spl_vm_val_t) - _sz) * 8;
_v = (spl_vm_val_t)(((isize)(_v << _shift)) >> _shift);
}
PUSH(_v);
break;
}
case SPL_STORE: {
spl_val_t _v = POP();
spl_vm_val_t _v = POP();
void *_addr = (void *)POP();
CHECK_ADDR(_addr, "STORE");
memcpy(_addr, &_v, spl_type_size(ins->type));
@@ -1043,12 +1045,12 @@ int spl_vm_run_once(spl_vm_t *vm) {
/* ========== Type Conversion ========== */
case SPL_TRUNC: {
spl_val_t _v = POP();
spl_vm_val_t _v = POP();
intptr_t _bits = ins->imm;
if (_bits < 1 || _bits > 64)
VM_ERROR("TRUNC: bad bit-width");
if (_bits < 64) {
spl_val_t _mask = ((spl_val_t)1 << _bits) - 1;
spl_vm_val_t _mask = ((spl_vm_val_t)1 << _bits) - 1;
_v &= _mask;
}
PUSH(_v);
@@ -1056,13 +1058,13 @@ int spl_vm_run_once(spl_vm_t *vm) {
}
case SPL_SEXT: {
spl_val_t _v = POP();
spl_vm_val_t _v = POP();
intptr_t _bits = ins->imm;
if (_bits < 1 || _bits > 64)
VM_ERROR("SEXT: bad bit-width");
if (_bits < 64) {
spl_val_t _sign = (spl_val_t)1 << (_bits - 1);
spl_val_t _mask = ((spl_val_t)1 << _bits) - 1;
spl_vm_val_t _sign = (spl_vm_val_t)1 << (_bits - 1);
spl_vm_val_t _mask = ((spl_vm_val_t)1 << _bits) - 1;
_v &= _mask;
if (_v & _sign)
_v |= ~_mask;
@@ -1072,12 +1074,12 @@ int spl_vm_run_once(spl_vm_t *vm) {
}
case SPL_ZEXT: {
spl_val_t _v = POP();
spl_vm_val_t _v = POP();
intptr_t _bits = ins->imm;
if (_bits < 1 || _bits > 64)
VM_ERROR("ZEXT: bad bit-width");
if (_bits < 64)
_v &= ((spl_val_t)1 << _bits) - 1;
_v &= ((spl_vm_val_t)1 << _bits) - 1;
PUSH(_v);
break;
}
@@ -1085,8 +1087,8 @@ int spl_vm_run_once(spl_vm_t *vm) {
/* ========== Native Interface ========== */
case SPL_NCALL: {
intptr_t _nargs = ins->imm;
spl_val_t _nat_idx = POP();
spl_native_t *_nat;
spl_vm_val_t _nat_idx = POP();
spl_vm_native_t *_nat;
if (_nat_idx >= vec_size(prog->natives))
VM_ERROR("NCALL: native index out of range");
_nat = &vec_at(prog->natives, _nat_idx);
@@ -1095,18 +1097,18 @@ int spl_vm_run_once(spl_vm_t *vm) {
"NCALL: NULL native function pointer expect %s", _nat->name);
VM_ERROR(vm->error_msg);
}
spl_val_t *_arg_base = vm->stacks.data + vm->sp - _nargs;
spl_vm_val_t *_arg_base = vm->stacks.data + vm->sp - _nargs;
// spl_vm_stackdump(vm, vm->sp);
// printf("addr %p nargs %zd sp %zd stack %p arg_base %p\n", _nat->impl_fn, _nargs, vm->sp,
// vm->stacks.data, _arg_base);
spl_val_t _result = _nat->impl_fn(_nargs, _arg_base);
spl_vm_val_t _result = _nat->impl_fn(_nargs, _arg_base);
vm->sp -= _nargs;
PUSH(_result);
break;
}
case SPL_NLIB: {
spl_val_t _si = ins->imm;
spl_vm_val_t _si = ins->imm;
const char *_lib;
if (_si >= vec_size(prog->strtab) || !vec_at(prog->strtab, _si))
VM_ERROR("NLIB: invalid string index");
@@ -1175,44 +1177,44 @@ int spl_vm_run_until(spl_vm_t *vm, size_t step) {
}
}
static const char *func_name_by_ip(spl_prog_t *prog, spl_val_t ip) {
static const char *func_name_by_ip(spl_prog_t *prog, spl_vm_val_t ip) {
vec_for(prog->funcs, i) {
spl_func_t *f = &vec_at(prog->funcs, i);
spl_vm_func_t *f = &vec_at(prog->funcs, i);
if (ip >= f->address && ip < (f->address + f->ninsns))
return f->name;
}
return "?";
}
void spl_vm_dump_instr(spl_vm_t *vm, spl_val_t ip) {
void spl_vm_dump_instr(spl_vm_t *vm, spl_vm_val_t ip) {
if (!vm || !vm->prog)
return;
if (ip >= vec_size(vm->prog->insns))
return;
spl_ins_t *ins = &vec_at(vm->prog->insns, ip);
fprintf(stderr, " instr at ip=%zd: op=%s type=%s imm=%zu\n", ip, spl_opcode_name(ins->opcode),
spl_type_tag_name(ins->type), ins->imm);
spl_vm_ins_t *ins = &vec_at(vm->prog->insns, ip);
fprintf(stderr, " instr at ip=%zd: op=%s type=%s imm=%zu\n", ip,
spl_vm_opcode_name(ins->opcode), spl_vm_type_kind_name(ins->type), ins->imm);
}
void spl_vm_stackdump(spl_vm_t *vm, spl_val_t sp) {
void spl_vm_stackdump(spl_vm_t *vm, spl_vm_val_t sp) {
if (!vm)
return;
fprintf(stderr, "stack dump (sp=%zd, fp=%zd):\n", sp, vm->fp);
spl_val_t start = sp > 32 ? sp - 32 : 0;
for (spl_val_t i = start; i <= sp; i++) {
spl_vm_val_t start = sp > 32 ? sp - 32 : 0;
for (spl_vm_val_t i = start; i <= sp; i++) {
fprintf(stderr, " [%3zd] = [addr 0x%p] 0x%016zx (%zd)\n", i, &vm->stacks.data[i],
vm->stacks.data[i], vm->stacks.data[i]);
}
}
int spl_vm_backtrace(spl_vm_t *vm, spl_val_t fp) {
int spl_vm_backtrace(spl_vm_t *vm, spl_vm_val_t fp) {
if (!vm || !vm->prog)
return -1;
(void)fp;
fprintf(stderr, "backtrace: \n");
for (isize i = vm->cp - 1; i >= 0; i--) {
spl_val_t _saved_ip = vm->frames.data[i].saved_ip;
spl_val_t _saved_fp = vm->frames.data[i].saved_fp;
spl_vm_val_t _saved_ip = vm->frames.data[i].saved_ip;
spl_vm_val_t _saved_fp = vm->frames.data[i].saved_fp;
const char *_fn = func_name_by_ip(vm->prog, _saved_ip - 1);
fprintf(stderr, " [%3zd] %s (fp=%zd, ip=%zd, args=%zd)\n", i, _fn, _saved_fp, _saved_ip,
vm->frames.data[i].nargs);