934 lines
36 KiB
C
934 lines
36 KiB
C
#include "spl_syscall.h"
|
|
#include "include/core_map.h"
|
|
#include "include/core_vec.h"
|
|
#include "spl_mcode.h"
|
|
#include "spl_vm.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
/* VM 偏移 -> 宿主地址；size=0 表示不做边界检查。 */
|
|
#define VM_X(_vm, off) ((void *)spl_vm_xlate((_vm), (spl_vm_val_t)(off), 0))
|
|
#define VM_XN(_vm, off, n) ((void *)spl_vm_xlate((_vm), (spl_vm_val_t)(off), (usize)(n)))
|
|
#define VM_ASP(_vm) spl_vm_asp(_vm)
|
|
|
|
#define CHECK_NARGS(fname, expected) \
|
|
do { \
|
|
if (nargs != (expected)) { \
|
|
fprintf(stderr, fname ": expected " #expected " args, got %d\n", nargs); \
|
|
return -1; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define SYSCALL_0(name, ret_expr) \
|
|
static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) { \
|
|
(void)_vm; \
|
|
CHECK_NARGS(#name, 0); \
|
|
(void)args; \
|
|
return (spl_vm_val_t)(uintptr_t)(ret_expr); \
|
|
}
|
|
|
|
#define SYSCALL_1(name, t1, ret_expr) \
|
|
static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) { \
|
|
(void)_vm; \
|
|
CHECK_NARGS(#name, 1); \
|
|
t1 a1 = (t1)(uintptr_t)args[0]; \
|
|
return (spl_vm_val_t)(uintptr_t)(ret_expr); \
|
|
}
|
|
|
|
#define SYSCALL_2(name, t1, t2, ret_expr) \
|
|
static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) { \
|
|
(void)_vm; \
|
|
CHECK_NARGS(#name, 2); \
|
|
t1 a1 = (t1)(uintptr_t)args[0]; \
|
|
t2 a2 = (t2)(uintptr_t)args[1]; \
|
|
return (spl_vm_val_t)(uintptr_t)(ret_expr); \
|
|
}
|
|
|
|
#define SYSCALL_3(name, t1, t2, t3, ret_expr) \
|
|
static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) { \
|
|
(void)_vm; \
|
|
CHECK_NARGS(#name, 3); \
|
|
t1 a1 = (t1)(uintptr_t)args[0]; \
|
|
t2 a2 = (t2)(uintptr_t)args[1]; \
|
|
t3 a3 = (t3)(uintptr_t)args[2]; \
|
|
return (spl_vm_val_t)(uintptr_t)(ret_expr); \
|
|
}
|
|
|
|
#define SYSCALL_4(name, t1, t2, t3, t4, ret_expr) \
|
|
static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) { \
|
|
(void)_vm; \
|
|
CHECK_NARGS(#name, 4); \
|
|
t1 a1 = (t1)(uintptr_t)args[0]; \
|
|
t2 a2 = (t2)(uintptr_t)args[1]; \
|
|
t3 a3 = (t3)(uintptr_t)args[2]; \
|
|
t4 a4 = (t4)(uintptr_t)args[3]; \
|
|
return (spl_vm_val_t)(uintptr_t)(ret_expr); \
|
|
}
|
|
|
|
#define ADDRCHECK(vm, ptr, size, ctx) \
|
|
do { \
|
|
uintptr_t _acp = (uintptr_t)(ptr); \
|
|
usize _acs = (usize)(size); \
|
|
if (!spl_vm_addr_valid(_acp, _acs)) { \
|
|
fprintf(stderr, "%s: invalid address %p size=%zu (ip=%zu fp=%zu sp=%zu)\n", (ctx), \
|
|
(void *)_acp, _acs, (vm)->ip, (vm)->fp, (vm)->sp); \
|
|
spl_vm_backtrace((vm), (vm)->fp); \
|
|
(vm)->exit_code = 2; \
|
|
return 0; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define SYSCALL_DUMP(vm) \
|
|
do { \
|
|
fprintf(stderr, " --- syscall dump (sp=%zu fp=%zu cp=%zu ip=%zu) ---\n", (vm)->sp, \
|
|
(vm)->fp, (vm)->cp, (vm)->ip); \
|
|
spl_vm_backtrace((vm), (vm)->fp); \
|
|
spl_vm_stackdump((vm), (vm)->sp); \
|
|
} while (0)
|
|
|
|
#define SYSCALL_FAIL(vm, ...) \
|
|
do { \
|
|
fprintf(stderr, "syscall error: "); \
|
|
fprintf(stderr, __VA_ARGS__); \
|
|
fprintf(stderr, "\n"); \
|
|
SYSCALL_DUMP(vm); \
|
|
(vm)->exit_code = 1; \
|
|
return 0; \
|
|
} while (0)
|
|
|
|
/* =================================================================
|
|
* 从共享核心 spl_rt_core.h 派生的 syscall 包装
|
|
* ================================================================= */
|
|
|
|
#include "spl_rt_core.h"
|
|
|
|
#define SPL_WRAP1(name, fn, t1) \
|
|
static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) { \
|
|
(void)_vm; \
|
|
CHECK_NARGS(#name, 1); \
|
|
return (spl_vm_val_t)(uintptr_t)fn((t1)(uintptr_t)args[0]); \
|
|
}
|
|
|
|
#define SPL_WRAP1_V(name, fn, t1) \
|
|
static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) { \
|
|
(void)_vm; \
|
|
CHECK_NARGS(#name, 1); \
|
|
fn((t1)(uintptr_t)args[0]); \
|
|
return 0; \
|
|
}
|
|
|
|
#define SPL_WRAP2(name, fn, t1, t2) \
|
|
static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) { \
|
|
(void)_vm; \
|
|
CHECK_NARGS(#name, 2); \
|
|
return (spl_vm_val_t)(uintptr_t)fn((t1)(uintptr_t)args[0], (t2)(uintptr_t)args[1]); \
|
|
}
|
|
|
|
#define SPL_WRAP3(name, fn, t1, t2, t3) \
|
|
static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) { \
|
|
(void)_vm; \
|
|
CHECK_NARGS(#name, 3); \
|
|
return (spl_vm_val_t)(uintptr_t)fn((t1)(uintptr_t)args[0], (t2)(uintptr_t)args[1], \
|
|
(t3)(uintptr_t)args[2]); \
|
|
}
|
|
|
|
#define SPL_WRAP4(name, fn, t1, t2, t3, t4) \
|
|
static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) { \
|
|
(void)_vm; \
|
|
CHECK_NARGS(#name, 4); \
|
|
return (spl_vm_val_t)(uintptr_t)fn((t1)(uintptr_t)args[0], (t2)(uintptr_t)args[1], \
|
|
(t3)(uintptr_t)args[2], (t4)(uintptr_t)args[3]); \
|
|
}
|
|
|
|
/* =================================================================
|
|
* OS syscalls
|
|
* ================================================================= */
|
|
|
|
SYSCALL_1(vm_exit, int, (exit(a1), (spl_vm_val_t)0))
|
|
SYSCALL_1(vm_putchar, int, putchar(a1))
|
|
SYSCALL_0(vm_getchar, getchar())
|
|
SYSCALL_1(vm_putint, int, (fprintf(stdout, "%d", a1), (spl_vm_val_t)0))
|
|
|
|
/* FILE* 存于 VM 空间，返回其偏移（不透明句柄）。 */
|
|
static spl_vm_val_t vm_file_handle(spl_vm_t *vm, FILE *f) {
|
|
spl_vm_val_t off;
|
|
FILE **slot;
|
|
if (!f)
|
|
return 0;
|
|
off = (spl_vm_val_t)(uintptr_t)spl_alloc_ex(VM_ASP(vm), sizeof(FILE *));
|
|
if (off == 0)
|
|
return 0;
|
|
slot = (FILE **)VM_XN(vm, off, sizeof(FILE *));
|
|
if (!slot)
|
|
return 0;
|
|
*slot = f;
|
|
return off;
|
|
}
|
|
|
|
static FILE *vm_file_get(spl_vm_t *vm, spl_vm_val_t off) {
|
|
FILE **slot = (FILE **)VM_XN(vm, off, sizeof(FILE *));
|
|
return slot ? *slot : NULL;
|
|
}
|
|
|
|
static spl_vm_val_t vm_putstr(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
const char *s;
|
|
CHECK_NARGS("vm_putstr", 1);
|
|
s = (const char *)VM_X(_vm, args[0]);
|
|
if (s)
|
|
fputs(s, stdout);
|
|
return 0;
|
|
}
|
|
|
|
static spl_vm_val_t vm_fopen(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
const char *path, *mode;
|
|
CHECK_NARGS("vm_fopen", 2);
|
|
path = (const char *)VM_X(_vm, args[0]);
|
|
mode = (const char *)VM_X(_vm, args[1]);
|
|
return vm_file_handle(_vm, fopen(path, mode));
|
|
}
|
|
|
|
static spl_vm_val_t vm_fclose(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
FILE *f;
|
|
CHECK_NARGS("vm_fclose", 1);
|
|
f = vm_file_get(_vm, args[0]);
|
|
return f ? (spl_vm_val_t)fclose(f) : 0;
|
|
}
|
|
|
|
static spl_vm_val_t vm_fread(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
void *buf;
|
|
FILE *f;
|
|
CHECK_NARGS("vm_fread", 4);
|
|
buf = VM_X(_vm, args[0]);
|
|
f = vm_file_get(_vm, args[3]);
|
|
if (!buf || !f)
|
|
return 0;
|
|
return (spl_vm_val_t)fread(buf, (size_t)args[1], (size_t)args[2], f);
|
|
}
|
|
|
|
static spl_vm_val_t vm_fwrite(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
const void *buf;
|
|
FILE *f;
|
|
CHECK_NARGS("vm_fwrite", 4);
|
|
buf = VM_X(_vm, args[0]);
|
|
f = vm_file_get(_vm, args[3]);
|
|
if (!buf || !f)
|
|
return 0;
|
|
return (spl_vm_val_t)fwrite(buf, (size_t)args[1], (size_t)args[2], f);
|
|
}
|
|
|
|
static spl_vm_val_t vm_fsize(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
FILE *f;
|
|
long cur, sz;
|
|
CHECK_NARGS("vm_fsize", 1);
|
|
f = vm_file_get(_vm, args[0]);
|
|
if (!f)
|
|
return 0;
|
|
cur = ftell(f);
|
|
fseek(f, 0, SEEK_END);
|
|
sz = ftell(f);
|
|
fseek(f, cur, SEEK_SET);
|
|
return (spl_vm_val_t)(uintptr_t)(sz < 0 ? 0 : sz);
|
|
}
|
|
|
|
static spl_vm_val_t vm_std_handle(spl_vm_t *_vm, int which) {
|
|
if (_vm->stdio_off[which] == 0) {
|
|
FILE *f = which == 0 ? stdin : (which == 1 ? stdout : stderr);
|
|
_vm->stdio_off[which] = vm_file_handle(_vm, f);
|
|
}
|
|
return _vm->stdio_off[which];
|
|
}
|
|
|
|
static spl_vm_val_t vm_stdin(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)args;
|
|
CHECK_NARGS("vm_stdin", 0);
|
|
return vm_std_handle(_vm, 0);
|
|
}
|
|
static spl_vm_val_t vm_stdout(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)args;
|
|
CHECK_NARGS("vm_stdout", 0);
|
|
return vm_std_handle(_vm, 1);
|
|
}
|
|
static spl_vm_val_t vm_stderr(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)args;
|
|
CHECK_NARGS("vm_stderr", 0);
|
|
return vm_std_handle(_vm, 2);
|
|
}
|
|
|
|
static spl_vm_val_t vm_read_file(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_read_file", 1);
|
|
const char *path = (const char *)VM_X(_vm, args[0]);
|
|
FILE *f;
|
|
long sz;
|
|
spl_vm_val_t off;
|
|
char *buf;
|
|
if (path == nullptr) {
|
|
fprintf(stderr, "filepath can't be null");
|
|
return 0;
|
|
}
|
|
f = fopen(path, "rb");
|
|
if (!f) {
|
|
fprintf(stderr, "filepath %s can't be open", path);
|
|
return 1;
|
|
}
|
|
fseek(f, 0, SEEK_END);
|
|
sz = ftell(f);
|
|
fseek(f, 0, SEEK_SET);
|
|
off = (spl_vm_val_t)(uintptr_t)spl_alloc_ex(VM_ASP(_vm), (uintptr_t)sz + 1);
|
|
if (off == 0) {
|
|
fclose(f);
|
|
return 0;
|
|
}
|
|
buf = (char *)VM_XN(_vm, off, (uintptr_t)sz + 1);
|
|
if (!buf) {
|
|
fclose(f);
|
|
return 0;
|
|
}
|
|
{
|
|
size_t nread = fread(buf, 1, (size_t)sz, f);
|
|
buf[nread] = '\0';
|
|
}
|
|
fclose(f);
|
|
return off;
|
|
}
|
|
|
|
/* =================================================================
|
|
* mem syscalls —— 使用 spl_rt_core.h 中的实现
|
|
* ================================================================= */
|
|
|
|
static spl_vm_val_t spl_sys_vm_alloc(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
uintptr_t sz;
|
|
spl_vm_val_t p;
|
|
CHECK_NARGS("vm_alloc", 1);
|
|
sz = (uintptr_t)args[0];
|
|
if (sz == 0)
|
|
SYSCALL_FAIL(_vm, "vm_alloc: zero size");
|
|
if (sz > ((uintptr_t)1 << 32))
|
|
SYSCALL_FAIL(_vm, "vm_alloc: size too large (%zu)", (size_t)sz);
|
|
p = (spl_vm_val_t)(uintptr_t)spl_alloc_ex(VM_ASP(_vm), sz);
|
|
if (p == 0)
|
|
SYSCALL_FAIL(_vm, "vm_alloc: alloc(%zu) failed", (size_t)sz);
|
|
return p;
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_free(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_free", 1);
|
|
spl_free_ex(VM_ASP(_vm), (void *)(uintptr_t)args[0]);
|
|
return 0;
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_realloc(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
uintptr_t sz;
|
|
spl_vm_val_t np;
|
|
CHECK_NARGS("vm_realloc", 2);
|
|
sz = (uintptr_t)args[1];
|
|
if (args[0] == 0)
|
|
SYSCALL_FAIL(_vm, "vm_realloc: NULL ptr");
|
|
if (sz == 0)
|
|
SYSCALL_FAIL(_vm, "vm_realloc: zero size");
|
|
np = (spl_vm_val_t)(uintptr_t)spl_realloc_ex(VM_ASP(_vm), (void *)(uintptr_t)args[0], sz);
|
|
if (np == 0)
|
|
SYSCALL_FAIL(_vm, "vm_realloc: realloc failed");
|
|
return np;
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_memcpy(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
void *dst, *src;
|
|
uintptr_t n;
|
|
CHECK_NARGS("vm_memcpy", 3);
|
|
n = (uintptr_t)args[2];
|
|
if (n == 0)
|
|
return args[0];
|
|
dst = VM_X(_vm, args[0]);
|
|
src = VM_X(_vm, args[1]);
|
|
if (!dst || !src)
|
|
SYSCALL_FAIL(_vm, "vm_memcpy: invalid address");
|
|
vm_memcpy(dst, src, n);
|
|
return args[0];
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_memmove(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
void *dst, *src;
|
|
uintptr_t n;
|
|
CHECK_NARGS("vm_memmove", 3);
|
|
n = (uintptr_t)args[2];
|
|
if (n == 0)
|
|
return args[0];
|
|
dst = VM_X(_vm, args[0]);
|
|
src = VM_X(_vm, args[1]);
|
|
if (!dst || !src)
|
|
SYSCALL_FAIL(_vm, "vm_memmove: invalid address");
|
|
vm_memmove(dst, src, n);
|
|
return args[0];
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_memcmp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
const void *a, *b;
|
|
uintptr_t n;
|
|
CHECK_NARGS("vm_memcmp", 3);
|
|
a = VM_X(_vm, args[0]);
|
|
b = VM_X(_vm, args[1]);
|
|
n = (uintptr_t)args[2];
|
|
if (n && (!a || !b))
|
|
SYSCALL_FAIL(_vm, "vm_memcmp: invalid address");
|
|
return (spl_vm_val_t)(uintptr_t)vm_memcmp(a, b, n);
|
|
}
|
|
|
|
/* =================================================================
|
|
* Vec syscalls（参数按 VM 偏移解释）
|
|
* ================================================================= */
|
|
|
|
#define VM_VEC_BYTES ((uintptr_t)sizeof(spl_vec_t))
|
|
#define VM_MAP_BYTES ((uintptr_t)sizeof(spl_map_t))
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_valid(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_valid", 1);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_valid_ex(VM_XN(_vm, args[0], VM_VEC_BYTES));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_push_raw(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_push_raw", 2);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_push_raw_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), VM_X(_vm, args[1]));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_push(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_push", 2);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_push_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), VM_X(_vm, args[1]));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_get(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_get", 3);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_get_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), (uintptr_t)args[1],
|
|
(void **)VM_XN(_vm, args[2], sizeof(void *)));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_allocate(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_allocate", 4);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_allocate_out_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), (uintptr_t)args[1], (uintptr_t)args[2],
|
|
(uintptr_t)args[3]);
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_reserve_raw(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_reserve_raw", 2);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_reserve_raw_void_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), (uintptr_t)args[1]);
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_append(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_append", 3);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_append_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), VM_X(_vm, args[1]), (uintptr_t)args[2]);
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_set(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_set", 3);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_set_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), (uintptr_t)args[1], VM_X(_vm, args[2]));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_pop(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_pop", 2);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_pop_ex(VM_ASP(_vm),
|
|
VM_XN(_vm, args[0], VM_VEC_BYTES),
|
|
VM_X(_vm, args[1]));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_clone(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_clone", 2);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_clone_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), VM_XN(_vm, args[1], VM_VEC_BYTES));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_vec_drop(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_vec_drop", 1);
|
|
return (spl_vm_val_t)(uintptr_t)spl_vec_drop_ex(VM_ASP(_vm),
|
|
VM_XN(_vm, args[0], VM_VEC_BYTES));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_bytes_eq(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_bytes_eq", 4);
|
|
return (spl_vm_val_t)(uintptr_t)spl_bytes_eq_ex(VM_ASP(_vm), VM_X(_vm, args[0]),
|
|
(uintptr_t)args[1], VM_X(_vm, args[2]),
|
|
(uintptr_t)args[3]);
|
|
}
|
|
|
|
/* =================================================================
|
|
* Map syscalls
|
|
* ================================================================= */
|
|
|
|
static spl_vm_val_t spl_sys_vm_map_valid(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_map_valid", 1);
|
|
return (spl_vm_val_t)(uintptr_t)spl_map_valid_ex(VM_XN(_vm, args[0], VM_MAP_BYTES));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_map_reserve(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_map_reserve", 2);
|
|
return (spl_vm_val_t)(uintptr_t)spl_map_reserve_void_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_MAP_BYTES), (uintptr_t)args[1]);
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_map_put(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_map_put", 3);
|
|
return (spl_vm_val_t)(uintptr_t)spl_map_put_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_MAP_BYTES), VM_X(_vm, args[1]), VM_X(_vm, args[2]));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_map_get(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_map_get", 3);
|
|
return (spl_vm_val_t)(uintptr_t)spl_map_get_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_MAP_BYTES), VM_X(_vm, args[1]), VM_X(_vm, args[2]));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_map_del(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_map_del", 2);
|
|
return (spl_vm_val_t)(uintptr_t)spl_map_del_ex(
|
|
VM_ASP(_vm), VM_XN(_vm, args[0], VM_MAP_BYTES), VM_X(_vm, args[1]));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_map_clear(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_map_clear", 1);
|
|
return (spl_vm_val_t)(uintptr_t)spl_map_clear_ex(VM_ASP(_vm),
|
|
VM_XN(_vm, args[0], VM_MAP_BYTES));
|
|
}
|
|
|
|
static spl_vm_val_t spl_sys_vm_map_drop(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_map_drop", 1);
|
|
return (spl_vm_val_t)(uintptr_t)spl_map_drop_ex(VM_ASP(_vm),
|
|
VM_XN(_vm, args[0], VM_MAP_BYTES));
|
|
}
|
|
|
|
/* =================================================================
|
|
* printf / timestamp
|
|
* ================================================================= */
|
|
|
|
static spl_vm_val_t vm_printf(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
if (nargs <= 0)
|
|
return 0;
|
|
|
|
const spl_vm_val_t *fmt_slice =
|
|
(const spl_vm_val_t *)VM_XN(_vm, args[0], 2 * sizeof(spl_vm_val_t));
|
|
const char *fmt;
|
|
usize fmt_len;
|
|
if (!fmt_slice)
|
|
return 0;
|
|
fmt = (const char *)VM_X(_vm, fmt_slice[0]);
|
|
fmt_len = (usize)fmt_slice[1];
|
|
if (!fmt && fmt_len)
|
|
return 0;
|
|
|
|
if (nargs <= 1) {
|
|
fwrite(fmt, 1, fmt_len, stdout);
|
|
return (spl_vm_val_t)nargs;
|
|
}
|
|
|
|
typedef VEC(char) string_builder_t;
|
|
string_builder_t buffer;
|
|
vec_init(buffer);
|
|
|
|
int arg_idx = 1;
|
|
char tmp_buf[32];
|
|
|
|
for (usize i = 0; i < fmt_len; ++i) {
|
|
if (fmt[i] != '%') {
|
|
vec_push(buffer, fmt[i]);
|
|
continue;
|
|
}
|
|
if (++i >= fmt_len)
|
|
break;
|
|
if (arg_idx >= nargs)
|
|
break;
|
|
|
|
switch (fmt[i]) {
|
|
case 'd': {
|
|
memset(tmp_buf, 0, sizeof(tmp_buf));
|
|
snprintf(tmp_buf, sizeof(tmp_buf), "%zd", (isize)args[arg_idx]);
|
|
for (usize j = 0; tmp_buf[j] != '\0'; ++j)
|
|
vec_push(buffer, tmp_buf[j]);
|
|
arg_idx++;
|
|
break;
|
|
}
|
|
case 'c':
|
|
vec_push(buffer, (char)args[arg_idx]);
|
|
arg_idx++;
|
|
break;
|
|
case 's': {
|
|
const spl_vm_val_t *s =
|
|
(const spl_vm_val_t *)VM_XN(_vm, args[arg_idx], 2 * sizeof(spl_vm_val_t));
|
|
const char *p = s ? (const char *)VM_X(_vm, s[0]) : NULL;
|
|
usize l = s ? (usize)s[1] : 0;
|
|
if (p)
|
|
for (usize j = 0; j < l; ++j)
|
|
vec_push(buffer, p[j]);
|
|
arg_idx++;
|
|
break;
|
|
}
|
|
default:
|
|
vec_push(buffer, '%');
|
|
vec_push(buffer, fmt[i]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (vec_size(buffer) > 0)
|
|
fwrite(buffer.data, 1, vec_size(buffer), stdout);
|
|
vec_free(buffer);
|
|
return (spl_vm_val_t)nargs;
|
|
}
|
|
|
|
static spl_vm_val_t vm_timestamp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_timestamp", 1);
|
|
spl_vm_val_t arg = args[0];
|
|
struct timespec ts;
|
|
int has_time = (timespec_get(&ts, TIME_UTC) == TIME_UTC);
|
|
switch (arg) {
|
|
case 0:
|
|
return has_time ? 1 : 0;
|
|
case 1:
|
|
return has_time ? (spl_vm_val_t)ts.tv_sec : 0;
|
|
case 2:
|
|
return has_time ? (spl_vm_val_t)ts.tv_nsec : 0;
|
|
case 3:
|
|
if (!_vm)
|
|
return 0;
|
|
return (spl_vm_val_t)_vm->steps;
|
|
case 5:
|
|
if (!_vm)
|
|
return 0;
|
|
return (spl_vm_val_t)_vm->ncalls;
|
|
case 4:
|
|
return has_time ? (spl_vm_val_t)((unsigned long long)ts.tv_sec * 1000000000ull +
|
|
(unsigned long long)ts.tv_nsec)
|
|
: 0;
|
|
default:
|
|
fprintf(stderr, "vm_timestamp: invalid arg %zu\n", (size_t)arg);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* =================================================================
|
|
* nested-VM syscalls
|
|
* ================================================================= */
|
|
|
|
/* ---- 配置层的“外部函数处理器”：把某个 VM 未解析的 native 交给调用者 VM。
|
|
* 这是配置策略，不属于 VM 库 API；VM 本身只有通用 foreign 钩子。 ---- */
|
|
typedef struct {
|
|
spl_vm_t *caller;
|
|
void *ctx;
|
|
} spl_foreign_t;
|
|
|
|
static spl_vm_val_t spl_foreign_reenter(spl_vm_t *vm, const spl_vm_call_t *call, void *user) {
|
|
spl_foreign_t *f = (spl_foreign_t *)user;
|
|
spl_vm_val_t tmp[20];
|
|
spl_vm_call_t c2;
|
|
int i;
|
|
(void)vm;
|
|
if (!f || !f->caller || !call || !call->name)
|
|
return 0;
|
|
if (call->nargs + 1 > (usize)(sizeof(tmp) / sizeof(tmp[0])))
|
|
return 0;
|
|
tmp[0] = (spl_vm_val_t)(uintptr_t)f->ctx;
|
|
for (i = 0; i < (int)call->nargs; i++)
|
|
tmp[1 + i] = call->args ? call->args[i] : 0;
|
|
c2.name = call->name;
|
|
c2.args = tmp;
|
|
c2.nargs = call->nargs + 1;
|
|
c2.ret = 0;
|
|
if (spl_vm_invoke(f->caller, &c2) != 0)
|
|
return 0;
|
|
return c2.ret;
|
|
}
|
|
|
|
static spl_vm_val_t vm_new(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_new", 0);
|
|
(void)args;
|
|
(void)_vm;
|
|
spl_vm_t *vm = (spl_vm_t *)malloc(sizeof(spl_vm_t));
|
|
if (!vm)
|
|
return 0;
|
|
spl_vm_init(vm);
|
|
return (spl_vm_val_t)(uintptr_t)vm;
|
|
}
|
|
|
|
/* 配置入口：vm_set_foreign(vm, handler, ctx)。handler=0：把未解析 native 重入
|
|
* 当前调用者(_vm)，ctx 透传前置。名与语义由配置层定义；VM 库不认识 foreign handler。 */
|
|
static spl_vm_val_t sc_vm_set_foreign(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
spl_vm_t *vm;
|
|
spl_foreign_t *f;
|
|
CHECK_NARGS("vm_set_foreign", 3);
|
|
vm = (spl_vm_t *)(uintptr_t)args[0];
|
|
if (!vm || !_vm)
|
|
return -1;
|
|
if (args[1] != 0) /* 仅注册 handler 0（重入调用者） */
|
|
return -1;
|
|
if (vm->foreign == spl_foreign_reenter && vm->foreign_ctx)
|
|
free(vm->foreign_ctx);
|
|
f = (spl_foreign_t *)malloc(sizeof(*f));
|
|
if (!f)
|
|
return -1;
|
|
f->caller = _vm;
|
|
f->ctx = (void *)(uintptr_t)args[2];
|
|
spl_vm_set_foreign(vm, spl_foreign_reenter, f);
|
|
return 0;
|
|
}
|
|
|
|
static spl_vm_val_t vm_drop(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)_vm;
|
|
CHECK_NARGS("vm_drop", 1);
|
|
spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
|
|
if (!vm)
|
|
return 0;
|
|
if (vm->foreign == spl_foreign_reenter && vm->foreign_ctx)
|
|
free(vm->foreign_ctx);
|
|
if (vm->prog) {
|
|
spl_prog_drop(vm->prog);
|
|
free(vm->prog);
|
|
vm->prog = NULL;
|
|
}
|
|
spl_vm_drop(vm);
|
|
free(vm);
|
|
return 0;
|
|
}
|
|
|
|
static spl_vm_val_t vm_load(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_load", 2);
|
|
spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
|
|
const char *path = (const char *)VM_X(_vm, args[1]);
|
|
if (!vm || !path)
|
|
return -1;
|
|
|
|
spl_prog_t *prog = (spl_prog_t *)malloc(sizeof(spl_prog_t));
|
|
if (!prog)
|
|
return -1;
|
|
if (spl_prog_load_from_file(path, prog) != 0) {
|
|
free(prog);
|
|
return -1;
|
|
}
|
|
spl_syscall_register(prog);
|
|
if (spl_vm_load_prog(vm, prog) != 0) {
|
|
spl_prog_drop(prog);
|
|
free(prog);
|
|
return -1;
|
|
}
|
|
return (spl_vm_val_t)(uintptr_t)prog;
|
|
}
|
|
|
|
static spl_vm_val_t vm_load_from_buffer(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_load_from_buffer", 3);
|
|
spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
|
|
const char *buf = (const char *)VM_XN(_vm, args[1], (usize)args[2]);
|
|
usize len = (usize)args[2];
|
|
spl_prog_t *prog;
|
|
if (!vm || !buf)
|
|
return -1;
|
|
prog = (spl_prog_t *)malloc(sizeof(spl_prog_t));
|
|
if (!prog)
|
|
return -1;
|
|
if (spl_prog_load_from_buffer(buf, len, prog) != 0) {
|
|
free(prog);
|
|
return -1;
|
|
}
|
|
/* 不自动注入任何 native/syscall：解析策略由使用者配置。 */
|
|
if (spl_vm_load_prog(vm, prog) != 0) {
|
|
spl_prog_drop(prog);
|
|
free(prog);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static spl_vm_val_t vm_push(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)_vm;
|
|
CHECK_NARGS("vm_push", 2);
|
|
spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
|
|
spl_vm_val_t val = args[1];
|
|
if (!vm)
|
|
return -1;
|
|
if (vm->sp >= vm->config.max_stack_depth) {
|
|
fprintf(stderr, "vm_push: stack overflow\n");
|
|
return -1;
|
|
}
|
|
vm->stacks.data[vm->sp++] = val;
|
|
return 0;
|
|
}
|
|
|
|
static spl_vm_val_t vm_call(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
CHECK_NARGS("vm_call", 3);
|
|
spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
|
|
const char *name = (const char *)VM_X(_vm, args[1]);
|
|
spl_vm_val_t call_nargs = args[2];
|
|
if (!vm || !name)
|
|
return -1;
|
|
|
|
if (spl_vm_call_entry(vm, name, (int)call_nargs) != 0) {
|
|
fprintf(stderr, "vm_call: function '%s' not found or bad ABI\n", name);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static spl_vm_val_t vm_run(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)_vm;
|
|
CHECK_NARGS("vm_run", 1);
|
|
spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
|
|
if (!vm)
|
|
return -1;
|
|
spl_vm_run_until(vm, 0);
|
|
return (spl_vm_val_t)vm->ret_val;
|
|
}
|
|
|
|
/* ---- 栈 / 结果 / 内存 访问（不暴露宿主指针） ---- */
|
|
|
|
static spl_vm_val_t sc_vm_ret_val(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)_vm;
|
|
CHECK_NARGS("vm_ret_val", 1);
|
|
return spl_vm_ret_val((spl_vm_t *)(uintptr_t)args[0]);
|
|
}
|
|
|
|
static spl_vm_val_t sc_vm_sp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)_vm;
|
|
CHECK_NARGS("vm_sp", 1);
|
|
return (spl_vm_val_t)spl_vm_sp((spl_vm_t *)(uintptr_t)args[0]);
|
|
}
|
|
|
|
static spl_vm_val_t sc_vm_fp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)_vm;
|
|
CHECK_NARGS("vm_fp", 1);
|
|
return (spl_vm_val_t)spl_vm_fp((spl_vm_t *)(uintptr_t)args[0]);
|
|
}
|
|
|
|
static spl_vm_val_t sc_vm_stack_get(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)_vm;
|
|
CHECK_NARGS("vm_stack_get", 2);
|
|
return spl_vm_stack_get((spl_vm_t *)(uintptr_t)args[0], (usize)args[1]);
|
|
}
|
|
|
|
static spl_vm_val_t sc_vm_stack_set(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)_vm;
|
|
CHECK_NARGS("vm_stack_set", 3);
|
|
return (spl_vm_val_t)spl_vm_stack_set((spl_vm_t *)(uintptr_t)args[0], (usize)args[1], args[2]);
|
|
}
|
|
|
|
static spl_vm_val_t sc_vm_mem_alloc(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
(void)_vm;
|
|
CHECK_NARGS("vm_mem_alloc", 2);
|
|
return spl_vm_mem_alloc((spl_vm_t *)(uintptr_t)args[0], (usize)args[1]);
|
|
}
|
|
|
|
static spl_vm_val_t sc_vm_mem_read(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
spl_vm_t *vm;
|
|
void *dst;
|
|
usize n;
|
|
CHECK_NARGS("vm_mem_read", 4);
|
|
vm = (spl_vm_t *)(uintptr_t)args[0];
|
|
n = (usize)args[3];
|
|
dst = VM_XN(_vm, args[2], n);
|
|
if ((!dst) && n)
|
|
return -1;
|
|
return (spl_vm_val_t)spl_vm_mem_read(vm, (spl_vm_val_t)args[1], dst, n);
|
|
}
|
|
|
|
static spl_vm_val_t sc_vm_mem_write(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
|
|
spl_vm_t *vm;
|
|
void *src;
|
|
usize n;
|
|
CHECK_NARGS("vm_mem_write", 4);
|
|
vm = (spl_vm_t *)(uintptr_t)args[0];
|
|
n = (usize)args[3];
|
|
src = VM_XN(_vm, args[2], n);
|
|
if ((!src) && n)
|
|
return -1;
|
|
return (spl_vm_val_t)spl_vm_mem_write(vm, (spl_vm_val_t)args[1], src, n);
|
|
}
|
|
|
|
/* =================================================================
|
|
* Registration
|
|
* ================================================================= */
|
|
|
|
void spl_syscall_register(spl_prog_t *prog) {
|
|
static spl_vm_native_t table[] = {
|
|
{"vm_exit", 0, vm_exit},
|
|
{"vm_putchar", 0, vm_putchar},
|
|
{"vm_getchar", 0, vm_getchar},
|
|
{"vm_putint", 0, vm_putint},
|
|
{"vm_putstr", 0, vm_putstr},
|
|
{"vm_fopen", 0, vm_fopen},
|
|
{"vm_fclose", 0, vm_fclose},
|
|
{"vm_fread", 0, vm_fread},
|
|
{"vm_fwrite", 0, vm_fwrite},
|
|
{"vm_fsize", 0, vm_fsize},
|
|
{"vm_stdin", 0, vm_stdin},
|
|
{"vm_stdout", 0, vm_stdout},
|
|
{"vm_stderr", 0, vm_stderr},
|
|
{"vm_read_file", 0, vm_read_file},
|
|
|
|
{"vm_alloc", 0, spl_sys_vm_alloc},
|
|
{"vm_free", 0, spl_sys_vm_free},
|
|
{"vm_realloc", 0, spl_sys_vm_realloc},
|
|
{"vm_memcpy", 0, spl_sys_vm_memcpy},
|
|
{"vm_memmove", 0, spl_sys_vm_memmove},
|
|
{"vm_memcmp", 0, spl_sys_vm_memcmp},
|
|
{"vm_printf", 0, vm_printf},
|
|
|
|
{"vm_vec_valid", 0, spl_sys_vm_vec_valid},
|
|
{"vm_vec_push_raw", 0, spl_sys_vm_vec_push_raw},
|
|
{"vm_vec_push", 0, spl_sys_vm_vec_push},
|
|
{"vm_vec_get", 0, spl_sys_vm_vec_get},
|
|
{"vm_vec_allocate", 0, spl_sys_vm_vec_allocate},
|
|
{"vm_vec_reserve_raw", 0, spl_sys_vm_vec_reserve_raw},
|
|
{"vm_vec_append", 0, spl_sys_vm_vec_append},
|
|
{"vm_vec_set", 0, spl_sys_vm_vec_set},
|
|
{"vm_vec_pop", 0, spl_sys_vm_vec_pop},
|
|
{"vm_vec_clone", 0, spl_sys_vm_vec_clone},
|
|
{"vm_vec_drop", 0, spl_sys_vm_vec_drop},
|
|
{"vm_bytes_eq", 0, spl_sys_vm_bytes_eq},
|
|
|
|
{"vm_map_valid", 0, spl_sys_vm_map_valid},
|
|
{"vm_map_reserve", 0, spl_sys_vm_map_reserve},
|
|
{"vm_map_put", 0, spl_sys_vm_map_put},
|
|
{"vm_map_get", 0, spl_sys_vm_map_get},
|
|
{"vm_map_del", 0, spl_sys_vm_map_del},
|
|
{"vm_map_clear", 0, spl_sys_vm_map_clear},
|
|
{"vm_map_drop", 0, spl_sys_vm_map_drop},
|
|
|
|
{"vm_timestamp", 0, vm_timestamp},
|
|
|
|
{"vm_new", 0, vm_new},
|
|
{"vm_set_foreign", 0, sc_vm_set_foreign},
|
|
{"vm_drop", 0, vm_drop},
|
|
{"vm_load", 0, vm_load},
|
|
{"vm_load_from_buffer", 0, vm_load_from_buffer},
|
|
{"vm_push", 0, vm_push},
|
|
{"vm_call", 0, vm_call},
|
|
{"vm_run", 0, vm_run},
|
|
|
|
{"vm_ret_val", 0, sc_vm_ret_val},
|
|
{"vm_sp", 0, sc_vm_sp},
|
|
{"vm_fp", 0, sc_vm_fp},
|
|
{"vm_stack_get", 0, sc_vm_stack_get},
|
|
{"vm_stack_set", 0, sc_vm_stack_set},
|
|
{"vm_mem_alloc", 0, sc_vm_mem_alloc},
|
|
{"vm_mem_read", 0, sc_vm_mem_read},
|
|
{"vm_mem_write", 0, sc_vm_mem_write},
|
|
};
|
|
int n = (int)(sizeof(table) / sizeof(table[0]));
|
|
if (!prog)
|
|
return;
|
|
vec_for(prog->natives, i) {
|
|
spl_vm_native_t *nat = &vec_at(prog->natives, i);
|
|
if (!nat->name || nat->impl_fn)
|
|
continue;
|
|
for (int j = 0; j < n; j++) {
|
|
if (strcmp(nat->name, table[j].name) == 0) {
|
|
nat->impl_fn = table[j].impl_fn;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|