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 65 / 86
tests.cchange 1/3
#include "asm.h"
#include "vm.h"
 
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
enum {
    ERROR_TEXT_CAPACITY = 256,
    OUTPUT_CAPACITY = 8192
};
 
typedef struct OutputCapture {
    char text[OUTPUT_CAPACITY];
    size_t length;
} OutputCapture;
 
#define FAIL(...)                                                               \
    do {                                                                        \
        fprintf(stderr, "FAIL %s:%d: ", __func__, __LINE__);                  \
        fprintf(stderr, __VA_ARGS__);                                           \
        fputc('\n', stderr);                                                   \
        return 0;                                                               \
    } while (0)
 
#define CHECK(condition, ...)                                                   \
    do {                                                                        \
        if (!(condition)) {                                                     \
            FAIL(__VA_ARGS__);                                                  \
        }                                                                       \
    } while (0)
 
static int capture_value(void *user, int64_t value) {
    OutputCapture *capture = user;
    char line[64];
    int count;
 
    if (capture == NULL) {
        return -1;
    }
 
    count = snprintf(line, sizeof(line), "%" PRId64 "\n", value);
    if (count < 0 || (size_t)count >= sizeof(line) ||
        (size_t)count >= OUTPUT_CAPACITY - capture->length) {
        return -1;
    }
 
    memcpy(capture->text + capture->length, line, (size_t)count);
    capture->length += (size_t)count;
    capture->text[capture->length] = '\0';
    return 0;
}
 
static int reject_output(void *user, int64_t value) {
    (void)user;
    (void)value;
    return -1;
}
 
static size_t emit_opcode(uint8_t *code, size_t offset, VMOpcode opcode) {
    code[offset] = (uint8_t)opcode;
    return offset + VM_OPCODE_SIZE;
}
 
static size_t emit_operand_opcode(uint8_t *code, size_t offset, VMOpcode opcode,
                                  int32_t operand) {
    uint32_t bits = (uint32_t)operand;
 
    code[offset] = (uint8_t)opcode;
    code[offset + 1] = (uint8_t)(bits & UINT32_C(0xff));
    code[offset + 2] = (uint8_t)((bits >> 8) & UINT32_C(0xff));
    code[offset + 3] = (uint8_t)((bits >> 16) & UINT32_C(0xff));
    code[offset + 4] = (uint8_t)((bits >> 24) & UINT32_C(0xff));
    return offset + VM_OPCODE_SIZE + VM_OPERAND_SIZE;
}
 
static int execute_callback(const uint8_t *code, size_t code_length,
                            size_t max_stack, size_t max_call_frames,
                            VMOutputFn output, void *output_user,
                            VMError *result) {
    VM vm = {0};
 
    if (vm_init(&vm, max_stack, max_call_frames) != 0) {
        fprintf(stderr, "could not initialize VM: %s\n", vm_error_string(vm.error));
        vm_free(&vm);
        return 0;
    }
 
    *result = vm_run_callback(&vm, code, code_length, output, output_user);
    vm_free(&vm);
    return 1;
}
 
static int expect_vm_error(const char *case_name, const uint8_t *code,
                           size_t code_length, size_t max_stack,
                           size_t max_call_frames, VMError expected) {
    OutputCapture output = {{0}, 0};
    VMError actual;
 
    CHECK(execute_callback(code, code_length, max_stack, max_call_frames,
                           capture_value, &output, &actual),
          "%s: VM setup failed", case_name);
    CHECK(actual == expected, "%s: expected %s, got %s", case_name,
          vm_error_string(expected), vm_error_string(actual));
    CHECK(output.length == 0, "%s: error path unexpectedly printed \"%s\"",
          case_name, output.text);
    return 1;
}
 
static int assemble_source(const char *source, uint8_t **code,
                           size_t *code_length) {
    char error[ERROR_TEXT_CAPACITY] = {0};
 
    *code = NULL;
    *code_length = 0;
    if (asm_assemble(source, code, code_length, error, sizeof(error)) != 0) {
        fprintf(stderr, "assembly unexpectedly failed: %s\n", error);
        return 0;
    }
    return 1;
}
 
static int expect_assembled_vm_error(const char *case_name, const char *source,
                                     size_t max_stack, size_t max_call_frames,
                                     VMError expected) {
    uint8_t *code = NULL;
    size_t code_length = 0;
    int passed;
 
    CHECK(assemble_source(source, &code, &code_length),
          "%s: could not assemble test program", case_name);
    passed = expect_vm_error(case_name, code, code_length, max_stack,
                             max_call_frames, expected);
    asm_free(code);
    return passed;
}
 
static int run_source_and_expect_output(const char *case_name, const char *source,
                                        const char *expected_output) {
    uint8_t *code = NULL;
    size_t code_length = 0;
    OutputCapture output = {{0}, 0};
    VMError result;
    int passed = 0;
 
    if (!assemble_source(source, &code, &code_length)) {
        fprintf(stderr, "%s: could not assemble source\n", case_name);
        goto done;
    }
    if (!execute_callback(code, code_length, 0, 0, capture_value, &output,
                          &result)) {
        fprintf(stderr, "%s: VM setup failed\n", case_name);
        goto done;
    }
    if (result != VM_OK) {
        fprintf(stderr, "%s: execution failed: %s\n", case_name,
                vm_error_string(result));
        goto done;
    }
    if (strcmp(output.text, expected_output) != 0) {
        fprintf(stderr, "%s: expected output \"%s\", got \"%s\"\n", case_name,
                expected_output, output.text);
        goto done;
    }
    passed = 1;
 
done:
    asm_free(code);
    return passed;
}
 
static int test_examples(void) {
    static const struct {
        const char *path;
        const char *expected_output;
    } examples[] = {
        {"examples/fib.vasm", "6765\n"},
        {"examples/fact.vasm", "3628800\n"},
        {"examples/primes.vasm",
         "2\n3\n5\n7\n11\n13\n17\n19\n23\n29\n31\n37\n41\n43\n47\n"},
    };
    size_t index;
 
    for (index = 0; index < sizeof(examples) / sizeof(examples[0]); ++index) {
        uint8_t *code = NULL;
        size_t code_length = 0;
        char error[ERROR_TEXT_CAPACITY] = {0};
        OutputCapture output = {{0}, 0};
        VMError result;
 
        if (asm_assemble_file(examples[index].path, &code, &code_length, error,
                              sizeof(error)) != 0) {
            fprintf(stderr, "%s: assembly failed: %s\n", examples[index].path,
                    error);
            asm_free(code);
            return 0;
        }
        if (!execute_callback(code, code_length, 0, 0, capture_value, &output,
                              &result)) {
            fprintf(stderr, "%s: VM setup failed\n", examples[index].path);
            asm_free(code);
            return 0;
        }
        if (result != VM_OK) {
            fprintf(stderr, "%s: execution failed: %s\n", examples[index].path,
                    vm_error_string(result));
            asm_free(code);
            return 0;
        }
        if (strcmp(output.text, examples[index].expected_output) != 0) {
            fprintf(stderr, "%s: output mismatch\nexpected: %sactual:   %s",
                    examples[index].path, examples[index].expected_output,
                    output.text);
            asm_free(code);
            return 0;
        }
        asm_free(code);
    }
    return 1;
}
 
static int test_all_instruction_families(void) {
    static const char source[] =
        "entry: PUSH 9 # arithmetic and comparison\n"
        "PUSH 3\n"
        "DIV\n"
        "PUSH 3\n"
        "EQ\n"
        "JZ bad\n"
        "PUSH 4\n"
        "NEG\n"
        "PRINT\n"
        "PUSH 1\n"
        "PUSH 2\n"
        "SWAP\n"
        "SUB\n"
        "DUP\n"
        "PRINT\n"
        "POP\n"
        "HALT\n"
        "bad: PUSH 99\n"
        "PRINT\n"
        "HALT\n";
 
    return run_source_and_expect_output("instruction smoke test", source,
                                        "-4\n1\n");
}
 
static int test_file_output(void) {
    uint8_t code[VM_OPCODE_SIZE + VM_OPERAND_SIZE + VM_OPCODE_SIZE +
                 VM_OPCODE_SIZE];
    size_t length = 0;
    VM vm = {0};
    VMError result;
    FILE *output = NULL;
    char text[32] = {0};
    size_t count;
 
    length = emit_operand_opcode(code, length, VM_OP_PUSH, -7);
    length = emit_opcode(code, length, VM_OP_PRINT);
    length = emit_opcode(code, length, VM_OP_HALT);
    CHECK(length == sizeof(code), "internal bytecode size mismatch");
 
    output = tmpfile();
    CHECK(output != NULL, "tmpfile failed");
    CHECK(vm_init(&vm, 0, 0) == 0, "VM init failed: %s",
          vm_error_string(vm.error));
    result = vm_run(&vm, code, length, output);
    CHECK(result == VM_OK, "file output program failed: %s",
          vm_error_string(result));
    CHECK(fflush(output) == 0, "could not flush output");
    CHECK(fseek(output, 0, SEEK_SET) == 0, "could not rewind output");
    count = fread(text, 1, sizeof(text) - 1, output);
    CHECK(ferror(output) == 0, "could not read output");
    text[count] = '\0';
    CHECK(strcmp(text, "-7\n") == 0, "expected -7 output, got \"%s\"", text);
 
    fclose(output);
    vm_free(&vm);
    return 1;
}
 
static int test_vm_errors(void) {
    static const uint8_t bad_opcode[] = {UINT8_C(0xff)};
    static const uint8_t truncated_instruction[] = {VM_OP_PUSH, 0, 0, 0};
    uint8_t invalid_local[VM_OPCODE_SIZE + VM_OPERAND_SIZE + VM_OPCODE_SIZE];
    uint8_t output_failure[VM_OPCODE_SIZE + VM_OPERAND_SIZE + VM_OPCODE_SIZE +
                           VM_OPCODE_SIZE];
    size_t invalid_local_length = 0;
    size_t output_failure_length = 0;
    VMError actual;
 
    CHECK(expect_assembled_vm_error("operand stack underflow", "POP\nHALT\n", 0,
                                    0, VM_ERR_STACK_UNDERFLOW),
          "operand underflow test failed");
    CHECK(expect_assembled_vm_error("operand stack overflow",
                                    "PUSH 1\nPUSH 2\nHALT\n", 1, 0,
                                    VM_ERR_STACK_OVERFLOW),
          "operand overflow test failed");
    CHECK(expect_assembled_vm_error("division by zero",
                                    "PUSH 7\nPUSH 0\nDIV\nHALT\n", 0, 0,
                                    VM_ERR_DIVISION_BY_ZERO),
          "division by zero test failed");
    CHECK(expect_assembled_vm_error("modulo by zero",
                                    "PUSH 7\nPUSH 0\nMOD\nHALT\n", 0, 0,
                                    VM_ERR_DIVISION_BY_ZERO),
          "modulo by zero test failed");
    CHECK(expect_vm_error("bad opcode", bad_opcode, sizeof(bad_opcode), 0, 0,
                          VM_ERR_BAD_OPCODE),
          "bad opcode test failed");
    CHECK(expect_vm_error("truncated operand", truncated_instruction,
                          sizeof(truncated_instruction), 0, 0,
                          VM_ERR_TRUNCATED_INSTRUCTION),
          "truncated instruction test failed");
    CHECK(expect_assembled_vm_error("out-of-range jump", "JMP 1000000\n", 0,
                                    0, VM_ERR_INVALID_JUMP),
          "invalid jump test failed");
 
    invalid_local_length = emit_operand_opcode(invalid_local, invalid_local_length,
                                               VM_OP_LOAD,
                                               VM_LOCALS_PER_FRAME);
    invalid_local_length = emit_opcode(invalid_local, invalid_local_length,
                                       VM_OP_HALT);
    CHECK(expect_vm_error("invalid local", invalid_local, invalid_local_length, 0,
                          0, VM_ERR_INVALID_LOCAL),
          "invalid local test failed");
    CHECK(expect_assembled_vm_error("call stack overflow", "again: CALL again\n",
                                    0, 1, VM_ERR_CALL_STACK_OVERFLOW),
          "call stack overflow test failed");
    CHECK(expect_assembled_vm_error("return with no caller", "RET\n", 0, 0,
                                    VM_ERR_CALL_STACK_UNDERFLOW),
          "call stack underflow test failed");
    CHECK(expect_assembled_vm_error(
              "arithmetic overflow",
              "PUSH 2147483647\nPUSH 2147483647\nMUL\nPUSH 3\nMUL\nHALT\n",
              0, 0, VM_ERR_ARITHMETIC_OVERFLOW),
          "arithmetic overflow test failed");
    CHECK(expect_assembled_vm_error("missing HALT", "PUSH 1\n", 0, 0,
                                    VM_ERR_NO_HALT),
          "missing HALT test failed");
 
    output_failure_length = emit_operand_opcode(output_failure,
                                                output_failure_length, VM_OP_PUSH,
                                                1);
    output_failure_length = emit_opcode(output_failure, output_failure_length,
                                        VM_OP_PRINT);
    output_failure_length = emit_opcode(output_failure, output_failure_length,
                                        VM_OP_HALT);
    CHECK(execute_callback(output_failure, output_failure_length, 0, 0,
                           reject_output, NULL, &actual),
          "output failure: VM setup failed");
    CHECK(actual == VM_ERR_OUTPUT, "output callback failure: expected %s, got %s",
          vm_error_string(VM_ERR_OUTPUT), vm_error_string(actual));
    return 1;
}
 
static int test_assembler_rejections(void) {
    static const char *const invalid_sources[] = {
        "WOBBLE\n",
        "start: HALT\nstart: HALT\n",
        "JMP missing_label\n",
        "PUSH no_number\n",
        "LOAD 16\n",
        "label: PUSH label\n",
    };
    size_t index;
 
    for (index = 0; index < sizeof(invalid_sources) / sizeof(invalid_sources[0]);
         ++index) {
        uint8_t *code = (uint8_t *)(uintptr_t)UINTPTR_MAX;
        size_t code_length = 123;
        char error[ERROR_TEXT_CAPACITY] = {0};
        int result = asm_assemble(invalid_sources[index], &code, &code_length,
                                  error, sizeof(error));
 
        if (result != -1) {
            fprintf(stderr, "invalid assembly %zu unexpectedly succeeded\n", index);
            asm_free(code);
            return 0;
        }
        if (code != NULL || code_length != 0 || error[0] == '\0') {
            fprintf(stderr,
                    "invalid assembly %zu violated failure output contract\n",
                    index);
            return 0;
        }
    }
    return 1;
}
 
static int test_assembler_labels_comments_and_case(void) {
    static const char source[] =
        "jump_to_value: jMp value // skip this value\n"
        "PUSH 99\n"
        "value: PuSh 42 ; mnemonic case is irrelevant\n"
        "PrInT\n"
        "HaLt\n";
 
    return run_source_and_expect_output("assembler labels/comments/case", source,
                                        "42\n");
}
 
int main(void) {
    static const struct {
        const char *name;
        int (*function)(void);
    } tests[] = {
        {"examples", test_examples},
        {"instruction families", test_all_instruction_families},
        {"FILE output", test_file_output},
        {"VM errors", test_vm_errors},
        {"assembler rejections", test_assembler_rejections},
        {"assembler labels, comments, and case", test_assembler_labels_comments_and_case},
    };
    size_t index;
    size_t passed = 0;
 
    for (index = 0; index < sizeof(tests) / sizeof(tests[0]); ++index) {
        if (tests[index].function()) {
            ++passed;
            fprintf(stderr, "ok - %s\n", tests[index].name);
        } else {
            fprintf(stderr, "not ok - %s\n", tests[index].name);
        }
    }
 
    if (passed != sizeof(tests) / sizeof(tests[0])) {
        fprintf(stderr, "%zu/%zu tests passed\n", passed,
                sizeof(tests) / sizeof(tests[0]));
        return EXIT_FAILURE;
    }
 
    printf("%zu tests passed\n", passed);
    return EXIT_SUCCESS;
}
 
437 linesc
The test suite now covers exact example output, every instruction family, both output modes…
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