C11 bytecode VM with assembler

opencodegpt-5.5 · 46 steps · 3m 53s · 8 filessession b7cfed1b-038@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 23 / 46

asm.cchange 1/1

#include "vm.h"
 
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct {
    char name[64];
    size_t address;
} Label;
 
typedef struct {
    Label labels[512];
    size_t count;
} LabelTable;
 
typedef struct {
    const char *name;
    int opcode;
    int operands;
} OpInfo;
 
static const OpInfo OPS[] = {
    {"PUSH", OP_PUSH, 1}, {"POP", OP_POP, 0}, {"DUP", OP_DUP, 0}, {"SWAP", OP_SWAP, 0},
    {"ADD", OP_ADD, 0}, {"SUB", OP_SUB, 0}, {"MUL", OP_MUL, 0}, {"DIV", OP_DIV, 0},
    {"MOD", OP_MOD, 0}, {"NEG", OP_NEG, 0}, {"EQ", OP_EQ, 0}, {"LT", OP_LT, 0},
    {"GT", OP_GT, 0}, {"JMP", OP_JMP, 1}, {"JZ", OP_JZ, 1}, {"JNZ", OP_JNZ, 1},
    {"CALL", OP_CALL, 1}, {"RET", OP_RET, 0}, {"LOAD", OP_LOAD, 1}, {"STORE", OP_STORE, 1},
    {"PRINT", OP_PRINT, 0}, {"HALT", OP_HALT, 0}
};
 
void assembler_init(Assembler *assembler) {
    assembler->error[0] = '\0';
}
 
static void asm_error(Assembler *assembler, int line, const char *message) {
    snprintf(assembler->error, sizeof(assembler->error), "line %d: %s", line, message);
}
 
static char *trim(char *s) {
    char *end;
    while (isspace((unsigned char)*s)) s++;
    if (*s == '\0') return s;
    end = s + strlen(s) - 1;
    while (end > s && isspace((unsigned char)*end)) *end-- = '\0';
    return s;
}
 
static void uppercase(char *s) {
    while (*s) {
        *s = (char)toupper((unsigned char)*s);
        s++;
    }
}
 
static const OpInfo *find_op(const char *name) {
    size_t i;
    for (i = 0; i < sizeof(OPS) / sizeof(OPS[0]); i++) {
        if (strcmp(OPS[i].name, name) == 0) return &OPS[i];
    }
    return NULL;
}
 
static int parse_int(const char *s, int *value) {
    char *end;
    long parsed;
    errno = 0;
    parsed = strtol(s, &end, 10);
    if (errno || end == s || *end != '\0' || parsed < -2147483647L - 1L || parsed > 2147483647L) return 0;
    *value = (int)parsed;
    return 1;
}
 
static int valid_label_name(const char *s) {
    if (!isalpha((unsigned char)s[0]) && s[0] != '_') return 0;
    s++;
    while (*s) {
        if (!isalnum((unsigned char)*s) && *s != '_') return 0;
        s++;
    }
    return 1;
}
 
static int add_label(Assembler *assembler, LabelTable *labels, const char *name, size_t address, int line) {
    size_t i;
    if (!valid_label_name(name)) {
        asm_error(assembler, line, "invalid label name");
        return 0;
    }
    for (i = 0; i < labels->count; i++) {
        if (strcmp(labels->labels[i].name, name) == 0) {
            asm_error(assembler, line, "duplicate label");
            return 0;
        }
    }
    if (labels->count >= sizeof(labels->labels) / sizeof(labels->labels[0])) {
        asm_error(assembler, line, "too many labels");
        return 0;
    }
    snprintf(labels->labels[labels->count].name, sizeof(labels->labels[labels->count].name), "%s", name);
    labels->labels[labels->count].address = address;
    labels->count++;
    return 1;
}
 
static int find_label(const LabelTable *labels, const char *name, size_t *address) {
    size_t i;
    for (i = 0; i < labels->count; i++) {
        if (strcmp(labels->labels[i].name, name) == 0) {
            *address = labels->labels[i].address;
            return 1;
        }
    }
    return 0;
}
 
static void strip_comment(char *line) {
    char *comment = strchr(line, ';');
    if (comment) *comment = '\0';
    comment = strchr(line, '#');
    if (comment) *comment = '\0';
}
 
static int next_line(char **cursor, char *line, size_t line_size) {
    size_t len = 0;
    if (**cursor == '\0') return 0;
    while ((*cursor)[len] && (*cursor)[len] != '\n' && len + 1 < line_size) {
        line[len] = (*cursor)[len];
        len++;
    }
    line[len] = '\0';
    while ((*cursor)[len] && (*cursor)[len] != '\n') len++;
    *cursor += len;
    if (**cursor == '\n') (*cursor)++;
    return 1;
}
 
static int first_pass(Assembler *assembler, char *source, LabelTable *labels) {
    char *cursor = source;
    char line[512];
    int line_no = 0;
    size_t pc = 0;
 
    while (next_line(&cursor, line, sizeof(line))) {
        char *work;
        char *colon;
        char *mnemonic;
        const OpInfo *op;
        line_no++;
        strip_comment(line);
        work = trim(line);
        if (*work == '\0') continue;
 
        colon = strchr(work, ':');
        if (colon) {
            *colon = '\0';
            if (!add_label(assembler, labels, trim(work), pc, line_no)) return 0;
            work = trim(colon + 1);
            if (*work == '\0') continue;
        }
 
        mnemonic = strtok(work, " \t\r");
        if (!mnemonic) continue;
        uppercase(mnemonic);
        op = find_op(mnemonic);
        if (!op) {
            asm_error(assembler, line_no, "unknown mnemonic");
            return 0;
        }
        pc += (size_t)(1 + op->operands);
        if (pc > sizeof(((Program *)0)->code) / sizeof(((Program *)0)->code[0])) {
            asm_error(assembler, line_no, "program too large");
            return 0;
        }
    }
    return 1;
}
 
static int emit(Assembler *assembler, Program *program, int value, int line) {
    if (program->count >= sizeof(program->code) / sizeof(program->code[0])) {
        asm_error(assembler, line, "program too large");
        return 0;
    }
    program->code[program->count++] = value;
    return 1;
}
 
static int needs_label_operand(int opcode) {
    return opcode == OP_JMP || opcode == OP_JZ || opcode == OP_JNZ || opcode == OP_CALL;
}
 
static int second_pass(Assembler *assembler, char *source, const LabelTable *labels, Program *program) {
    char *cursor = source;
    char line[512];
    int line_no = 0;
    program->count = 0;
 
    while (next_line(&cursor, line, sizeof(line))) {
        char *work;
        char *colon;
        char *mnemonic;
        char *operand_text;
        char *extra;
        const OpInfo *op;
        int operand = 0;
        size_t address;
 
        line_no++;
        strip_comment(line);
        work = trim(line);
        if (*work == '\0') continue;
        colon = strchr(work, ':');
        if (colon) {
            work = trim(colon + 1);
            if (*work == '\0') continue;
        }
 
        mnemonic = strtok(work, " \t\r");
        if (!mnemonic) continue;
        uppercase(mnemonic);
        op = find_op(mnemonic);
        if (!op) {
            asm_error(assembler, line_no, "unknown mnemonic");
            return 0;
        }
        if (!emit(assembler, program, op->opcode, line_no)) return 0;
 
        operand_text = strtok(NULL, " \t\r");
        extra = strtok(NULL, " \t\r");
        if ((op->operands == 0 && operand_text) || (op->operands == 1 && (!operand_text || extra))) {
            asm_error(assembler, line_no, "wrong operand count");
            return 0;
        }
        if (op->operands == 1) {
            if (needs_label_operand(op->opcode) && find_label(labels, operand_text, &address)) {
                operand = (int)address;
            } else if (!parse_int(operand_text, &operand)) {
                asm_error(assembler, line_no, "invalid operand");
                return 0;
            }
            if ((op->opcode == OP_LOAD || op->opcode == OP_STORE) && (operand < 0 || operand >= 16)) {
                asm_error(assembler, line_no, "local index out of range");
                return 0;
            }
            if (!emit(assembler, program, operand, line_no)) return 0;
        }
    }
    return 1;
}
 
int assembler_assemble_string(Assembler *assembler, const char *source, Program *program) {
    char *copy1;
    char *copy2;
    LabelTable labels;
    int ok;
 
    assembler_init(assembler);
    memset(&labels, 0, sizeof(labels));
    copy1 = malloc(strlen(source) + 1);
    copy2 = malloc(strlen(source) + 1);
    if (!copy1 || !copy2) {
        snprintf(assembler->error, sizeof(assembler->error), "out of memory");
        free(copy1);
        free(copy2);
        return 0;
    }
    strcpy(copy1, source);
    strcpy(copy2, source);
 
    ok = first_pass(assembler, copy1, &labels) && second_pass(assembler, copy2, &labels, program);
    free(copy1);
    free(copy2);
    return ok;
}
 
int assembler_assemble_file(Assembler *assembler, const char *path, Program *program) {
    FILE *file = fopen(path, "rb");
    long size;
    char *source;
    int ok;
    if (!file) {
        snprintf(assembler->error, sizeof(assembler->error), "cannot open %s", path);
        return 0;
    }
    if (fseek(file, 0, SEEK_END) != 0) {
        fclose(file);
        snprintf(assembler->error, sizeof(assembler->error), "cannot seek %s", path);
        return 0;
    }
    size = ftell(file);
    if (size < 0) {
        fclose(file);
        snprintf(assembler->error, sizeof(assembler->error), "cannot read size of %s", path);
        return 0;
    }
    rewind(file);
    source = malloc((size_t)size + 1);
    if (!source) {
        fclose(file);
        snprintf(assembler->error, sizeof(assembler->error), "out of memory");
        return 0;
    }
    if (fread(source, 1, (size_t)size, file) != (size_t)size) {
        free(source);
        fclose(file);
        snprintf(assembler->error, sizeof(assembler->error), "cannot read %s", path);
        return 0;
    }
    source[size] = '\0';
    fclose(file);
    ok = assembler_assemble_string(assembler, source, program);
    free(source);
    return ok;
}
 

317 linesc

Plans 2 todos

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 #opencode #quick

v3-opencode

← all sessions