Don't shoehorn Flash into MemorySpace interface

Author: Grazfather

sim/aviron/src/lib/Cpu.zig

@@ -65,7 +65,6 @@ eeprom: EEPROM,
 io: IO,
 data: memory.MemorySpace,
 io_space: memory.MemorySpace,
-prog: memory.MemorySpace,
 
 // State
 pc: u24 = 0,
@@ -283,14 +282,8 @@ fn shift_program_counter(cpu: *Cpu, by: i12) void {
 }
 
 fn fetch_code(cpu: *Cpu) u16 {
-    // Program space is byte-addressed; PC is word-addressed.
-    const base: usize = @intCast(@as(u32, cpu.pc) << 1);
-    const lo = cpu.prog.read8(base) catch @panic("fetch_code: unmapped program byte (lo)");
-    const hi = cpu.prog.read8(base + 1) catch @panic("fetch_code: unmapped program byte (hi)");
-    const value: u16 = switch (comptime builtin.cpu.arch.endian()) {
-        .little => (@as(u16, hi) << 8) | lo,
-        .big => (@as(u16, lo) << 8) | hi,
-    };
+    // Program memory is word-addressed; PC is in words.
+    const value: u16 = cpu.flash.read(@intCast(cpu.pc));
     cpu.pc +%= 1; // increment with wraparound
     cpu.pc &= @intFromEnum(cpu.code_model); // then wrap to lower bit size
     return value;

sim/aviron/src/lib/io.zig

@@ -62,35 +62,33 @@ pub const Flash = struct {
             const Self = @This();
 
             allocator: std.mem.Allocator,
-            data_words: []u16,
             data: []align(2) u8,
 
             pub fn init(allocator: std.mem.Allocator, size_bytes: usize) !Self {
                 if ((size_bytes & 1) != 0) return error.InvalidFlashSize;
-                const words = try allocator.alloc(u16, @divExact(size_bytes, 2));
-                @memset(words, 0);
-                const bytes: []align(2) u8 = std.mem.sliceAsBytes(words);
-                return .{ .allocator = allocator, .data_words = words, .data = bytes };
+                const bytes = try allocator.alignedAlloc(u8, std.mem.Alignment.fromByteUnits(2), size_bytes);
+                @memset(bytes, 0);
+                return .{ .allocator = allocator, .data = bytes };
             }
 
             pub fn deinit(self: *Self) void {
-                self.allocator.free(self.data_words);
+                self.allocator.free(self.data);
             }
 
             pub fn memory(self: *Self) Flash {
                 return Flash{
                     .ctx = self,
                     .vtable = &vtable,
-                    .size = self.data_words.len,
+                    .size = @intCast(@divExact(self.data.len, 2)),
                 };
             }
 
             pub const vtable = VTable{ .readFn = mem_read };
 
             fn mem_read(ctx: ?*anyopaque, addr: Address) u16 {
                 const mem: *Self = @ptrCast(@alignCast(ctx.?));
-                std.debug.assert(addr < @as(Address, @intCast(mem.data_words.len)));
-                return mem.data_words[addr];
+                std.debug.assert(addr < @as(Address, @intCast(@divExact(mem.data.len, 2))));
+                return std.mem.bytesAsSlice(u16, &mem.data)[addr];
             }
         };
     }

sim/aviron/src/lib/mcu.zig

@@ -40,20 +40,17 @@ pub const Config = struct {
 pub const Spaces = struct {
     data: memory.MemorySpace,
     io: memory.MemorySpace,
-    prog: memory.MemorySpace,
 
     pub fn deinit(self: *const Spaces, alloc: std.mem.Allocator) void {
         self.data.deinit(alloc);
         self.io.deinit(alloc);
-        self.prog.deinit(alloc);
     }
 };
 
 /// Build memory spaces (data, io, program) for the given MCU configuration.
 pub fn build_spaces(
     alloc: std.mem.Allocator,
     cfg: Config,
-    flash: *const io_mod.Flash,
     ram: *io_mod.RAM,
     io_mem: *io_mod.IO,
 ) !Spaces {
@@ -71,13 +68,7 @@ pub fn build_spaces(
     io_seg_buf[0] = .{ .at = 0, .size = io_size, .backend = memory.Backend.fromIO(io_mem) };
     const io_space = try memory.MemorySpace.init(alloc, io_seg_buf[0..]);
 
-    // Program space: byte-addressable view over Flash
-    var prog_seg_buf: [1]memory.Segment = undefined;
-    const prog_size: usize = flash.size * 2; // words → bytes
-    prog_seg_buf[0] = .{ .at = 0, .size = prog_size, .backend = memory.Backend.fromFlash(flash) };
-    const prog_space = try memory.MemorySpace.init(alloc, prog_seg_buf[0..]);
-
-    return .{ .data = data_space, .io = io_space, .prog = prog_space };
+    return .{ .data = data_space, .io = io_space };
 }
 
 pub const SpecialIoConfig = struct {

sim/aviron/src/lib/memory.zig

@@ -1,9 +1,8 @@
 const std = @import("std");
 const io = @import("io.zig");
 
-/// Unified byte-addressable backend interface for RAM, Flash, and IO.
+/// Unified byte-addressable backend interface for RAM and IO.
 /// - RAM: read/write bytes by index
-/// - Flash: read-only; byte reads derived from word-addressed storage
 /// - IO: read/write bytes with side effects; never exposes slices
 pub const Backend = struct {
     ctx: *anyopaque,
@@ -55,11 +54,6 @@ pub const Backend = struct {
         return .{ .ctx = ram, .vtable = &ram_vtable };
     }
 
-    /// Adapter for Flash backends (read-only, word-addressed internally)
-    pub fn fromFlash(flash: *const io.Flash) Backend {
-        return .{ .ctx = @constCast(flash), .vtable = &flash_vtable };
-    }
-
     /// Adapter for IO backends (read-write with side effects). Index is treated as IO address.
     pub fn fromIO(io_mem: *io.IO) Backend {
         return .{ .ctx = io_mem, .vtable = &io_vtable };
@@ -93,39 +87,6 @@ const ram_vtable = Backend.VTable{
     .slice_rw = &ram_slice_rw,
 };
 
-fn flash_read8(ctx: *anyopaque, idx: usize) Backend.ReadError!u8 {
-    const f: *const io.Flash = @ptrCast(@alignCast(ctx));
-    const word_index: io.Flash.Address = @intCast(idx >> 1);
-    const word: u16 = f.read(word_index);
-    return if ((idx & 1) == 0)
-        @as(u8, @intCast(word & 0x00FF))
-    else
-        @as(u8, @intCast((word >> 8) & 0x00FF));
-}
-
-fn flash_write8(_: *anyopaque, _: usize, _: u8) Backend.WriteError!void {
-    return error.ReadOnly;
-}
-
-fn flash_write_masked(_: *anyopaque, _: usize, _: u8, _: u8) Backend.WriteError!void {
-    return error.ReadOnly;
-}
-
-fn flash_slice_ro(_: *anyopaque) ?[]const u8 {
-    return null;
-}
-fn flash_slice_rw(_: *anyopaque) ?[]u8 {
-    return null;
-}
-
-const flash_vtable = Backend.VTable{
-    .read8 = &flash_read8,
-    .write8 = &flash_write8,
-    .write_masked = &flash_write_masked,
-    .slice_ro = &flash_slice_ro,
-    .slice_rw = &flash_slice_rw,
-};
-
 fn io_read8(ctx: *anyopaque, idx: usize) Backend.ReadError!u8 {
     const m: *io.IO = @ptrCast(@alignCast(ctx));
     return m.read(@intCast(idx));

sim/aviron/src/main.zig

@@ -51,7 +51,7 @@ pub fn main() !u8 {
     var io_mem = io.memory();
 
     // Build memory spaces via MCU helper
-    const spaces = try aviron.mcu.build_spaces(allocator, mcu_config, &flash_mem, &sram_mem, &io_mem);
+    const spaces = try aviron.mcu.build_spaces(allocator, mcu_config, &sram_mem, &io_mem);
     defer spaces.deinit(allocator);
 
     var cpu = aviron.Cpu{
@@ -64,7 +64,6 @@ pub fn main() !u8 {
         .io = io_mem,
         .data = spaces.data,
         .io_space = spaces.io,
-        .prog = spaces.prog,
 
         .code_model = mcu_config.code_model,
         .instruction_set = mcu_config.instruction_set,

sim/aviron/src/testrunner.zig

@@ -76,7 +76,7 @@ fn run_test(
     var io_mem = io.memory();
 
     // Build memory spaces via MCU helper
-    const spaces = try aviron.mcu.build_spaces(allocator, mcu_config, &flash_mem, &sram_mem, &io_mem);
+    const spaces = try aviron.mcu.build_spaces(allocator, mcu_config, &sram_mem, &io_mem);
     defer spaces.deinit(allocator);
 
     var cpu = aviron.Cpu{
@@ -89,7 +89,6 @@ fn run_test(
         .io = io_mem,
         .data = spaces.data,
         .io_space = spaces.io,
-        .prog = spaces.prog,
         .code_model = mcu_config.code_model,
         .sio = .{
             .ramp_x = mcu_config.special_io.ramp_x,