Implement a stack-based bytecode virtual machine with an assembler in C11 in this direc…

antigravitygemini · 28 steps · 1m 01s · 9 filessession da5b2d5a-567@patrick-toulme

Implement a stack-based bytecode virtual machine with an assembler in C11 in this directory. Files: vm.c, vm.h (the VM: operand stack, call stack, ops PUSH, POP, DUP, SWAP, ADD, SUB, MUL, DIV, MOD, NEG, EQ, LT, GT, JMP, JZ, JNZ, CALL, RET, LOAD, STORE for 16 locals per frame, PRINT, HALT; robust error handling for stack under/overflow, division by zero, bad opcodes, out-of-range jumps), asm.c (a two-pass assembler from mnemonic text with labels and comments to bytecode), examples/ (fib.vasm computing fib(20) recursively, fact.vasm computing 10! iteratively, primes.vasm printing primes below 50), tests.c (runs each example through assembler+VM and asserts exact output; plus negative tests for each error path), Makefile (clang -std=c11 -Wall -Wextra -fsanitize=address). Build with make, run the tests under ASan, and fix failures until everything passes clean.

same matchclaude-code · 45 steps codex · 86 steps opencode · 46 steps pi · 59 steps antigravity · 28 steps

compare in arena

step 11 / 28

vm.cchange 1/1

#include "vm.h"
#include <string.h>
 
void vm_init(VM *vm, const uint8_t *code, size_t code_size, FILE *out) {
    if (!vm) return;
    vm->code = code;
    vm->code_size = code_size;
    vm->ip = 0;
    vm->sp = 0;
    vm->fp = 0;
    memset(vm->stack, 0, sizeof(vm->stack));
    memset(vm->call_stack, 0, sizeof(vm->call_stack));
    memset(vm->current_locals, 0, sizeof(vm->current_locals));
    vm->out = out ? out : stdout;
    vm->halted = false;
}
 
VMResult vm_step(VM *vm) {
    if (!vm) return VM_ERR_INVALID_OPCODE;
    if (vm->halted) return VM_OK;
    if (vm->ip >= vm->code_size) return VM_ERR_INVALID_JUMP;
 
    uint8_t op = vm->code[vm->ip++];
 
    switch (op) {
        case OP_HALT:
            vm->halted = true;
            return VM_OK;
 
        case OP_PUSH: {
            if (vm->ip + 8 > vm->code_size) return VM_ERR_INVALID_OPCODE;
            if (vm->sp >= VM_STACK_CAPACITY) return VM_ERR_STACK_OVERFLOW;
            int64_t val;
            memcpy(&val, &vm->code[vm->ip], 8);
            vm->ip += 8;
            vm->stack[vm->sp++] = val;
            return VM_OK;
        }
 
        case OP_POP: {
            if (vm->sp == 0) return VM_ERR_STACK_UNDERFLOW;
            vm->sp--;
            return VM_OK;
        }
 
        case OP_DUP: {
            if (vm->sp == 0) return VM_ERR_STACK_UNDERFLOW;
            if (vm->sp >= VM_STACK_CAPACITY) return VM_ERR_STACK_OVERFLOW;
            vm->stack[vm->sp] = vm->stack[vm->sp - 1];
            vm->sp++;
            return VM_OK;
        }
 
        case OP_SWAP: {
            if (vm->sp < 2) return VM_ERR_STACK_UNDERFLOW;
            int64_t tmp = vm->stack[vm->sp - 1];
            vm->stack[vm->sp - 1] = vm->stack[vm->sp - 2];
            vm->stack[vm->sp - 2] = tmp;
            return VM_OK;
        }
 
        case OP_ADD: {
            if (vm->sp < 2) return VM_ERR_STACK_UNDERFLOW;
            int64_t b = vm->stack[--vm->sp];
            int64_t a = vm->stack[--vm->sp];
            vm->stack[vm->sp++] = a + b;
            return VM_OK;
        }
 
        case OP_SUB: {
            if (vm->sp < 2) return VM_ERR_STACK_UNDERFLOW;
            int64_t b = vm->stack[--vm->sp];
            int64_t a = vm->stack[--vm->sp];
            vm->stack[vm->sp++] = a - b;
            return VM_OK;
        }
 
        case OP_MUL: {
            if (vm->sp < 2) return VM_ERR_STACK_UNDERFLOW;
            int64_t b = vm->stack[--vm->sp];
            int64_t a = vm->stack[--vm->sp];
            vm->stack[vm->sp++] = a * b;
            return VM_OK;
        }
 
        case OP_DIV: {
            if (vm->sp < 2) return VM_ERR_STACK_UNDERFLOW;
            int64_t b = vm->stack[--vm->sp];
            int64_t a = vm->stack[--vm->sp];
            if (b == 0) return VM_ERR_DIVISION_BY_ZERO;
            if (a == INT64_MIN && b == -1) {
                vm->stack[vm->sp++] = INT64_MIN;
            } else {
                vm->stack[vm->sp++] = a / b;
            }
            return VM_OK;
        }
 
        case OP_MOD: {
            if (vm->sp < 2) return VM_ERR_STACK_UNDERFLOW;
            int64_t b = vm->stack[--vm->sp];
            int64_t a = vm->stack[--vm->sp];
            if (b == 0) return VM_ERR_DIVISION_BY_ZERO;
            if (b == -1) {
                vm->stack[vm->sp++] = 0;
            } else {
                vm->stack[vm->sp++] = a % b;
            }
            return VM_OK;
        }
 
        case OP_NEG: {
            if (vm->sp < 1) return VM_ERR_STACK_UNDERFLOW;
            vm->stack[vm->sp - 1] = -vm->stack[vm->sp - 1];
            return VM_OK;
        }
 
        case OP_EQ: {
            if (vm->sp < 2) return VM_ERR_STACK_UNDERFLOW;
            int64_t b = vm->stack[--vm->sp];
            int64_t a = vm->stack[--vm->sp];
            vm->stack[vm->sp++] = (a == b) ? 1 : 0;
            return VM_OK;
        }
 
        case OP_LT: {
            if (vm->sp < 2) return VM_ERR_STACK_UNDERFLOW;
            int64_t b = vm->stack[--vm->sp];
            int64_t a = vm->stack[--vm->sp];
            vm->stack[vm->sp++] = (a < b) ? 1 : 0;
            return VM_OK;
        }
 
        case OP_GT: {
            if (vm->sp < 2) return VM_ERR_STACK_UNDERFLOW;
            int64_t b = vm->stack[--vm->sp];
            int64_t a = vm->stack[--vm->sp];
            vm->stack[vm->sp++] = (a > b) ? 1 : 0;
            return VM_OK;
        }
 
        case OP_JMP: {
            if (vm->ip + 4 > vm->code_size) return VM_ERR_INVALID_OPCODE;
            uint32_t target;
            memcpy(&target, &vm->code[vm->ip], 4);
            if (target >= vm->code_size) return VM_ERR_INVALID_JUMP;
            vm->ip = target;
            return VM_OK;
        }
 
        case OP_JZ: {
            if (vm->sp < 1) return VM_ERR_STACK_UNDERFLOW;
            if (vm->ip + 4 > vm->code_size) return VM_ERR_INVALID_OPCODE;
            uint32_t target;
            memcpy(&target, &vm->code[vm->ip], 4);
            int64_t cond = vm->stack[--vm->sp];
            if (cond == 0) {
                if (target >= vm->code_size) return VM_ERR_INVALID_JUMP;
                vm->ip = target;
            } else {
                vm->ip += 4;
            }
            return VM_OK;
        }
 
        case OP_JNZ: {
            if (vm->sp < 1) return VM_ERR_STACK_UNDERFLOW;
            if (vm->ip + 4 > vm->code_size) return VM_ERR_INVALID_OPCODE;
            uint32_t target;
            memcpy(&target, &vm->code[vm->ip], 4);
            int64_t cond = vm->stack[--vm->sp];
            if (cond != 0) {
                if (target >= vm->code_size) return VM_ERR_INVALID_JUMP;
                vm->ip = target;
            } else {
                vm->ip += 4;
            }
            return VM_OK;
        }
 
        case OP_CALL: {
            if (vm->ip + 4 > vm->code_size) return VM_ERR_INVALID_OPCODE;
            if (vm->fp >= VM_CALL_STACK_CAPACITY) return VM_ERR_CALL_STACK_OVERFLOW;
            uint32_t target;
            memcpy(&target, &vm->code[vm->ip], 4);
            if (target >= vm->code_size) return VM_ERR_INVALID_JUMP;
            
            vm->call_stack[vm->fp].return_address = vm->ip + 4;
            memcpy(vm->call_stack[vm->fp].locals, vm->current_locals, sizeof(vm->current_locals));
            vm->fp++;
            memset(vm->current_locals, 0, sizeof(vm->current_locals));
            vm->ip = target;
            return VM_OK;
        }
 
        case OP_RET: {
            if (vm->fp == 0) return VM_ERR_CALL_STACK_UNDERFLOW;
            vm->fp--;
            vm->ip = vm->call_stack[vm->fp].return_address;
            memcpy(vm->current_locals, vm->call_stack[vm->fp].locals, sizeof(vm->current_locals));
            return VM_OK;
        }
 
        case OP_LOAD: {
            if (vm->ip + 1 > vm->code_size) return VM_ERR_INVALID_OPCODE;
            uint8_t idx = vm->code[vm->ip++];
            if (idx >= VM_LOCALS_COUNT) return VM_ERR_INVALID_LOCAL_INDEX;
            if (vm->sp >= VM_STACK_CAPACITY) return VM_ERR_STACK_OVERFLOW;
            vm->stack[vm->sp++] = vm->current_locals[idx];
            return VM_OK;
        }
 
        case OP_STORE: {
            if (vm->ip + 1 > vm->code_size) return VM_ERR_INVALID_OPCODE;
            uint8_t idx = vm->code[vm->ip++];
            if (idx >= VM_LOCALS_COUNT) return VM_ERR_INVALID_LOCAL_INDEX;
            if (vm->sp == 0) return VM_ERR_STACK_UNDERFLOW;
            vm->current_locals[idx] = vm->stack[--vm->sp];
            return VM_OK;
        }
 
        case OP_PRINT: {
            if (vm->sp == 0) return VM_ERR_STACK_UNDERFLOW;
            int64_t val = vm->stack[--vm->sp];
            fprintf(vm->out, "%" PRId64 "\n", val);
            return VM_OK;
        }
 
        default:
            return VM_ERR_INVALID_OPCODE;
    }
}
 
VMResult vm_run(VM *vm) {
    if (!vm) return VM_ERR_INVALID_OPCODE;
    while (!vm->halted) {
        if (vm->ip >= vm->code_size) {
            return VM_ERR_INVALID_JUMP;
        }
        VMResult res = vm_step(vm);
        if (res != VM_OK) {
            return res;
        }
    }
    return VM_OK;
}
 
const char *vm_result_to_string(VMResult result) {
    switch (result) {
        case VM_OK: return "OK";
        case VM_ERR_STACK_OVERFLOW: return "Stack overflow";
        case VM_ERR_STACK_UNDERFLOW: return "Stack underflow";
        case VM_ERR_CALL_STACK_OVERFLOW: return "Call stack overflow";
        case VM_ERR_CALL_STACK_UNDERFLOW: return "Call stack underflow";
        case VM_ERR_DIVISION_BY_ZERO: return "Division by zero";
        case VM_ERR_INVALID_OPCODE: return "Invalid opcode";
        case VM_ERR_INVALID_JUMP: return "Invalid jump target";
        case VM_ERR_INVALID_LOCAL_INDEX: return "Invalid local variable index";
        default: return "Unknown error";
    }
}
 

262 linesc

**Verifying Core Components** I'm now diving into the implementation details of `asm.c`, fo…

Files at this step

drag the rail to scrub

Discussion

No comments yet. Start the discussion. Recorded by @patrick-toulme.

#antigravity #c #gemini #quick #testing

v5-agy

← all sessions