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

codexgpt-5.6-terra · 86 steps · 9m 00s · 9 filessession ddf0dfec-8dd@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 46 / 86
asm.cchange 2/2
#include "asm.h"
 
#include "vm.h"
 
#include <errno.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
−enum {
−    ASM_IMMEDIATE_SIZE = 4,
−    ASM_LOCAL_COUNT = 16
−};
enum { ASM_LOCAL_COUNT = VM_LOCALS_PER_FRAME };
 
typedef struct {
    const char *start;
    size_t length;
} Token;
 
typedef struct {
    const char *current;
    const char *end;
} LineParser;
 
typedef struct {
    const char *name;
    uint8_t opcode;
    enum {
        OPERAND_NONE,
        OPERAND_INTEGER,
        OPERAND_TARGET,
        OPERAND_LOCAL
    } operand_kind;
} Instruction;
 
typedef struct {
    char *name;
    size_t length;
    size_t offset;
    size_t line;
} Label;
 
typedef struct {
    Label *items;
    size_t count;
    size_t capacity;
} LabelTable;
 
/* Keep this table in one place: it is the textual contract of the VM. */
static const Instruction INSTRUCTIONS[] = {
    {"PUSH", VM_OP_PUSH, OPERAND_INTEGER},
    {"POP", VM_OP_POP, OPERAND_NONE},
    {"DUP", VM_OP_DUP, OPERAND_NONE},
    {"SWAP", VM_OP_SWAP, OPERAND_NONE},
    {"ADD", VM_OP_ADD, OPERAND_NONE},
    {"SUB", VM_OP_SUB, OPERAND_NONE},
    {"MUL", VM_OP_MUL, OPERAND_NONE},
    {"DIV", VM_OP_DIV, OPERAND_NONE},
    {"MOD", VM_OP_MOD, OPERAND_NONE},
    {"NEG", VM_OP_NEG, OPERAND_NONE},
    {"EQ", VM_OP_EQ, OPERAND_NONE},
    {"LT", VM_OP_LT, OPERAND_NONE},
    {"GT", VM_OP_GT, OPERAND_NONE},
    {"JMP", VM_OP_JMP, OPERAND_TARGET},
    {"JZ", VM_OP_JZ, OPERAND_TARGET},
    {"JNZ", VM_OP_JNZ, OPERAND_TARGET},
    {"CALL", VM_OP_CALL, OPERAND_TARGET},
    {"RET", VM_OP_RET, OPERAND_NONE},
    {"LOAD", VM_OP_LOAD, OPERAND_LOCAL},
    {"STORE", VM_OP_STORE, OPERAND_LOCAL},
    {"PRINT", VM_OP_PRINT, OPERAND_NONE},
    {"HALT", VM_OP_HALT, OPERAND_NONE},
};
 
static void set_error(char *err, size_t err_cap, const char *format, ...) {
    va_list args;
 
    if (err == NULL || err_cap == 0) {
        return;
    }
 
    va_start(args, format);
    (void)vsnprintf(err, err_cap, format, args);
    va_end(args);
}
 
static void reset_outputs(uint8_t **code_out, size_t *length_out) {
    if (code_out != NULL) {
        *code_out = NULL;
    }
    if (length_out != NULL) {
        *length_out = 0;
    }
}
 
static int validate_outputs(uint8_t **code_out, size_t *length_out,
                            char *err, size_t err_cap) {
    reset_outputs(code_out, length_out);
    if (code_out == NULL || length_out == NULL) {
        set_error(err, err_cap,
                  "assembler requires non-NULL code_out and length_out");
        return -1;
    }
    return 0;
}
 
static unsigned char ascii_lower(unsigned char value) {
    if (value >= (unsigned char)'A' && value <= (unsigned char)'Z') {
        return (unsigned char)(value + ((unsigned char)'a' - (unsigned char)'A'));
    }
    return value;
}
 
static int token_equals_ci(Token token, const char *text) {
    size_t index;
 
    for (index = 0; text[index] != '\0'; ++index) {
        if (index >= token.length ||
            ascii_lower((unsigned char)token.start[index]) !=
                ascii_lower((unsigned char)text[index])) {
            return 0;
        }
    }
    return index == token.length;
}
 
static int is_space(unsigned char value) {
    return value == (unsigned char)' ' || value == (unsigned char)'\t' ||
           value == (unsigned char)'\r' || value == (unsigned char)'\v' ||
           value == (unsigned char)'\f';
}
 
static int starts_comment(const char *current, const char *end) {
    return current < end &&
           (*current == '#' || *current == ';' ||
            (*current == '/' && current + 1 < end && current[1] == '/'));
}
 
static int next_token(LineParser *parser, Token *token) {
    const char *start;
 
    while (parser->current < parser->end &&
           is_space((unsigned char)*parser->current)) {
        ++parser->current;
    }
    if (parser->current >= parser->end ||
        starts_comment(parser->current, parser->end)) {
        return 0;
    }
 
    start = parser->current;
    while (parser->current < parser->end &&
           !is_space((unsigned char)*parser->current) &&
           !starts_comment(parser->current, parser->end)) {
        ++parser->current;
    }
 
    token->start = start;
    token->length = (size_t)(parser->current - start);
    return 1;
}
 
static int is_label_start(unsigned char value) {
    return (value >= (unsigned char)'A' && value <= (unsigned char)'Z') ||
           (value >= (unsigned char)'a' && value <= (unsigned char)'z') ||
           value == (unsigned char)'_';
}
 
static int is_label_continue(unsigned char value) {
    return is_label_start(value) ||
           (value >= (unsigned char)'0' && value <= (unsigned char)'9');
}
 
static int valid_label_name(Token token) {
    size_t index;
 
    if (token.length == 0 || !is_label_start((unsigned char)token.start[0])) {
        return 0;
    }
    for (index = 1; index < token.length; ++index) {
        if (!is_label_continue((unsigned char)token.start[index])) {
            return 0;
        }
    }
    return 1;
}
 
static int token_is_label_definition(Token token) {
    return token.length > 0 && token.start[token.length - 1] == ':';
}
 
static int token_contains_colon(Token token) {
    size_t index;
 
    for (index = 0; index < token.length; ++index) {
        if (token.start[index] == ':') {
            return 1;
        }
    }
    return 0;
}
 
static const Instruction *find_instruction(Token mnemonic) {
    size_t index;
 
    for (index = 0; index < sizeof(INSTRUCTIONS) / sizeof(INSTRUCTIONS[0]);
         ++index) {
        if (token_equals_ci(mnemonic, INSTRUCTIONS[index].name)) {
            return &INSTRUCTIONS[index];
        }
    }
    return NULL;
}
 
static size_t instruction_size(const Instruction *instruction) {
    return instruction->operand_kind == OPERAND_NONE
−               ? 1U
−               : 1U + (size_t)ASM_IMMEDIATE_SIZE;
               ? (size_t)VM_OPCODE_SIZE
               : (size_t)VM_OPCODE_SIZE + (size_t)VM_OPERAND_SIZE;
}
 
static int parse_i32(Token token, int32_t *value_out) {
    size_t index = 0;
    int negative = 0;
    uint64_t magnitude = 0;
    uint64_t limit;
 
    if (token.length == 0) {
        return -1;
    }
    if (token.start[index] == '+' || token.start[index] == '-') {
        negative = token.start[index] == '-';
        ++index;
    }
    if (index == token.length) {
        return -1;
    }
 
    limit = negative ? (uint64_t)INT32_MAX + 1U : (uint64_t)INT32_MAX;
    for (; index < token.length; ++index) {
        unsigned char digit;
 
        if (token.start[index] < '0' || token.start[index] > '9') {
            return -1;
        }
        digit = (unsigned char)(token.start[index] - '0');
        if (magnitude > (limit - digit) / 10U) {
            return -1;
        }
        magnitude = magnitude * 10U + digit;
    }
 
    if (negative) {
        if (magnitude == (uint64_t)INT32_MAX + 1U) {
            *value_out = INT32_MIN;
        } else {
            *value_out = -(int32_t)magnitude;
        }
    } else {
        *value_out = (int32_t)magnitude;
    }
    return 0;
}
 
static int begins_like_number(Token token) {
    if (token.length == 0) {
        return 0;
    }
    return (token.start[0] >= '0' && token.start[0] <= '9') ||
           token.start[0] == '+' || token.start[0] == '-';
}
 
static void token_for_error(Token token, char *buffer, size_t buffer_cap) {
    size_t amount;
 
    if (buffer_cap == 0) {
        return;
    }
    amount = token.length;
    if (amount >= buffer_cap) {
        amount = buffer_cap - 1;
    }
    if (amount != 0) {
        memcpy(buffer, token.start, amount);
    }
    buffer[amount] = '\0';
}
 
static int get_operand(LineParser *parser, Token *operand, size_t line,
                       char *err, size_t err_cap) {
    Token extra;
 
    if (!next_token(parser, operand)) {
        set_error(err, err_cap, "line %zu: missing instruction operand", line);
        return -1;
    }
    if (next_token(parser, &extra)) {
        char text[65];
        token_for_error(extra, text, sizeof(text));
        set_error(err, err_cap, "line %zu: unexpected token '%s'", line, text);
        return -1;
    }
    return 0;
}
 
static int ensure_no_operand(LineParser *parser, size_t line, char *err,
                             size_t err_cap) {
    Token extra;
 
    if (next_token(parser, &extra)) {
        char text[65];
        token_for_error(extra, text, sizeof(text));
        set_error(err, err_cap,
                  "line %zu: instruction does not take an operand ('%s')", line,
                  text);
        return -1;
    }
    return 0;
}
 
static int validate_operand(const Instruction *instruction, LineParser *parser,
                            size_t line, Token *operand_out, char *err,
                            size_t err_cap) {
    Token operand;
    int32_t value;
 
    if (instruction->operand_kind == OPERAND_NONE) {
        return ensure_no_operand(parser, line, err, err_cap);
    }
    if (get_operand(parser, &operand, line, err, err_cap) != 0) {
        return -1;
    }
 
    switch (instruction->operand_kind) {
        case OPERAND_INTEGER:
            if (parse_i32(operand, &value) != 0) {
                set_error(err, err_cap, "line %zu: expected a signed 32-bit integer",
                          line);
                return -1;
            }
            break;
        case OPERAND_LOCAL:
            if (parse_i32(operand, &value) != 0 || value < 0 ||
                value >= ASM_LOCAL_COUNT) {
                set_error(err, err_cap,
                          "line %zu: local index must be an integer from 0 to %d",
                          line, ASM_LOCAL_COUNT - 1);
                return -1;
            }
            break;
        case OPERAND_TARGET:
            if (parse_i32(operand, &value) != 0) {
                if (begins_like_number(operand) || !valid_label_name(operand)) {
                    set_error(err, err_cap,
                              "line %zu: expected a signed 32-bit address or label",
                              line);
                    return -1;
                }
            }
            break;
        case OPERAND_NONE:
        default:
            /* Covered above; keep this branch to make future additions safe. */
            set_error(err, err_cap, "line %zu: internal assembler operand error",
                      line);
            return -1;
    }
 
    if (operand_out != NULL) {
        *operand_out = operand;
    }
    return 0;
}
 
static void labels_destroy(LabelTable *labels) {
    size_t index;
 
    for (index = 0; index < labels->count; ++index) {
        free(labels->items[index].name);
    }
    free(labels->items);
    labels->items = NULL;
    labels->count = 0;
    labels->capacity = 0;
}
 
static const Label *labels_find(const LabelTable *labels, Token name) {
    size_t index;
 
    for (index = 0; index < labels->count; ++index) {
        const Label *label = &labels->items[index];
        if (label->length == name.length &&
            memcmp(label->name, name.start, name.length) == 0) {
            return label;
        }
    }
    return NULL;
}
 
static int labels_add(LabelTable *labels, Token name, size_t offset,
                      size_t line, char *err, size_t err_cap) {
    Label *new_items;
    char *copy;
    size_t new_capacity;
 
    if (labels_find(labels, name) != NULL) {
        char text[65];
        token_for_error(name, text, sizeof(text));
        set_error(err, err_cap, "line %zu: duplicate label '%s'", line, text);
        return -1;
    }
    if (name.length == SIZE_MAX) {
        set_error(err, err_cap, "line %zu: label is too long", line);
        return -1;
    }
    copy = malloc(name.length + 1U);
    if (copy == NULL) {
        set_error(err, err_cap, "out of memory while recording labels");
        return -1;
    }
    memcpy(copy, name.start, name.length);
    copy[name.length] = '\0';
 
    if (labels->count == labels->capacity) {
        new_capacity = labels->capacity == 0 ? 16U : labels->capacity * 2U;
        if (new_capacity < labels->capacity ||
            new_capacity > SIZE_MAX / sizeof(*labels->items)) {
            free(copy);
            set_error(err, err_cap, "too many labels");
            return -1;
        }
        new_items = realloc(labels->items,
                            new_capacity * sizeof(*labels->items));
        if (new_items == NULL) {
            free(copy);
            set_error(err, err_cap, "out of memory while recording labels");
            return -1;
        }
        labels->items = new_items;
        labels->capacity = new_capacity;
    }
 
    labels->items[labels->count].name = copy;
    labels->items[labels->count].length = name.length;
    labels->items[labels->count].offset = offset;
    labels->items[labels->count].line = line;
    ++labels->count;
    return 0;
}
 
static int consume_labels(LineParser *parser, Token *first_non_label,
                          int *has_instruction, LabelTable *labels,
                          size_t offset, size_t line, char *err,
                          size_t err_cap) {
    Token token;
    int has_token = next_token(parser, &token);
 
    while (has_token && token_is_label_definition(token)) {
        Token label_name;
 
        label_name.start = token.start;
        label_name.length = token.length - 1U;
        if (!valid_label_name(label_name)) {
            set_error(err, err_cap, "line %zu: invalid label definition", line);
            return -1;
        }
        if (labels != NULL &&
            labels_add(labels, label_name, offset, line, err, err_cap) != 0) {
            return -1;
        }
        has_token = next_token(parser, &token);
    }
 
    if (!has_token) {
        *has_instruction = 0;
        return 0;
    }
    if (token_contains_colon(token)) {
        set_error(err, err_cap, "line %zu: malformed label definition", line);
        return -1;
    }
    *first_non_label = token;
    *has_instruction = 1;
    return 0;
}
 
static int next_line(const char **cursor, size_t *line_number,
                     const char **start_out, const char **end_out) {
    const char *start = *cursor;
    const char *end = start;
 
    if (*start == '\0') {
        return 0;
    }
    while (*end != '\0' && *end != '\n') {
        ++end;
    }
    *start_out = start;
    *end_out = end;
    if (*end == '\n') {
        *cursor = end + 1;
    } else {
        *cursor = end;
    }
    ++*line_number;
    return 1;
}
 
static int first_pass(const char *source, LabelTable *labels,
                      size_t *code_length, char *err, size_t err_cap) {
    const char *cursor = source;
    const char *line_start;
    const char *line_end;
    size_t line = 0;
    size_t offset = 0;
 
    while (next_line(&cursor, &line, &line_start, &line_end)) {
        LineParser parser = {line_start, line_end};
        Token mnemonic;
        int has_instruction;
        const Instruction *instruction;
        size_t encoded_size;
 
        if (consume_labels(&parser, &mnemonic, &has_instruction, labels, offset,
                           line, err, err_cap) != 0) {
            return -1;
        }
        if (!has_instruction) {
            continue;
        }
        instruction = find_instruction(mnemonic);
        if (instruction == NULL) {
            char text[65];
            token_for_error(mnemonic, text, sizeof(text));
            set_error(err, err_cap, "line %zu: unknown instruction '%s'", line,
                      text);
            return -1;
        }
        if (validate_operand(instruction, &parser, line, NULL, err, err_cap) !=
            0) {
            return -1;
        }
        encoded_size = instruction_size(instruction);
        if (offset > (size_t)INT32_MAX - encoded_size) {
            set_error(err, err_cap, "assembled bytecode exceeds 32-bit address space");
            return -1;
        }
        offset += encoded_size;
    }
 
    *code_length = offset;
    return 0;
}
 
static void write_i32_le(uint8_t *destination, int32_t value) {
    uint32_t bits = (uint32_t)value;
 
    destination[0] = (uint8_t)(bits & UINT32_C(0xff));
    destination[1] = (uint8_t)((bits >> 8U) & UINT32_C(0xff));
    destination[2] = (uint8_t)((bits >> 16U) & UINT32_C(0xff));
    destination[3] = (uint8_t)((bits >> 24U) & UINT32_C(0xff));
}
 
static int resolve_operand(const Instruction *instruction, Token operand,
                           const LabelTable *labels, size_t line,
                           int32_t *value_out, char *err, size_t err_cap) {
    int32_t value;
 
    if (instruction->operand_kind == OPERAND_INTEGER ||
        instruction->operand_kind == OPERAND_LOCAL) {
        if (parse_i32(operand, &value) != 0) {
            set_error(err, err_cap, "line %zu: internal operand parsing error", line);
            return -1;
        }
        *value_out = value;
        return 0;
    }
 
    if (instruction->operand_kind == OPERAND_TARGET) {
        const Label *label;
 
        if (parse_i32(operand, &value) == 0) {
            *value_out = value;
            return 0;
        }
        label = labels_find(labels, operand);
        if (label == NULL) {
            char text[65];
            token_for_error(operand, text, sizeof(text));
            set_error(err, err_cap, "line %zu: undefined label '%s'", line, text);
            return -1;
        }
        if (label->offset > (size_t)INT32_MAX) {
            set_error(err, err_cap, "line %zu: label address is out of range", line);
            return -1;
        }
        *value_out = (int32_t)label->offset;
        return 0;
    }
 
    set_error(err, err_cap, "line %zu: internal assembler operand error", line);
    return -1;
}
 
static int second_pass(const char *source, const LabelTable *labels,
                       uint8_t *code, size_t code_length, char *err,
                       size_t err_cap) {
    const char *cursor = source;
    const char *line_start;
    const char *line_end;
    size_t line = 0;
    size_t offset = 0;
 
    while (next_line(&cursor, &line, &line_start, &line_end)) {
        LineParser parser = {line_start, line_end};
        Token mnemonic;
        Token operand;
        int has_instruction;
        const Instruction *instruction;
 
        if (consume_labels(&parser, &mnemonic, &has_instruction, NULL, offset,
                           line, err, err_cap) != 0) {
            return -1;
        }
        if (!has_instruction) {
            continue;
        }
        instruction = find_instruction(mnemonic);
        if (instruction == NULL ||
            validate_operand(instruction, &parser, line, &operand, err, err_cap) !=
                0) {
            if (instruction == NULL) {
                set_error(err, err_cap, "line %zu: internal instruction lookup error",
                          line);
            }
            return -1;
        }
        if (offset > code_length || instruction_size(instruction) > code_length - offset) {
            set_error(err, err_cap, "internal assembler size mismatch");
            return -1;
        }
        code[offset++] = instruction->opcode;
        if (instruction->operand_kind != OPERAND_NONE) {
            int32_t value;
 
            if (resolve_operand(instruction, operand, labels, line, &value, err,
                                err_cap) != 0) {
                return -1;
            }
            write_i32_le(code + offset, value);
−            offset += ASM_IMMEDIATE_SIZE;
            offset += VM_OPERAND_SIZE;
        }
    }
 
    if (offset != code_length) {
        set_error(err, err_cap, "internal assembler size mismatch");
        return -1;
    }
    return 0;
}
 
static int assemble_source(const char *source, uint8_t **code_out,
                           size_t *length_out, char *err, size_t err_cap) {
    LabelTable labels = {0};
    uint8_t *code = NULL;
    size_t code_length = 0;
    size_t allocation_size;
    int result = -1;
 
    if (first_pass(source, &labels, &code_length, err, err_cap) != 0) {
        goto done;
    }
    allocation_size = code_length == 0 ? 1U : code_length;
    code = malloc(allocation_size);
    if (code == NULL) {
        set_error(err, err_cap, "out of memory while allocating bytecode");
        goto done;
    }
    if (second_pass(source, &labels, code, code_length, err, err_cap) != 0) {
        goto done;
    }
 
    *code_out = code;
    *length_out = code_length;
    code = NULL;
    result = 0;
 
done:
    free(code);
    labels_destroy(&labels);
    return result;
}
 
int asm_assemble(const char *source, uint8_t **code_out, size_t *length_out,
                 char *err, size_t err_cap) {
    if (validate_outputs(code_out, length_out, err, err_cap) != 0) {
        return -1;
    }
    if (source == NULL) {
        set_error(err, err_cap, "assembler source must not be NULL");
        return -1;
    }
    return assemble_source(source, code_out, length_out, err, err_cap);
}
 
int asm_assemble_file(const char *path, uint8_t **code_out,
                      size_t *length_out, char *err, size_t err_cap) {
    FILE *file;
    long file_size;
    char *source = NULL;
    size_t source_length;
    int result;
 
    if (validate_outputs(code_out, length_out, err, err_cap) != 0) {
        return -1;
    }
    if (path == NULL) {
        set_error(err, err_cap, "assembler file path must not be NULL");
        return -1;
    }
    file = fopen(path, "rb");
    if (file == NULL) {
        set_error(err, err_cap, "cannot open '%s': %s", path, strerror(errno));
        return -1;
    }
    if (fseek(file, 0L, SEEK_END) != 0 || (file_size = ftell(file)) < 0 ||
        fseek(file, 0L, SEEK_SET) != 0) {
        int saved_errno = errno;
        (void)fclose(file);
        set_error(err, err_cap, "cannot read '%s': %s", path,
                  strerror(saved_errno));
        return -1;
    }
    if ((uintmax_t)file_size > (uintmax_t)SIZE_MAX - 1U) {
        (void)fclose(file);
        set_error(err, err_cap, "source file '%s' is too large", path);
        return -1;
    }
    source_length = (size_t)file_size;
    source = malloc(source_length + 1U);
    if (source == NULL) {
        (void)fclose(file);
        set_error(err, err_cap, "out of memory while reading '%s'", path);
        return -1;
    }
    if (source_length != 0 && fread(source, 1U, source_length, file) != source_length) {
        int saved_errno = ferror(file) ? errno : 0;
        free(source);
        (void)fclose(file);
        set_error(err, err_cap, "cannot read '%s'%s%s", path,
                  saved_errno != 0 ? ": " : "",
                  saved_errno != 0 ? strerror(saved_errno) : "");
        return -1;
    }
    if (fclose(file) != 0) {
        int saved_errno = errno;
        free(source);
        set_error(err, err_cap, "cannot close '%s': %s", path,
                  strerror(saved_errno));
        return -1;
    }
    source[source_length] = '\0';
    result = assemble_source(source, code_out, length_out, err, err_cap);
    free(source);
    return result;
}
 
void asm_free(uint8_t *code) {
    free(code);
}
 
769 linesc
Delegates wait_agent
Files at this step
drag the rail to scrub
Discussion

No comments yet. Start the discussion. Recorded by @patrick-toulme.
#c #codex #gpt #gpt-5.6-terra #quick #subagents #testing
v2-codex
← all sessions