Write a bump allocator:

var heap_start: i64 = 500000;
var heap_ptr: i64 = 500000;
var heap_limit: i64 = 900000;

fn alloc(size: i64) i64 {
    var ptr: i64 = heap_ptr;
    heap_ptr += (size + 7) / 8 * 8;
    if (heap_ptr > heap_limit) { return 0; }
    return ptr;
}

That's it. alloc(100) returns 500000 and advances heap_ptr to 500104 (rounded up to a multiple of 8 for alignment). The next alloc(50) returns 500104 and advances to 500160. Each call gets a fresh, non-overlapping region.

The (size + 7) / 8 * 8 rounds up to 8-byte alignment. WAT's i64.load and i64.store require aligned addresses. Without rounding, alloc(3) followed by alloc(8) would place an i64 at a misaligned address.

Test:

    check(
        \\var heap_ptr: i64 = 500000;
        \\var heap_limit: i64 = 900000;
        \\fn alloc(size: i64) i64 {
        \\    var ptr: i64 = heap_ptr;
        \\    heap_ptr += (size + 7) / 8 * 8;
        \\    if (heap_ptr > heap_limit) { return 0; }
        \\    return ptr;
        \\}
        \\var a: i64 = alloc(100);
        \\var b: i64 = alloc(200);
        \\b - a
    , 104);  // 100 rounded up to 104 (next multiple of 8)

The bump allocator is fast (one addition per call), simple (six lines), and useful for programs that only allocate and never free -- compilers, for instance. Our self-hosted compiler could use this instead of pre-assigned addresses.

But it can't free. Memory only grows. For long-running programs, we need something better.