creeperlv/Sagittarius
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented using Antigravity and it actually works!

Browse Source
This commit is contained in:
Creeper Lv
2026-05-25 15:21:34 +10:00
parent 2365e0a329
commit bcff8b3859
7 changed files with 1858 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/VM/SagittariusInternal.c
+604
View File
@@ -0,0 +1,604 @@
#include "../../Headers/SagittariusInternal.h"
#include "../../Headers/SagittariusPanic.h"
#include <stdbool.h>
#include <string.h>
#include <math.h>
/* Safe register read/write helpers */
static inline void reg_read(SagittariusCore *core, uint8_t reg_idx, void *dest, sagittarius_type t) {
size_t sz = 0;
switch (t) {
case st_uint8: case st_int8: sz = 1; break;
case st_uint16: case st_int16: sz = 2; break;
case st_uint32: case st_int32: case st_single: sz = 4; break;
case st_uint64: case st_int64: case st_double: sz = 8; break;
}
memcpy(dest, &core->reg.head[reg_idx], sz);
}
static inline void reg_write(SagittariusCore *core, uint8_t reg_idx, const void *src, sagittarius_type t) {
size_t sz = 0;
switch (t) {
case st_uint8: case st_int8: sz = 1; break;
case st_uint16: case st_int16: sz = 2; break;
case st_uint32: case st_int32: case st_single: sz = 4; break;
case st_uint64: case st_int64: case st_double: sz = 8; break;
}
memcpy(&core->reg.head[reg_idx], src, sz);
}
/* Macro for math2 (add, sub, mul) */
#define MATH2_OP_IMPL(name, op) \
internal bool SagMath2##name(SagittariusCore *core, sagittarius_type t, uint8_t L, uint8_t R, uint8_t T) { \
switch (t) { \
case st_uint8: { uint8_t l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = l op r; reg_write(core, T, &res, t); break; } \
case st_uint16: { uint16_t l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = l op r; reg_write(core, T, &res, t); break; } \
case st_uint32: { uint32_t l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = l op r; reg_write(core, T, &res, t); break; } \
case st_uint64: { uint64_t l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = l op r; reg_write(core, T, &res, t); break; } \
case st_int8: { int8_t l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = l op r; reg_write(core, T, &res, t); break; } \
case st_int16: { int16_t l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = l op r; reg_write(core, T, &res, t); break; } \
case st_int32: { int32_t l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = l op r; reg_write(core, T, &res, t); break; } \
case st_int64: { int64_t l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = l op r; reg_write(core, T, &res, t); break; } \
case st_single: { float l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = l op r; reg_write(core, T, &res, t); break; } \
case st_double: { double l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = l op r; reg_write(core, T, &res, t); break; } \
default: return false; \
} \
return true; \
}
MATH2_OP_IMPL(Add, +)
MATH2_OP_IMPL(Sub, -)
MATH2_OP_IMPL(Mul, *)
#define DIV_CASE(st_type, c_type) \
case st_type: { \
c_type l, r, res; \
reg_read(core, L, &l, t); \
reg_read(core, R, &r, t); \
if (r == 0) { \
if (core->vm->panic_handler) core->vm->panic_handler(core, Sagittarius_Msg_Generic, "Division by zero"); \
return false; \
} \
res = l / r; \
reg_write(core, T, &res, t); \
break; \
}
#define DIV_FLOAT_CASE(st_type, c_type) \
case st_type: { \
c_type l, r, res; \
reg_read(core, L, &l, t); \
reg_read(core, R, &r, t); \
res = l / r; \
reg_write(core, T, &res, t); \
break; \
}
internal bool SagMath2Div(SagittariusCore *core, sagittarius_type t, uint8_t L, uint8_t R, uint8_t T) {
switch (t) {
DIV_CASE(st_uint8, uint8_t)
DIV_CASE(st_uint16, uint16_t)
DIV_CASE(st_uint32, uint32_t)
DIV_CASE(st_uint64, uint64_t)
DIV_CASE(st_int8, int8_t)
DIV_CASE(st_int16, int16_t)
DIV_CASE(st_int32, int32_t)
DIV_CASE(st_int64, int64_t)
DIV_FLOAT_CASE(st_single, float)
DIV_FLOAT_CASE(st_double, double)
default: return false;
}
return true;
}
#define MOD_CASE(st_type, c_type) \
case st_type: { \
c_type l, r, res; \
reg_read(core, L, &l, t); \
reg_read(core, R, &r, t); \
if (r == 0) { \
if (core->vm->panic_handler) core->vm->panic_handler(core, Sagittarius_Msg_Generic, "Modulo by zero"); \
return false; \
} \
res = l % r; \
reg_write(core, T, &res, t); \
break; \
}
internal bool SagMath2Mod(SagittariusCore *core, sagittarius_type t, uint8_t L, uint8_t R, uint8_t T) {
switch (t) {
MOD_CASE(st_uint8, uint8_t)
MOD_CASE(st_uint16, uint16_t)
MOD_CASE(st_uint32, uint32_t)
MOD_CASE(st_uint64, uint64_t)
MOD_CASE(st_int8, int8_t)
MOD_CASE(st_int16, int16_t)
MOD_CASE(st_int32, int32_t)
MOD_CASE(st_int64, int64_t)
case st_single: { float l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = fmodf(l, r); reg_write(core, T, &res, t); break; }
case st_double: { double l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = fmod(l, r); reg_write(core, T, &res, t); break; }
default: return false;
}
return true;
}
#define POW_CASE(st_type, c_type) \
case st_type: { \
c_type l, r, res; \
reg_read(core, L, &l, t); \
reg_read(core, R, &r, t); \
res = (c_type)pow((double)l, (double)r); \
reg_write(core, T, &res, t); \
break; \
}
internal bool SagMath2Pow(SagittariusCore *core, sagittarius_type t, uint8_t L, uint8_t R, uint8_t T) {
switch (t) {
POW_CASE(st_uint8, uint8_t)
POW_CASE(st_uint16, uint16_t)
POW_CASE(st_uint32, uint32_t)
POW_CASE(st_uint64, uint64_t)
POW_CASE(st_int8, int8_t)
POW_CASE(st_int16, int16_t)
POW_CASE(st_int32, int32_t)
POW_CASE(st_int64, int64_t)
case st_single: { float l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = powf(l, r); reg_write(core, T, &res, t); break; }
case st_double: { double l, r, res; reg_read(core, L, &l, t); reg_read(core, R, &r, t); res = pow(l, r); reg_write(core, T, &res, t); break; }
default: return false;
}
return true;
}
internal bool Math2Op(SagittariusCore *core, SagittariusInst inst) {
uint8_t t = (inst.data >> 8) & 0xFF;
uint8_t op = (inst.data >> 16) & 0xFF;
uint8_t L = (inst.data >> 24) & 0xFF;
uint8_t R = (inst.data >> 32) & 0xFF;
uint8_t T = (inst.data >> 40) & 0xFF;
bool status = false;
switch (op) {
case sag_math2_add: status = SagMath2Add(core, (sagittarius_type)t, L, R, T); break;
case sag_math2_sub: status = SagMath2Sub(core, (sagittarius_type)t, L, R, T); break;
case sag_math2_mul: status = SagMath2Mul(core, (sagittarius_type)t, L, R, T); break;
case sag_math2_div: status = SagMath2Div(core, (sagittarius_type)t, L, R, T); break;
case sag_math2_mod: status = SagMath2Mod(core, (sagittarius_type)t, L, R, T); break;
case sag_math2_pow: status = SagMath2Pow(core, (sagittarius_type)t, L, R, T); break;
default: return false;
}
if (status) {
core->pc += 8;
}
return status;
}
/* Math1 unary operators helper */
static inline double my_abs(double v) { return v < 0 ? -v : v; }
static inline float my_absf(float v) { return v < 0 ? -v : v; }
#define MATH1_OP_IMPL(name, func, float_func) \
internal bool SagMath1##name(SagittariusCore *core, sagittarius_type t, uint8_t L, uint8_t T) { \
switch (t) { \
case st_uint8: { uint8_t l, res; reg_read(core, L, &l, t); res = (uint8_t)func((double)l); reg_write(core, T, &res, t); break; } \
case st_uint16: { uint16_t l, res; reg_read(core, L, &l, t); res = (uint16_t)func((double)l); reg_write(core, T, &res, t); break; } \
case st_uint32: { uint32_t l, res; reg_read(core, L, &l, t); res = (uint32_t)func((double)l); reg_write(core, T, &res, t); break; } \
case st_uint64: { uint64_t l, res; reg_read(core, L, &l, t); res = (uint64_t)func((double)l); reg_write(core, T, &res, t); break; } \
case st_int8: { int8_t l, res; reg_read(core, L, &l, t); res = (int8_t)func((double)l); reg_write(core, T, &res, t); break; } \
case st_int16: { int16_t l, res; reg_read(core, L, &l, t); res = (int16_t)func((double)l); reg_write(core, T, &res, t); break; } \
case st_int32: { int32_t l, res; reg_read(core, L, &l, t); res = (int32_t)func((double)l); reg_write(core, T, &res, t); break; } \
case st_int64: { int64_t l, res; reg_read(core, L, &l, t); res = (int64_t)func((double)l); reg_write(core, T, &res, t); break; } \
case st_single: { float l, res; reg_read(core, L, &l, t); res = float_func(l); reg_write(core, T, &res, t); break; } \
case st_double: { double l, res; reg_read(core, L, &l, t); res = func(l); reg_write(core, T, &res, t); break; } \
default: return false; \
} \
return true; \
}
MATH1_OP_IMPL(Sin, sin, sinf)
MATH1_OP_IMPL(Cos, cos, cosf)
MATH1_OP_IMPL(Tan, tan, tanf)
MATH1_OP_IMPL(Sinh, sinh, sinhf)
MATH1_OP_IMPL(Cosh, cosh, coshf)
MATH1_OP_IMPL(Tanh, tanh, tanhf)
MATH1_OP_IMPL(Asin, asin, asinf)
MATH1_OP_IMPL(Acos, acos, acosf)
MATH1_OP_IMPL(Atan, atan, atanf)
MATH1_OP_IMPL(Abs, my_abs, my_absf)
MATH1_OP_IMPL(Exp, exp, expf)
internal bool Math1Op(SagittariusCore *core, SagittariusInst inst) {
uint8_t t = (inst.data >> 8) & 0xFF;
uint8_t op = (inst.data >> 16) & 0xFF;
uint8_t L = (inst.data >> 24) & 0xFF;
uint8_t T = (inst.data >> 32) & 0xFF;
bool status = false;
switch (op) {
case sag_math1_sin: status = SagMath1Sin(core, (sagittarius_type)t, L, T); break;
case sag_math1_cos: status = SagMath1Cos(core, (sagittarius_type)t, L, T); break;
case sag_math1_tan: status = SagMath1Tan(core, (sagittarius_type)t, L, T); break;
case sag_math1_sinh: status = SagMath1Sinh(core, (sagittarius_type)t, L, T); break;
case sag_math1_cosh: status = SagMath1Cosh(core, (sagittarius_type)t, L, T); break;
case sag_math1_tanh: status = SagMath1Tanh(core, (sagittarius_type)t, L, T); break;
case sag_math1_asin: status = SagMath1Asin(core, (sagittarius_type)t, L, T); break;
case sag_math1_acos: status = SagMath1Acos(core, (sagittarius_type)t, L, T); break;
case sag_math1_atan: status = SagMath1Atan(core, (sagittarius_type)t, L, T); break;
case sag_math1_abs: status = SagMath1Abs(core, (sagittarius_type)t, L, T); break;
case sag_math1_exp: status = SagMath1Exp(core, (sagittarius_type)t, L, T); break;
default: return false;
}
if (status) {
core->pc += 8;
}
return status;
}
/* CVT (Conversion) */
#define CVT_CASE_SRC(src_c_type, src_t) \
case src_t: { \
src_c_type val; \
reg_read(core, src_reg, &val, src_t); \
switch (dst_type) { \
case st_uint8: { uint8_t r = (uint8_t)val; reg_write(core, dst_reg, &r, dst_type); break; } \
case st_uint16: { uint16_t r = (uint16_t)val; reg_write(core, dst_reg, &r, dst_type); break; } \
case st_uint32: { uint32_t r = (uint32_t)val; reg_write(core, dst_reg, &r, dst_type); break; } \
case st_uint64: { uint64_t r = (uint64_t)val; reg_write(core, dst_reg, &r, dst_type); break; } \
case st_int8: { int8_t r = (int8_t)val; reg_write(core, dst_reg, &r, dst_type); break; } \
case st_int16: { int16_t r = (int16_t)val; reg_write(core, dst_reg, &r, dst_type); break; } \
case st_int32: { int32_t r = (int32_t)val; reg_write(core, dst_reg, &r, dst_type); break; } \
case st_int64: { int64_t r = (int64_t)val; reg_write(core, dst_reg, &r, dst_type); break; } \
case st_single: { float r = (float)val; reg_write(core, dst_reg, &r, dst_type); break; } \
case st_double: { double r = (double)val; reg_write(core, dst_reg, &r, dst_type); break; } \
} \
break; \
}
internal bool SagCvt(SagittariusCore *core, SagittariusInst inst) {
uint8_t src_reg = (inst.data >> 8) & 0xFF;
uint8_t src_type = (inst.data >> 16) & 0xFF;
uint8_t dst_reg = (inst.data >> 24) & 0xFF;
uint8_t dst_type = (inst.data >> 32) & 0xFF;
switch ((sagittarius_type)src_type) {
CVT_CASE_SRC(uint8_t, st_uint8)
CVT_CASE_SRC(uint16_t, st_uint16)
CVT_CASE_SRC(uint32_t, st_uint32)
CVT_CASE_SRC(uint64_t, st_uint64)
CVT_CASE_SRC(int8_t, st_int8)
CVT_CASE_SRC(int16_t, st_int16)
CVT_CASE_SRC(int32_t, st_int32)
CVT_CASE_SRC(int64_t, st_int64)
CVT_CASE_SRC(float, st_single)
CVT_CASE_SRC(double, st_double)
default: return false;
}
core->pc += 8;
return true;
}
/* Set, Mv, Cp, Save, Load */
internal bool SagSet(SagittariusCore *core, SagittariusInst inst) {
uint8_t length = (inst.data >> 8) & 0xFF;
uint8_t reg_idx = (inst.data >> 16) & 0xFF;
if (core->pc + 15 >= core->memory->size) {
if (core->vm->panic_handler) core->vm->panic_handler(core, Sagittarius_Msg_OOB, "Set payload out of bounds");
return false;
}
uint64_t payload = 0;
memcpy(&payload, &core->memory->data[core->pc + 8], 8);
if (length > 8) length = 8;
memcpy(&core->reg.head[reg_idx], &payload, length);
core->pc += 16;
return true;
}
internal bool SagMv(SagittariusCore *core, SagittariusInst inst) {
uint8_t length = (inst.data >> 8) & 0xFF;
uint8_t src_reg = (inst.data >> 16) & 0xFF;
uint8_t dst_reg = (inst.data >> 24) & 0xFF;
if (length > 8) length = 8;
memmove(&core->reg.head[dst_reg], &core->reg.head[src_reg], length);
core->pc += 8;
return true;
}
internal bool SagCp(SagittariusCore *core, SagittariusInst inst) {
uint8_t length = (inst.data >> 8) & 0xFF;
uint8_t src_reg = (inst.data >> 16) & 0xFF;
uint8_t dst_reg = (inst.data >> 24) & 0xFF;
if (length > 8) length = 8;
memcpy(&core->reg.head[dst_reg], &core->reg.head[src_reg], length);
core->pc += 8;
return true;
}
internal bool SagSave(SagittariusCore *core, SagittariusInst inst) {
uint8_t length = (inst.data >> 8) & 0xFF;
uint8_t src_reg = (inst.data >> 16) & 0xFF;
uint8_t dest_mem_ptr_reg = (inst.data >> 24) & 0xFF;
uint64_t mem_addr = 0;
memcpy(&mem_addr, &core->reg.head[dest_mem_ptr_reg], 8);
if (mem_addr + length > core->memory->size) {
if (core->vm->panic_handler) core->vm->panic_handler(core, Sagittarius_Msg_OOB, "Memory write out of bounds");
return false;
}
if (length > 8) length = 8;
memcpy(&core->memory->data[mem_addr], &core->reg.head[src_reg], length);
core->pc += 8;
return true;
}
internal bool SagLoad(SagittariusCore *core, SagittariusInst inst) {
uint8_t length = (inst.data >> 8) & 0xFF;
uint8_t dest_reg = (inst.data >> 16) & 0xFF;
uint8_t src_mem_ptr_reg = (inst.data >> 24) & 0xFF;
uint64_t mem_addr = 0;
memcpy(&mem_addr, &core->reg.head[src_mem_ptr_reg], 8);
if (mem_addr + length > core->memory->size) {
if (core->vm->panic_handler) core->vm->panic_handler(core, Sagittarius_Msg_OOB, "Memory read out of bounds");
return false;
}
if (length > 8) length = 8;
memcpy(&core->reg.head[dest_reg], &core->memory->data[mem_addr], length);
core->pc += 8;
return true;
}
/* Control flow: Jmp, JmpIf, Call, Ret */
internal bool SagJmp(SagittariusCore *core, SagittariusInst inst) {
uint8_t mode = (inst.data >> 8) & 0xFF; // 0 = absolute, 1 = relative
uint8_t val_mode = (inst.data >> 16) & 0xFF; // 0 = register, 1 = immediate
uint64_t target_val = 0;
if (val_mode == 0) {
uint8_t reg_idx = (inst.data >> 24) & 0xFF;
memcpy(&target_val, &core->reg.head[reg_idx], 8);
} else {
int32_t imm;
memcpy(&imm, &((uint8_t*)&inst.data)[3], 4);
target_val = (int64_t)imm; // Sign extended
}
if (mode == 0) {
core->pc = target_val;
} else {
core->pc += target_val;
}
return true;
}
internal bool SagJmpIf(SagittariusCore *core, SagittariusInst inst) {
uint8_t mode = (inst.data >> 8) & 0xFF;
uint8_t val_mode = (inst.data >> 16) & 0xFF;
uint8_t flag_reg = (inst.data >> 24) & 0xFF;
uint8_t flag = 0;
memcpy(&flag, &core->reg.head[flag_reg], 1);
if (flag != 0) {
uint64_t target_val = 0;
if (val_mode == 0) {
uint8_t reg_idx = (inst.data >> 32) & 0xFF;
memcpy(&target_val, &core->reg.head[reg_idx], 8);
} else {
int32_t imm;
memcpy(&imm, &((uint8_t*)&inst.data)[4], 4);
target_val = (int64_t)imm; // Sign extended
}
if (mode == 0) {
core->pc = target_val;
} else {
core->pc += target_val;
}
} else {
core->pc += 8;
}
return true;
}
internal bool SagCall(SagittariusCore *core, SagittariusInst inst) {
uint8_t mode = (inst.data >> 8) & 0xFF;
uint8_t val_mode = (inst.data >> 16) & 0xFF;
uint8_t reg_to_rem = (inst.data >> 24) & 0xFF;
if (val_mode == 0) {
uint8_t reg_idx = (inst.data >> 32) & 0xFF;
uint64_t target_pc = 0;
memcpy(&target_pc, &core->reg.head[reg_idx], 8);
uint64_t ret_pc = core->pc + 8;
memcpy(&core->reg.head[reg_to_rem], &ret_pc, 8);
if (mode == 0) {
core->pc = target_pc;
} else {
core->pc += target_pc;
}
} else {
if (core->pc + 15 >= core->memory->size) {
if (core->vm->panic_handler) core->vm->panic_handler(core, Sagittarius_Msg_OOB, "Call payload out of bounds");
return false;
}
uint64_t target_pc = 0;
memcpy(&target_pc, &core->memory->data[core->pc + 8], 8);
uint64_t ret_pc = core->pc + 16;
memcpy(&core->reg.head[reg_to_rem], &ret_pc, 8);
if (mode == 0) {
core->pc = target_pc;
} else {
core->pc += target_pc;
}
}
return true;
}
internal bool SagRet(SagittariusCore *core, SagittariusInst inst) {
uint8_t reg_to_restore = (inst.data >> 8) & 0xFF;
uint64_t target_pc = 0;
memcpy(&target_pc, &core->reg.head[reg_to_restore], 8);
core->pc = target_pc;
return true;
}
/* Compare */
#define CMP_CASE(st_type, c_type, sz) \
case st_type: { \
c_type l, r; \
reg_read(core, L, &l, (sagittarius_type)t); \
reg_read(core, R, &r, (sagittarius_type)t); \
switch (op) { \
case 0: res = (l == r); break; \
case 1: res = (l != r); break; \
case 2: res = (l < r); break; \
case 3: res = (l <= r); break; \
case 4: res = (l > r); break; \
case 5: res = (l >= r); break; \
default: res = 0; break; \
} \
break; \
}
internal bool SagCmp(SagittariusCore *core, SagittariusInst inst) {
uint8_t t = (inst.data >> 8) & 0xFF;
uint8_t op = (inst.data >> 16) & 0xFF;
uint8_t L = (inst.data >> 24) & 0xFF;
uint8_t R = (inst.data >> 32) & 0xFF;
uint8_t T = (inst.data >> 40) & 0xFF;
uint8_t res = 0;
switch ((sagittarius_type)t) {
CMP_CASE(st_uint8, uint8_t, 1)
CMP_CASE(st_uint16, uint16_t, 2)
CMP_CASE(st_uint32, uint32_t, 4)
CMP_CASE(st_uint64, uint64_t, 8)
CMP_CASE(st_int8, int8_t, 1)
CMP_CASE(st_int16, int16_t, 2)
CMP_CASE(st_int32, int32_t, 4)
CMP_CASE(st_int64, int64_t, 8)
CMP_CASE(st_single, float, 4)
CMP_CASE(st_double, double, 8)
default: return false;
}
memcpy(&core->reg.head[T], &res, 1);
core->pc += 8;
return true;
}
/* MathV (Vector Math) */
internal bool SagMathV(SagittariusCore *core, SagittariusInst inst) {
uint8_t w = (inst.data >> 8) & 0xFF;
uint8_t h = (inst.data >> 16) & 0xFF;
uint8_t op = (inst.data >> 24) & 0xFF;
uint8_t L_ptr_reg = (inst.data >> 32) & 0xFF;
uint8_t R_ptr_reg = (inst.data >> 40) & 0xFF;
uint8_t Dest_ptr_reg = (inst.data >> 48) & 0xFF;
uint64_t l_addr = 0, r_addr = 0, d_addr = 0;
memcpy(&l_addr, &core->reg.head[L_ptr_reg], 8);
memcpy(&r_addr, &core->reg.head[R_ptr_reg], 8);
memcpy(&d_addr, &core->reg.head[Dest_ptr_reg], 8);
uint64_t size_in_bytes = (uint64_t)w * h * 8;
if (l_addr + size_in_bytes > core->memory->size ||
r_addr + size_in_bytes > core->memory->size ||
d_addr + size_in_bytes > core->memory->size) {
if (core->vm->panic_handler) core->vm->panic_handler(core, Sagittarius_Msg_OOB, "Vector math OOB access");
return false;
}
for (uint64_t i = 0; i < (uint64_t)w * h; ++i) {
double l_val = 0, r_val = 0, d_val = 0;
memcpy(&l_val, &core->memory->data[l_addr + i * 8], 8);
memcpy(&r_val, &core->memory->data[r_addr + i * 8], 8);
switch (op) {
case 0: d_val = l_val + r_val; break;
case 1: d_val = l_val - r_val; break;
case 2: d_val = l_val * r_val; break;
case 3: {
if (r_val == 0.0) {
if (core->vm->panic_handler) core->vm->panic_handler(core, Sagittarius_Msg_Generic, "Vector division by zero");
return false;
}
d_val = l_val / r_val;
break;
}
default: d_val = 0; break;
}
memcpy(&core->memory->data[d_addr + i * 8], &d_val, 8);
}
core->pc += 8;
return true;
}
/* Halt */
internal bool SagHalt(SagittariusCore *core, SagittariusInst inst) {
(void)core; (void)inst;
return true;
}
/* Syscall & TSyscall */
internal bool SagSyscall(SagittariusCore *core, SagittariusInst inst) {
uint8_t ns_reg = (inst.data >> 8) & 0xFF;
uint8_t func_reg = (inst.data >> 16) & 0xFF;
uint64_t ns = 0, func_id = 0;
memcpy(&ns, &core->reg.head[ns_reg], 8);
memcpy(&func_id, &core->reg.head[func_reg], 8);
uint64_t syscall_id = (ns << 32) | func_id;
bool found = false;
for (uint64_t i = 0; i < core->vm->SagittariusSyscallCount; ++i) {
if (core->vm->SagittariusSyscallEntries[i].id == syscall_id) {
core->vm->SagittariusSyscallEntries[i].syscall(core);
found = true;
break;
}
}
if (!found) {
if (core->vm->panic_handler) core->vm->panic_handler(core, Sagittarius_Msg_Unknown, "Unregistered syscall called");
return false;
}
core->pc += 8;
return true;
}
internal bool SagTSyscall(SagittariusCore *core, SagittariusInst inst) {
uint8_t ns_reg = (inst.data >> 8) & 0xFF;
uint8_t func_reg = (inst.data >> 16) & 0xFF;
uint8_t result_reg = (inst.data >> 24) & 0xFF;
uint64_t ns = 0, func_id = 0;
memcpy(&ns, &core->reg.head[ns_reg], 8);
memcpy(&func_id, &core->reg.head[func_reg], 8);
uint64_t syscall_id = (ns << 32) | func_id;
uint8_t result = 0;
for (uint64_t i = 0; i < core->vm->SagittariusSyscallCount; ++i) {
if (core->vm->SagittariusSyscallEntries[i].id == syscall_id) {
result = 1;
break;
}
}
memcpy(&core->reg.head[result_reg], &result, 1);
core->pc += 8;
return true;
}