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

claude-codeclaude-sonnet-5 · 45 steps · 10m 00s · 9 filessession 38d9918d-816@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 10 / 45

vm.cchange 1/1

#include "vm.h"
 
#include <string.h>
 
static VMFrame *current_frame(VM *vm) {
    return &vm->call_stack[vm->fp - 1];
}
 
static int vm_push(VM *vm, int64_t val) {
    if (vm->sp >= VM_STACK_MAX) {
        vm->status = VM_ERR_STACK_OVERFLOW;
        return 0;
    }
    vm->stack[vm->sp++] = val;
    return 1;
}
 
static int vm_pop(VM *vm, int64_t *out) {
    if (vm->sp <= 0) {
        vm->status = VM_ERR_STACK_UNDERFLOW;
        return 0;
    }
    *out = vm->stack[--vm->sp];
    return 1;
}
 
static int read_i64(VM *vm, int64_t *out) {
    if (vm->ip + sizeof(int64_t) > vm->code_size) return 0;
    memcpy(out, vm->code + vm->ip, sizeof(int64_t));
    vm->ip += sizeof(int64_t);
    return 1;
}
 
static int read_i32(VM *vm, int32_t *out) {
    if (vm->ip + sizeof(int32_t) > vm->code_size) return 0;
    memcpy(out, vm->code + vm->ip, sizeof(int32_t));
    vm->ip += sizeof(int32_t);
    return 1;
}
 
static int read_u8(VM *vm, uint8_t *out) {
    if (vm->ip + sizeof(uint8_t) > vm->code_size) return 0;
    *out = vm->code[vm->ip];
    vm->ip += sizeof(uint8_t);
    return 1;
}
 
void vm_init(VM *vm, const uint8_t *code, size_t code_size, FILE *out) {
    memset(vm, 0, sizeof(*vm));
    vm->code = code;
    vm->code_size = code_size;
    vm->ip = 0;
    vm->sp = 0;
    vm->fp = 1; /* outermost/"main" frame is always present */
    vm->out = out ? out : stdout;
    vm->status = VM_OK;
    vm->halted = 0;
}
 
VMStatus vm_run(VM *vm) {
    if (vm->code == NULL || vm->code_size == 0) {
        vm->status = VM_ERR_NO_CODE;
        return vm->status;
    }
 
    while (!vm->halted) {
        if (vm->ip >= vm->code_size) {
            vm->status = VM_ERR_BAD_JUMP;
            return vm->status;
        }
 
        uint8_t opcode = vm->code[vm->ip];
        vm->ip += 1;
 
        switch (opcode) {
        case OP_PUSH: {
            int64_t val;
            if (!read_i64(vm, &val)) {
                vm->status = VM_ERR_TRUNCATED;
                return vm->status;
            }
            if (!vm_push(vm, val)) return vm->status;
            break;
        }
 
        case OP_POP: {
            int64_t v;
            if (!vm_pop(vm, &v)) return vm->status;
            break;
        }
 
        case OP_DUP: {
            if (vm->sp <= 0) {
                vm->status = VM_ERR_STACK_UNDERFLOW;
                return vm->status;
            }
            if (!vm_push(vm, vm->stack[vm->sp - 1])) return vm->status;
            break;
        }
 
        case OP_SWAP: {
            if (vm->sp < 2) {
                vm->status = VM_ERR_STACK_UNDERFLOW;
                return vm->status;
            }
            int64_t tmp = vm->stack[vm->sp - 1];
            vm->stack[vm->sp - 1] = vm->stack[vm->sp - 2];
            vm->stack[vm->sp - 2] = tmp;
            break;
        }
 
        case OP_ADD:
        case OP_SUB:
        case OP_MUL:
        case OP_DIV:
        case OP_MOD:
        case OP_EQ:
        case OP_LT:
        case OP_GT: {
            int64_t b, a;
            if (!vm_pop(vm, &b)) return vm->status;
            if (!vm_pop(vm, &a)) return vm->status;
            int64_t result;
            switch (opcode) {
            case OP_ADD: result = a + b; break;
            case OP_SUB: result = a - b; break;
            case OP_MUL: result = a * b; break;
            case OP_DIV:
                if (b == 0) {
                    vm->status = VM_ERR_DIV_ZERO;
                    return vm->status;
                }
                /* avoid the hardware trap on INT64_MIN / -1 */
                result = (a == INT64_MIN && b == -1) ? INT64_MIN : a / b;
                break;
            case OP_MOD:
                if (b == 0) {
                    vm->status = VM_ERR_DIV_ZERO;
                    return vm->status;
                }
                result = (a == INT64_MIN && b == -1) ? 0 : a % b;
                break;
            case OP_EQ: result = (a == b) ? 1 : 0; break;
            case OP_LT: result = (a < b) ? 1 : 0; break;
            case OP_GT: result = (a > b) ? 1 : 0; break;
            default: result = 0; break; /* unreachable */
            }
            if (!vm_push(vm, result)) return vm->status;
            break;
        }
 
        case OP_NEG: {
            int64_t v;
            if (!vm_pop(vm, &v)) return vm->status;
            if (!vm_push(vm, -v)) return vm->status;
            break;
        }
 
        case OP_JMP: {
            int32_t target;
            if (!read_i32(vm, &target)) {
                vm->status = VM_ERR_TRUNCATED;
                return vm->status;
            }
            if (target < 0 || (size_t)target >= vm->code_size) {
                vm->status = VM_ERR_BAD_JUMP;
                return vm->status;
            }
            vm->ip = (size_t)target;
            break;
        }
 
        case OP_JZ:
        case OP_JNZ: {
            int32_t target;
            if (!read_i32(vm, &target)) {
                vm->status = VM_ERR_TRUNCATED;
                return vm->status;
            }
            int64_t v;
            if (!vm_pop(vm, &v)) return vm->status;
            int take = (opcode == OP_JZ) ? (v == 0) : (v != 0);
            if (take) {
                if (target < 0 || (size_t)target >= vm->code_size) {
                    vm->status = VM_ERR_BAD_JUMP;
                    return vm->status;
                }
                vm->ip = (size_t)target;
            }
            break;
        }
 
        case OP_CALL: {
            int32_t target;
            if (!read_i32(vm, &target)) {
                vm->status = VM_ERR_TRUNCATED;
                return vm->status;
            }
            if (target < 0 || (size_t)target >= vm->code_size) {
                vm->status = VM_ERR_BAD_JUMP;
                return vm->status;
            }
            if (vm->fp >= VM_CALL_STACK_MAX) {
                vm->status = VM_ERR_CALLSTACK_OVERFLOW;
                return vm->status;
            }
            VMFrame *nf = &vm->call_stack[vm->fp];
            nf->return_addr = (int64_t)vm->ip;
            memset(nf->locals, 0, sizeof(nf->locals));
            vm->fp++;
            vm->ip = (size_t)target;
            break;
        }
 
        case OP_RET: {
            if (vm->fp <= 1) {
                vm->status = VM_ERR_CALLSTACK_UNDERFLOW;
                return vm->status;
            }
            vm->fp--;
            vm->ip = (size_t)vm->call_stack[vm->fp].return_addr;
            break;
        }
 
        case OP_LOAD: {
            uint8_t idx;
            if (!read_u8(vm, &idx)) {
                vm->status = VM_ERR_TRUNCATED;
                return vm->status;
            }
            if (idx >= VM_LOCALS_PER_FRAME) {
                vm->status = VM_ERR_BAD_LOCAL_INDEX;
                return vm->status;
            }
            if (!vm_push(vm, current_frame(vm)->locals[idx])) return vm->status;
            break;
        }
 
        case OP_STORE: {
            uint8_t idx;
            if (!read_u8(vm, &idx)) {
                vm->status = VM_ERR_TRUNCATED;
                return vm->status;
            }
            if (idx >= VM_LOCALS_PER_FRAME) {
                vm->status = VM_ERR_BAD_LOCAL_INDEX;
                return vm->status;
            }
            int64_t v;
            if (!vm_pop(vm, &v)) return vm->status;
            current_frame(vm)->locals[idx] = v;
            break;
        }
 
        case OP_PRINT: {
            int64_t v;
            if (!vm_pop(vm, &v)) return vm->status;
            fprintf(vm->out, "%lld\n", (long long)v);
            break;
        }
 
        case OP_HALT: {
            vm->halted = 1;
            break;
        }
 
        default:
            vm->status = VM_ERR_BAD_OPCODE;
            return vm->status;
        }
    }
 
    return vm->status; /* VM_OK */
}
 
const char *vm_status_str(VMStatus status) {
    switch (status) {
    case VM_OK: return "ok";
    case VM_ERR_STACK_OVERFLOW: return "stack overflow";
    case VM_ERR_STACK_UNDERFLOW: return "stack underflow";
    case VM_ERR_CALLSTACK_OVERFLOW: return "call stack overflow";
    case VM_ERR_CALLSTACK_UNDERFLOW: return "call stack underflow";
    case VM_ERR_DIV_ZERO: return "division by zero";
    case VM_ERR_BAD_OPCODE: return "bad opcode";
    case VM_ERR_BAD_JUMP: return "out-of-range jump";
    case VM_ERR_BAD_LOCAL_INDEX: return "bad local index";
    case VM_ERR_NO_CODE: return "no code loaded";
    case VM_ERR_TRUNCATED: return "truncated instruction";
    default: return "unknown error";
    }
}
 

292 linesc

Writes …/vm.c

Files at this step

drag the rail to scrub

Discussion

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

#c #claude #claude-code #claude-sonnet-5 #quick #testing

v1-claude

← all sessions