zongor
/
undar-lang-old
1
0
Fork 0
Code
undar-lang-old/src/vm/vm.c

491 lines
14 KiB
C
Raw Blame History

#include "vm.h"
#include "device.h"
#include "opcodes.h"
#include "str.h"
#define COMPARE_AND_JUMP(type, op) \
do { \
i32 cond; \
u32 mask, target; \
u8 dest, src1, src2; \
type value; \
type value2; \
dest = read_u8(vm, code, vm->pc); \
vm->pc++; \
src1 = read_u8(vm, code, vm->pc); \
vm->pc++; \
src2 = read_u8(vm, code, vm->pc); \
vm->pc++; \
value = frame.registers[src1]; \
value2 = frame.registers[src2]; \
cond = !!(value op value2); \
mask = -(u32)cond; \
target = frame.registers[dest]; \
vm->pc = (target & mask) | (vm->pc & ~mask); \
return true; \
} while (0)
#define MATH_OP(type, op) \
do { \
dest = read_u8(vm, code, vm->pc); \
vm->pc++; \
src1 = read_u8(vm, code, vm->pc); \
vm->pc++; \
src2 = read_u8(vm, code, vm->pc); \
vm->pc++; \
frame.registers[dest] = \
(type)frame.registers[src1] op(type) frame.registers[src2]; \
return true; \
} while (0)
u32 str_alloc(VM *vm, Frame *frame, const char *str, u32 length) {
u32 str_addr = vm->mp;
u32 i = 0;
vm->mp += 4;
while (i < length) {
vm->memory[vm->mp++] = str[i++];
}
vm->memory[vm->mp++] = '\0';
write_u32(vm, memory, str_addr, length);
frame->end = vm->mp;
return str_addr;
}
/**
* Step to the next opcode in the vm.
*/
bool step_vm(VM *vm) {
u8 opcode, dest, src1, src2;
u32 v, ptr;
i32 value;
Frame frame;
/* Get current instruction & Advance to next instruction */
opcode = vm->code[vm->pc++];
frame = vm->frames[vm->fp];
switch (opcode) {
case OP_HALT: {
return false;
}
case OP_CALL: {
u32 jmp = read_u32(vm, code, vm->pc); /* location of function in code */
vm->pc += 4;
vm->return_stack[vm->rp++] = vm->pc; /* set return address */
vm->fp++; /* increment to the next free frame */
vm->frames[vm->fp].start = vm->mp; /* set start of new memory block */
vm->pc = jmp;
return true;
}
case OP_RETURN: {
frame.rp = 0; /* reset register ptr */
vm->pc = vm->return_stack[--vm->rp]; /* set pc to return address */
vm->mp =
vm->frames[vm->fp--].start; /* reset memory pointer to start
of old slice, pop the frame */
return true;
}
case OP_LOAD_IMM: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
v = read_u32(vm, code, vm->pc);
vm->pc += 4;
frame.registers[dest] = v;
return true;
}
case OP_LOAD: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
ptr = read_u32(vm, code, vm->pc);
vm->pc += 4;
v = read_u32(vm, memory, ptr);
frame.registers[dest] = v;
return true;
}
case OP_STORE: {
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
ptr = read_u32(vm, code, vm->pc);
vm->pc += 4;
v = frame.registers[src1];
write_u32(vm, memory, ptr, v);
return true;
}
case OP_PUSH: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
vm->stack[++vm->sp] = frame.registers[dest];
return true;
}
case OP_POP: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
frame.registers[dest] = vm->stack[vm->sp--];
return true;
}
case OP_REG_MOV: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
frame.registers[dest] = frame.registers[src1];
return true;
}
case OP_JMP: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
vm->pc = frame.registers[dest]; /* Jump to address */
return true;
}
case OP_JMPF: { /* error handling for syscall, jump if flag == 0 */
u32 mask;
dest = read_u8(vm, code, vm->pc);
vm->pc++;
mask = -(u32)(vm->flag == 0);
vm->pc = (dest & mask) | (vm->pc & ~mask);
return true;
}
case OP_SYSCALL: {
u32 syscall_id, arg_count;
u8 first_reg;
syscall_id = read_u32(vm, code, vm->pc);
vm->pc += 4;
arg_count = read_u8(vm, code, vm->pc);
vm->pc++;
first_reg = read_u8(vm, code, vm->pc);
vm->pc++;
switch (syscall_id) {
case SYSCALL_DEVICE_OPEN: {
if (arg_count >= 2) {
Device *dev;
u32 path_ptr, mode;
path_ptr = frame.registers[first_reg]; /* R0: path pointer */
mode = frame.registers[first_reg + 1]; /* R1: mode */
dev = find_device_by_path(vm, (const char *)&vm->memory[path_ptr + 4]);
if (dev) {
if (dev->ops->open) {
vm->flag = dev->ops->open(dev->data, mode);
} else {
vm->flag = 1; /* success, no open needed */
}
} else {
vm->flag = 0; /* error */
}
} else {
vm->flag = 0; /* error: not enough arguments */
}
return true;
}
case SYSCALL_DEVICE_READ: {
if (arg_count >= 3) {
Device *dev;
u32 path_ptr, buffer_ptr, size;
path_ptr = frame.registers[first_reg]; /* R0: path pointer */
buffer_ptr = frame.registers[first_reg + 1]; /* R1: buffer pointer */
size = frame.registers[first_reg + 2]; /* R2: size */
dev = find_device_by_path(vm, (const char *)&vm->memory[path_ptr + 4]);
if (dev && dev->ops->read) {
vm->flag =
dev->ops->read(dev->data, (u8 *)&vm->memory[buffer_ptr], size);
} else {
vm->flag = 0;
}
} else {
vm->flag = 0; /* error: not enough arguments */
}
return true;
}
case SYSCALL_DEVICE_WRITE: {
if (arg_count >= 3) {
Device *dev;
u32 path_ptr, buffer_ptr, size;
path_ptr = frame.registers[first_reg]; /* R0: path pointer */
buffer_ptr = frame.registers[first_reg + 1]; /* R1: buffer pointer */
size = frame.registers[first_reg + 2]; /* R2: size */
dev = find_device_by_path(vm, (const char *)&vm->memory[path_ptr + 4]);
if (dev && dev->ops->write) {
vm->flag = dev->ops->write(
dev->data, (const u8 *)&vm->memory[buffer_ptr + 4], size);
} else {
vm->flag = 0;
}
} else {
vm->flag = 0; /* error: not enough arguments */
}
return true;
}
case SYSCALL_DEVICE_CLOSE: {
if (arg_count >= 1) {
Device *dev;
u32 path_ptr;
path_ptr = frame.registers[first_reg]; /* R0: path pointer */
dev = find_device_by_path(vm, (const char *)&vm->memory[path_ptr + 4]);
if (dev && dev->ops->close) {
i32 result = dev->ops->close(dev->data);
vm->flag = result;
} else {
vm->flag = 0;
}
} else {
vm->flag = 0; /* error: not enough arguments */
}
return true;
}
case SYSCALL_DEVICE_IOCTL: {
if (arg_count >= 3) {
Device *dev;
u32 path_ptr, args_ptr, cmd;
path_ptr = frame.registers[first_reg]; /* R0: device path */
cmd = frame.registers[first_reg + 1]; /* R1: ioctl command */
args_ptr = frame.registers[first_reg + 2]; /* R2: args pointer */
dev = find_device_by_path(vm, (const char *)&vm->memory[path_ptr + 4]);
if (dev && dev->ops && dev->ops->ioctl) {
i32 result = dev->ops->ioctl(dev->data, cmd, &vm->memory[args_ptr]);
vm->flag = result;
} else {
vm->flag = 0; /* error or no ioctl support */
}
} else {
vm->flag = 0; /* error: not enough arguments */
}
return true;
}
case SYSCALL_EXIT: {
return false;
}
default: {
vm->flag = 0; /* unknown syscall */
return true;
}
}
return true;
}
case OP_ADD_INT:
MATH_OP(i32, +);
case OP_SUB_INT:
MATH_OP(i32, -);
case OP_MUL_INT:
MATH_OP(i32, *);
case OP_DIV_INT:
MATH_OP(i32, /);
case OP_ADD_UINT:
MATH_OP(u32, +);
case OP_SUB_UINT:
MATH_OP(u32, -);
case OP_MUL_UINT:
MATH_OP(u32, *);
case OP_DIV_UINT:
MATH_OP(u32, /);
case OP_MUL_REAL: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
src2 = read_u8(vm, code, vm->pc);
vm->pc++;
frame.registers[dest] =
(frame.registers[src1] * frame.registers[src2]) >> 16;
return true;
}
case OP_DIV_REAL: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
src2 = read_u8(vm, code, vm->pc);
vm->pc++;
frame.registers[dest] =
(frame.registers[src1] << 16) / frame.registers[src2];
return true;
}
case OP_ADD_REAL: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
src2 = read_u8(vm, code, vm->pc);
vm->pc++;
frame.registers[dest] = frame.registers[src1] + frame.registers[src2];
return true;
}
case OP_SUB_REAL: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
src2 = read_u8(vm, code, vm->pc);
vm->pc++;
frame.registers[dest] = frame.registers[src1] - frame.registers[src2];
return true;
}
case OP_REAL_TO_INT: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
value = frame.registers[src1];
if (value >= 0) {
frame.registers[dest] = value >> 16;
} else {
frame.registers[dest] = -((-value) >> 16);
}
return true;
}
case OP_INT_TO_REAL: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
frame.registers[dest] = (frame.registers[src1] << 16);
return true;
}
case OP_REAL_TO_UINT: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
value = frame.registers[src1];
if (value < 0) {
frame.registers[dest] = 0;
} else {
frame.registers[dest] = AS_UINT(value >> 16);
}
return true;
}
case OP_UINT_TO_REAL: {
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
frame.registers[dest] = AS_INT(frame.registers[src1] << 16);
return true;
}
case OP_JEQ_UINT: {
COMPARE_AND_JUMP(u32, ==);
}
case OP_JGT_UINT: {
COMPARE_AND_JUMP(u32, >);
}
case OP_JLT_UINT: {
COMPARE_AND_JUMP(u32, <);
}
case OP_JLE_UINT: {
COMPARE_AND_JUMP(u32, <=);
}
case OP_JGE_UINT: {
COMPARE_AND_JUMP(u32, >=);
}
case OP_JEQ_INT: {
COMPARE_AND_JUMP(i32, ==);
}
case OP_JGT_INT: {
COMPARE_AND_JUMP(i32, >);
}
case OP_JLT_INT: {
COMPARE_AND_JUMP(i32, <);
}
case OP_JLE_INT: {
COMPARE_AND_JUMP(i32, <=);
}
case OP_JGE_INT: {
COMPARE_AND_JUMP(i32, >=);
}
case OP_JEQ_REAL: {
COMPARE_AND_JUMP(i32, ==);
}
case OP_JGT_REAL: {
COMPARE_AND_JUMP(i32, >);
}
case OP_JLT_REAL: {
COMPARE_AND_JUMP(i32, <);
}
case OP_JGE_REAL: {
COMPARE_AND_JUMP(i32, >=);
}
case OP_JLE_REAL: {
COMPARE_AND_JUMP(i32, <=);
}
case OP_INT_TO_STRING: {
char buffer[32];
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
int_to_string(AS_INT(frame.registers[src1]), buffer);
ptr = str_alloc(vm, &frame, buffer, strlength(buffer));
frame.registers[dest] = ptr;
return true;
}
case OP_UINT_TO_STRING: {
char buffer[32];
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
uint_to_string(frame.registers[src1], buffer);
ptr = str_alloc(vm, &frame, buffer, strlength(buffer));
frame.registers[dest] = ptr;
return true;
}
case OP_REAL_TO_STRING: {
char buffer[32];
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
fixed_to_string(AS_INT(frame.registers[src1]), buffer);
ptr =
str_alloc(vm, &frame, buffer, strlength(buffer)); /* copy buffer to dest */
frame.registers[dest] = ptr;
return true;
}
case OP_STRLEN: {
u32 ptr, length;
dest = read_u8(vm, code, vm->pc);
vm->pc++;
src1 = read_u8(vm, code, vm->pc);
vm->pc++;
ptr = frame.registers[src1];
length = read_u32(vm, memory, ptr);
frame.registers[dest] = length;
return true;
}
case OP_STRING_TO_INT: {
/* not implemented yet */
return false;
}
case OP_STRING_TO_UINT: {
/* not implemented yet */
return false;
}
case OP_STRING_TO_REAL: {
/* not implemented yet */
return false;
}
}
return false; /* something bad happened */
}
View Git Blame Copy Permalink