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

pigpt-5.5 · 59 steps · 6m 14s · 8 filessession 16bb4aa0-258@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 49 / 59

vm.cchange 3/4

#include "vm.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void bytecode_init(Bytecode *bc) {
    bc->words = NULL;
    bc->count = 0;
    bc->capacity = 0;
}
 
void bytecode_free(Bytecode *bc) {
    free(bc->words);
    bc->words = NULL;
    bc->count = 0;
    bc->capacity = 0;
}
 
VmError bytecode_emit(Bytecode *bc, int64_t word) {
    if (bc->count == bc->capacity) {
        size_t new_capacity = bc->capacity == 0 ? 64 : bc->capacity * 2;
        int64_t *new_words = (int64_t *)realloc(bc->words, new_capacity * sizeof(*new_words));
        if (!new_words) {
            return VM_ERR_OUT_OF_MEMORY;
        }
        bc->words = new_words;
        bc->capacity = new_capacity;
    }
    bc->words[bc->count++] = word;
    return VM_OK;
}
 
static int default_output(int64_t value, void *userdata) {
    (void)userdata;
    return printf("%lld\n", (long long)value) < 0 ? -1 : 0;
}
 
void vm_init(VM *vm, const Bytecode *code) {
    memset(vm, 0, sizeof(*vm));
    vm->code = code;
    vm->output = default_output;
    vm->frame_count = 1;
}
 
void vm_set_output(VM *vm, VmOutputFn output, void *userdata) {
    vm->output = output ? output : default_output;
    vm->output_userdata = userdata;
}
 
static VmError push(VM *vm, int64_t value) {
    if (vm->sp >= VM_STACK_MAX) {
        return VM_ERR_STACK_OVERFLOW;
    }
    vm->stack[vm->sp++] = value;
    return VM_OK;
}
 
static VmError pop(VM *vm, int64_t *out) {
    if (vm->sp == 0) {
        return VM_ERR_STACK_UNDERFLOW;
    }
    *out = vm->stack[--vm->sp];
    return VM_OK;
}
 
static VmError read_operand(VM *vm, int64_t *out) {
    if (vm->ip >= vm->code->count) {
        return VM_ERR_TRUNCATED_INSTRUCTION;
    }
    *out = vm->code->words[vm->ip++];
    return VM_OK;
}
 
−static int is_valid_opcode(int64_t opcode) {
−    return opcode >= OP_PUSH && opcode <= OP_HALT;
static int opcode_operand_count(int64_t opcode, size_t *count) {
    if (!is_valid_opcode(opcode)) {
        return 0;
    }
    switch ((VmOpcode)opcode) {
        case OP_PUSH:
        case OP_JMP:
        case OP_JZ:
        case OP_JNZ:
        case OP_CALL:
        case OP_LOAD:
        case OP_STORE:
            *count = 1;
            return 1;
        case OP_POP:
        case OP_DUP:
        case OP_SWAP:
        case OP_ADD:
        case OP_SUB:
        case OP_MUL:
        case OP_DIV:
        case OP_MOD:
        case OP_NEG:
        case OP_EQ:
        case OP_LT:
        case OP_GT:
        case OP_RET:
        case OP_PRINT:
        case OP_HALT:
            *count = 0;
            return 1;
    }
    return 0;
}
 
static int is_instruction_boundary(const VM *vm, size_t target) {
    size_t pos = 0;
    while (pos < vm->code->count) {
        if (pos == target) {
            return 1;
        }
        size_t operands = 0;
        if (!opcode_operand_count(vm->code->words[pos], &operands)) {
            return 0;
        }
        if (pos + 1 + operands > vm->code->count) {
            return 0;
        }
        pos += 1 + operands;
    }
    return 0;
}
 
static VmError validate_target(const VM *vm, int64_t target) {
    if (target < 0 || (uint64_t)target >= vm->code->count) {
        return VM_ERR_BAD_JUMP;
    }
−    if (!is_valid_opcode(vm->code->words[target])) {
    if (!is_instruction_boundary(vm, (size_t)target)) {
        return VM_ERR_BAD_JUMP;
    }
    return VM_OK;
}
 
VmError vm_run(VM *vm) {
    if (!vm->code) {
        vm->last_error = VM_ERR_BAD_OPERAND;
        return vm->last_error;
    }
 
    VmError err = VM_OK;
    for (;;) {
        err = VM_OK;
        if (vm->ip >= vm->code->count) {
            vm->last_error = VM_ERR_NO_HALT;
            return vm->last_error;
        }
 
        int64_t raw_opcode = vm->code->words[vm->ip++];
        if (!is_valid_opcode(raw_opcode)) {
            vm->last_error = VM_ERR_BAD_OPCODE;
            return vm->last_error;
        }
 
        VmOpcode opcode = (VmOpcode)raw_opcode;
        int64_t a = 0;
        int64_t b = 0;
        int64_t operand = 0;
 
        switch (opcode) {
            case OP_PUSH:
                if ((err = read_operand(vm, &operand)) != VM_OK) goto fail;
                if ((err = push(vm, operand)) != VM_OK) goto fail;
                break;
 
            case OP_POP:
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                break;
 
            case OP_DUP:
                if (vm->sp == 0) {
                    err = VM_ERR_STACK_UNDERFLOW;
                    goto fail;
                }
                if ((err = push(vm, vm->stack[vm->sp - 1])) != VM_OK) goto fail;
                break;
 
            case OP_SWAP:
                if (vm->sp < 2) {
                    err = VM_ERR_STACK_UNDERFLOW;
                    goto fail;
                }
                a = vm->stack[vm->sp - 1];
                vm->stack[vm->sp - 1] = vm->stack[vm->sp - 2];
                vm->stack[vm->sp - 2] = a;
                break;
 
            case OP_ADD:
                if ((err = pop(vm, &b)) != VM_OK) goto fail;
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if ((err = push(vm, a + b)) != VM_OK) goto fail;
                break;
 
            case OP_SUB:
                if ((err = pop(vm, &b)) != VM_OK) goto fail;
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if ((err = push(vm, a - b)) != VM_OK) goto fail;
                break;
 
            case OP_MUL:
                if ((err = pop(vm, &b)) != VM_OK) goto fail;
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if ((err = push(vm, a * b)) != VM_OK) goto fail;
                break;
 
            case OP_DIV:
                if ((err = pop(vm, &b)) != VM_OK) goto fail;
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if (b == 0) {
                    err = VM_ERR_DIVISION_BY_ZERO;
                    goto fail;
                }
                if ((err = push(vm, a / b)) != VM_OK) goto fail;
                break;
 
            case OP_MOD:
                if ((err = pop(vm, &b)) != VM_OK) goto fail;
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if (b == 0) {
                    err = VM_ERR_DIVISION_BY_ZERO;
                    goto fail;
                }
                if ((err = push(vm, a % b)) != VM_OK) goto fail;
                break;
 
            case OP_NEG:
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if ((err = push(vm, -a)) != VM_OK) goto fail;
                break;
 
            case OP_EQ:
                if ((err = pop(vm, &b)) != VM_OK) goto fail;
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if ((err = push(vm, a == b ? 1 : 0)) != VM_OK) goto fail;
                break;
 
            case OP_LT:
                if ((err = pop(vm, &b)) != VM_OK) goto fail;
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if ((err = push(vm, a < b ? 1 : 0)) != VM_OK) goto fail;
                break;
 
            case OP_GT:
                if ((err = pop(vm, &b)) != VM_OK) goto fail;
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if ((err = push(vm, a > b ? 1 : 0)) != VM_OK) goto fail;
                break;
 
            case OP_JMP:
                if ((err = read_operand(vm, &operand)) != VM_OK) goto fail;
                if ((err = validate_target(vm, operand)) != VM_OK) goto fail;
                vm->ip = (size_t)operand;
                break;
 
            case OP_JZ:
                if ((err = read_operand(vm, &operand)) != VM_OK) goto fail;
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if (a == 0) {
                    if ((err = validate_target(vm, operand)) != VM_OK) goto fail;
                    vm->ip = (size_t)operand;
                }
                break;
 
            case OP_JNZ:
                if ((err = read_operand(vm, &operand)) != VM_OK) goto fail;
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if (a != 0) {
                    if ((err = validate_target(vm, operand)) != VM_OK) goto fail;
                    vm->ip = (size_t)operand;
                }
                break;
 
            case OP_CALL:
                if ((err = read_operand(vm, &operand)) != VM_OK) goto fail;
                if ((err = validate_target(vm, operand)) != VM_OK) goto fail;
                if (vm->frame_count >= VM_CALL_STACK_MAX) {
                    err = VM_ERR_CALL_OVERFLOW;
                    goto fail;
                }
                vm->frames[vm->frame_count].return_ip = vm->ip;
                memset(vm->frames[vm->frame_count].locals, 0, sizeof(vm->frames[vm->frame_count].locals));
                vm->frame_count++;
                vm->ip = (size_t)operand;
                break;
 
            case OP_RET:
                if (vm->frame_count <= 1) {
                    err = VM_ERR_CALL_UNDERFLOW;
                    goto fail;
                }
                vm->frame_count--;
                vm->ip = vm->frames[vm->frame_count].return_ip;
                break;
 
            case OP_LOAD:
                if ((err = read_operand(vm, &operand)) != VM_OK) goto fail;
                if (operand < 0 || operand >= VM_LOCALS_PER_FRAME) {
                    err = VM_ERR_BAD_LOCAL;
                    goto fail;
                }
                if ((err = push(vm, vm->frames[vm->frame_count - 1].locals[operand])) != VM_OK) goto fail;
                break;
 
            case OP_STORE:
                if ((err = read_operand(vm, &operand)) != VM_OK) goto fail;
                if (operand < 0 || operand >= VM_LOCALS_PER_FRAME) {
                    err = VM_ERR_BAD_LOCAL;
                    goto fail;
                }
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                vm->frames[vm->frame_count - 1].locals[operand] = a;
                break;
 
            case OP_PRINT:
                if ((err = pop(vm, &a)) != VM_OK) goto fail;
                if (vm->output(a, vm->output_userdata) != 0) {
                    err = VM_ERR_OUTPUT;
                    goto fail;
                }
                break;
 
            case OP_HALT:
                vm->last_error = VM_OK;
                return VM_OK;
        }
    }
 
fail:
    vm->last_error = err;
    return err;
}
 
const char *vm_error_string(VmError error) {
    switch (error) {
        case VM_OK: return "ok";
        case VM_ERR_STACK_UNDERFLOW: return "stack underflow";
        case VM_ERR_STACK_OVERFLOW: return "stack overflow";
        case VM_ERR_CALL_UNDERFLOW: return "call stack underflow";
        case VM_ERR_CALL_OVERFLOW: return "call stack overflow";
        case VM_ERR_DIVISION_BY_ZERO: return "division by zero";
        case VM_ERR_BAD_OPCODE: return "bad opcode";
        case VM_ERR_BAD_OPERAND: return "bad operand";
        case VM_ERR_BAD_LOCAL: return "bad local";
        case VM_ERR_BAD_JUMP: return "out-of-range jump";
        case VM_ERR_TRUNCATED_INSTRUCTION: return "truncated instruction";
        case VM_ERR_NO_HALT: return "program ended without halt";
        case VM_ERR_OUT_OF_MEMORY: return "out of memory";
        case VM_ERR_OUTPUT: return "output error";
        default: return "unknown error";
    }
}
 

355 linesc

**Adding is_valid check before opcode_operand_count**

Files at this step

drag the rail to scrub

Discussion

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

#c #gpt #gpt-5.5 #pi #quick #testing

v4-pi

← all sessions