fix: advance r15, even when the pipeline is reloaded from the scheduler

The PC would fall behind whenever an IRQ was called because the pipeline
was reloaded (+8 to PC), however that was never actually done by any code

Now, the PC is always incremented when the pipeline is reloaded

src/Gui.zig

@@ -53,11 +53,11 @@ pub fn init(title: [12]u8, width: i32, height: i32) Self {
     };
 }
 
-pub fn run(self: *Self, arm7tdmi: *Arm7tdmi, scheduler: *Scheduler) !void {
+pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
     var quit = std.atomic.Atomic(bool).init(false);
     var frame_rate = FpsTracker.init();
 
-    const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, &frame_rate, scheduler, arm7tdmi });
+    const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, &frame_rate, scheduler, cpu });
     defer thread.join();
 
     var title_buf: [0x100]u8 = [_]u8{0} ** 0x100;
@@ -68,7 +68,7 @@ pub fn run(self: *Self, arm7tdmi: *Arm7tdmi, scheduler: *Scheduler) !void {
             switch (event.type) {
                 SDL.SDL_QUIT => break :emu_loop,
                 SDL.SDL_KEYDOWN => {
-                    const io = &arm7tdmi.bus.io;
+                    const io = &cpu.bus.io;
                     const key_code = event.key.keysym.sym;
 
                     switch (key_code) {
@@ -86,7 +86,7 @@ pub fn run(self: *Self, arm7tdmi: *Arm7tdmi, scheduler: *Scheduler) !void {
                     }
                 },
                 SDL.SDL_KEYUP => {
-                    const io = &arm7tdmi.bus.io;
+                    const io = &cpu.bus.io;
                     const key_code = event.key.keysym.sym;
 
                     switch (key_code) {
@@ -100,12 +100,12 @@ pub fn run(self: *Self, arm7tdmi: *Arm7tdmi, scheduler: *Scheduler) !void {
                         SDL.SDLK_s => io.keyinput.shoulder_r.set(),
                         SDL.SDLK_RETURN => io.keyinput.start.set(),
                         SDL.SDLK_RSHIFT => io.keyinput.select.set(),
-                        SDL.SDLK_i => log.err("Sample Count: {}", .{@intCast(u32, SDL.SDL_AudioStreamAvailable(arm7tdmi.bus.apu.stream)) / (2 * @sizeOf(u16))}),
+                        SDL.SDLK_i => log.err("Sample Count: {}", .{@intCast(u32, SDL.SDL_AudioStreamAvailable(cpu.bus.apu.stream)) / (2 * @sizeOf(u16))}),
                         SDL.SDLK_j => log.err("Scheduler Capacity: {} | Scheduler Event Count: {}", .{ scheduler.queue.capacity(), scheduler.queue.count() }),
                         SDL.SDLK_k => {
                             // Dump IWRAM to file
-                            log.info("PC: 0x{X:0>8}", .{arm7tdmi.r[15]});
+                            log.info("PC: 0x{X:0>8}", .{cpu.r[15]});
-                            log.info("LR: 0x{X:0>8}", .{arm7tdmi.r[14]});
+                            log.info("LR: 0x{X:0>8}", .{cpu.r[14]});
                             // const iwram_file = try std.fs.cwd().createFile("iwram.bin", .{});
                             // defer iwram_file.close();
 
@@ -119,7 +119,7 @@ pub fn run(self: *Self, arm7tdmi: *Arm7tdmi, scheduler: *Scheduler) !void {
         }
 
         // Emulator has an internal Double Buffer
-        const framebuf = arm7tdmi.bus.ppu.framebuf.get(.Renderer);
+        const framebuf = cpu.bus.ppu.framebuf.get(.Renderer);
         _ = SDL.SDL_UpdateTexture(self.texture, null, framebuf.ptr, pitch);
         _ = SDL.SDL_RenderCopy(self.renderer, self.texture, null, null);
         SDL.SDL_RenderPresent(self.renderer);
@@ -136,12 +136,13 @@ pub fn initAudio(self: *Self, apu: *Apu) void {
     self.audio.?.play();
 }
 
-pub fn deinit(self: Self) void {
+pub fn deinit(self: *Self) void {
-    if (self.audio) |aud| aud.deinit();
+    if (self.audio) |*aud| aud.deinit();
     SDL.SDL_DestroyTexture(self.texture);
     SDL.SDL_DestroyRenderer(self.renderer);
     SDL.SDL_DestroyWindow(self.window);
     SDL.SDL_Quit();
+    self.* = undefined;
 }
 
 const Audio = struct {
@@ -168,12 +169,13 @@ const Audio = struct {
         };
     }
 
-    fn deinit(this: This) void {
+    fn deinit(self: *This) void {
-        SDL.SDL_CloseAudioDevice(this.device);
+        SDL.SDL_CloseAudioDevice(self.device);
+        self.* = undefined;
     }
 
-    pub fn play(this: *This) void {
+    pub fn play(self: *This) void {
-        SDL.SDL_PauseAudioDevice(this.device, 0);
+        SDL.SDL_PauseAudioDevice(self.device, 0);
     }
 
     export fn callback(userdata: ?*anyopaque, stream: [*c]u8, len: c_int) void {

src/core/Bus.zig

@@ -49,32 +49,29 @@ io: Io,
 cpu: ?*Arm7tdmi,
 sched: *Scheduler,
 
-pub fn init(alloc: Allocator, sched: *Scheduler, paths: FilePaths) !Self {
+pub fn init(self: *Self, allocator: Allocator, sched: *Scheduler, cpu: *Arm7tdmi, paths: FilePaths) !void {
-    return Self{
+    self.* = .{
-        .pak = try GamePak.init(alloc, paths.rom, paths.save),
+        .pak = try GamePak.init(allocator, paths.rom, paths.save),
-        .bios = try Bios.init(alloc, paths.bios),
+        .bios = try Bios.init(allocator, paths.bios),
-        .ppu = try Ppu.init(alloc, sched),
+        .ppu = try Ppu.init(allocator, sched),
         .apu = Apu.init(sched),
-        .iwram = try Iwram.init(alloc),
+        .iwram = try Iwram.init(allocator),
-        .ewram = try Ewram.init(alloc),
+        .ewram = try Ewram.init(allocator),
         .dma = createDmaTuple(),
         .tim = createTimerTuple(sched),
         .io = Io.init(),
-        .cpu = null,
+        .cpu = cpu,
         .sched = sched,
     };
 }
 
-pub fn deinit(self: Self) void {
+pub fn deinit(self: *Self) void {
     self.iwram.deinit();
     self.ewram.deinit();
     self.pak.deinit();
     self.bios.deinit();
     self.ppu.deinit();
-}
+    self.* = undefined;
-
-pub fn attach(self: *Self, cpu: *Arm7tdmi) void {
-    self.cpu = cpu;
 }
 
 pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T {

src/core/apu.zig

@@ -444,29 +444,29 @@ const ToneSweep = struct {
             };
         }
 
-        pub fn tick(this: *This, ch1: *Self) void {
+        pub fn tick(self: *This, ch1: *Self) void {
-            if (this.timer != 0) this.timer -= 1;
+            if (self.timer != 0) self.timer -= 1;
 
-            if (this.timer == 0) {
+            if (self.timer == 0) {
                 const period = ch1.sweep.period.read();
-                this.timer = if (period == 0) 8 else period;
+                self.timer = if (period == 0) 8 else period;
-                if (!this.calc_performed) this.calc_performed = true;
+                if (!self.calc_performed) self.calc_performed = true;
 
-                if (this.enabled and period != 0) {
+                if (self.enabled and period != 0) {
-                    const new_freq = this.calcFrequency(ch1);
+                    const new_freq = self.calcFrequency(ch1);
 
                     if (new_freq <= 0x7FF and ch1.sweep.shift.read() != 0) {
                         ch1.freq.frequency.write(@truncate(u11, new_freq));
-                        this.shadow = @truncate(u11, new_freq);
+                        self.shadow = @truncate(u11, new_freq);
 
-                        _ = this.calcFrequency(ch1);
+                        _ = self.calcFrequency(ch1);
                     }
                 }
             }
         }
 
-        fn calcFrequency(this: *This, ch1: *Self) u12 {
+        fn calcFrequency(self: *This, ch1: *Self) u12 {
-            const shadow = @as(u12, this.shadow);
+            const shadow = @as(u12, self.shadow);
             const shadow_shifted = shadow >> ch1.sweep.shift.read();
             const decrease = ch1.sweep.direction.read();
 

src/core/bus/Bios.zig

@@ -8,27 +8,28 @@ pub const size = 0x4000;
 const Self = @This();
 
 buf: ?[]u8,
-alloc: Allocator,
+allocator: Allocator,
 
 addr_latch: u32,
 
-pub fn init(alloc: Allocator, maybe_path: ?[]const u8) !Self {
+pub fn init(allocator: Allocator, maybe_path: ?[]const u8) !Self {
     const buf: ?[]u8 = if (maybe_path) |path| blk: {
         const file = try std.fs.cwd().openFile(path, .{});
         defer file.close();
 
-        break :blk try file.readToEndAlloc(alloc, try file.getEndPos());
+        break :blk try file.readToEndAlloc(allocator, try file.getEndPos());
     } else null;
 
     return Self{
         .buf = buf,
-        .alloc = alloc,
+        .allocator = allocator,
         .addr_latch = 0,
     };
 }
 
-pub fn deinit(self: Self) void {
+pub fn deinit(self: *Self) void {
-    if (self.buf) |buf| self.alloc.free(buf);
+    if (self.buf) |buf| self.allocator.free(buf);
+    self.* = undefined;
 }
 
 pub fn read(self: *Self, comptime T: type, r15: u32, addr: u32) T {

src/core/bus/Ewram.zig

@@ -5,20 +5,21 @@ const ewram_size = 0x40000;
 const Self = @This();
 
 buf: []u8,
-alloc: Allocator,
+allocator: Allocator,
 
-pub fn init(alloc: Allocator) !Self {
+pub fn init(allocator: Allocator) !Self {
-    const buf = try alloc.alloc(u8, ewram_size);
+    const buf = try allocator.alloc(u8, ewram_size);
     std.mem.set(u8, buf, 0);
 
     return Self{
         .buf = buf,
-        .alloc = alloc,
+        .allocator = allocator,
     };
 }
 
-pub fn deinit(self: Self) void {
+pub fn deinit(self: *Self) void {
-    self.alloc.free(self.buf);
+    self.allocator.free(self.buf);
+    self.* = undefined;
 }
 
 pub fn read(self: *const Self, comptime T: type, address: usize) T {

src/core/bus/GamePak.zig

@@ -8,22 +8,22 @@ const Self = @This();
 
 title: [12]u8,
 buf: []u8,
-alloc: Allocator,
+allocator: Allocator,
 backup: Backup,
 
-pub fn init(alloc: Allocator, rom_path: []const u8, save_path: ?[]const u8) !Self {
+pub fn init(allocator: Allocator, rom_path: []const u8, save_path: ?[]const u8) !Self {
     const file = try std.fs.cwd().openFile(rom_path, .{});
     defer file.close();
 
-    const file_buf = try file.readToEndAlloc(alloc, try file.getEndPos());
+    const file_buf = try file.readToEndAlloc(allocator, try file.getEndPos());
     const title = parseTitle(file_buf);
     const kind = Backup.guessKind(file_buf) orelse .None;
 
     const pak = Self{
         .buf = file_buf,
-        .alloc = alloc,
+        .allocator = allocator,
         .title = title,
-        .backup = try Backup.init(alloc, kind, title, save_path),
+        .backup = try Backup.init(allocator, kind, title, save_path),
     };
     pak.parseHeader();
 
@@ -58,9 +58,10 @@ inline fn isLarge(self: *const Self) bool {
     return self.buf.len > 0x100_0000;
 }
 
-pub fn deinit(self: Self) void {
+pub fn deinit(self: *Self) void {
-    self.alloc.free(self.buf);
     self.backup.deinit();
+    self.allocator.free(self.buf);
+    self.* = undefined;
 }
 
 pub fn read(self: *Self, comptime T: type, address: u32) T {

src/core/bus/Iwram.zig

@@ -5,20 +5,21 @@ const iwram_size = 0x8000;
 const Self = @This();
 
 buf: []u8,
-alloc: Allocator,
+allocator: Allocator,
 
-pub fn init(alloc: Allocator) !Self {
+pub fn init(allocator: Allocator) !Self {
-    const buf = try alloc.alloc(u8, iwram_size);
+    const buf = try allocator.alloc(u8, iwram_size);
     std.mem.set(u8, buf, 0);
 
     return Self{
         .buf = buf,
-        .alloc = alloc,
+        .allocator = allocator,
     };
 }
 
-pub fn deinit(self: Self) void {
+pub fn deinit(self: *Self) void {
-    self.alloc.free(self.buf);
+    self.allocator.free(self.buf);
+    self.* = undefined;
 }
 
 pub fn read(self: *const Self, comptime T: type, address: usize) T {

src/core/bus/backup.zig

@@ -17,7 +17,7 @@ pub const Backup = struct {
     const Self = @This();
 
     buf: []u8,
-    alloc: Allocator,
+    allocator: Allocator,
     kind: Kind,
 
     title: [12]u8,
@@ -49,7 +49,7 @@ pub const Backup = struct {
 
         var backup = Self{
             .buf = buf,
-            .alloc = allocator,
+            .allocator = allocator,
             .kind = kind,
             .title = title,
             .save_path = path,
@@ -74,9 +74,10 @@ pub const Backup = struct {
         return null;
     }
 
-    pub fn deinit(self: Self) void {
+    pub fn deinit(self: *Self) void {
-        if (self.save_path) |path| self.writeSaveToDisk(self.alloc, path) catch |e| log.err("Failed to write save: {}", .{e});
+        if (self.save_path) |path| self.writeSaveToDisk(self.allocator, path) catch |e| log.err("Failed to write save: {}", .{e});
-        self.alloc.free(self.buf);
+        self.allocator.free(self.buf);
+        self.* = undefined;
     }
 
     fn loadSaveFromDisk(self: *Self, allocator: Allocator, path: []const u8) !void {
@@ -309,7 +310,7 @@ const Eeprom = struct {
     writer: Writer,
     reader: Reader,
 
-    alloc: Allocator,
+    allocator: Allocator,
 
     const Kind = enum {
         Unknown,
@@ -325,14 +326,14 @@ const Eeprom = struct {
         RequestEnd,
     };
 
-    fn init(alloc: Allocator) Self {
+    fn init(allocator: Allocator) Self {
         return .{
             .kind = .Unknown,
             .state = .Ready,
             .writer = Writer.init(),
             .reader = Reader.init(),
             .addr = 0,
-            .alloc = alloc,
+            .allocator = allocator,
         };
     }
 
@@ -360,7 +361,7 @@ const Eeprom = struct {
                     else => unreachable,
                 };
 
-                buf.* = self.alloc.alloc(u8, len) catch |e| {
+                buf.* = self.allocator.alloc(u8, len) catch |e| {
                     log.err("Failed to resize EEPROM buf to {} bytes", .{len});
                     std.debug.panic("EEPROM entered irrecoverable state {}", .{e});
                 };

src/core/cpu.zig

@@ -251,7 +251,7 @@ pub const Arm7tdmi = struct {
 
     logger: ?Logger,
 
-    pub fn init(sched: *Scheduler, bus: *Bus) Self {
+    pub fn init(sched: *Scheduler, bus: *Bus, log_file: ?std.fs.File) Self {
         return Self{
             .r = [_]u32{0x00} ** 16,
             .pipe = Pipline.init(),
@@ -262,14 +262,10 @@ pub const Arm7tdmi = struct {
             .banked_fiq = [_]u32{0x00} ** 10,
             .banked_r = [_]u32{0x00} ** 12,
             .banked_spsr = [_]PSR{.{ .raw = 0x0000_0000 }} ** 5,
-            .logger = null,
+            .logger = if (log_file) |file| Logger.init(file) else null,
         };
     }
 
-    pub fn attach(self: *Self, log_file: std.fs.File) void {
-        self.logger = Logger.init(log_file);
-    }
-
     inline fn bankedIdx(mode: Mode, kind: BankedKind) usize {
         const idx: usize = switch (mode) {
             .User, .System => 0,

src/core/ppu.zig

@@ -41,28 +41,25 @@ pub const Ppu = struct {
     oam: Oam,
     sched: *Scheduler,
     framebuf: FrameBuffer,
-    alloc: Allocator,
+    allocator: Allocator,
 
-    scanline_sprites: [128]?Sprite,
+    scanline_sprites: *[128]?Sprite,
     scanline: Scanline,
 
-    pub fn init(alloc: Allocator, sched: *Scheduler) !Self {
+    pub fn init(allocator: Allocator, sched: *Scheduler) !Self {
         // Queue first Hblank
         sched.push(.Draw, 240 * 4);
 
-        const framebufs = try alloc.alloc(u8, (framebuf_pitch * height) * 2);
+        const sprites = try allocator.create([128]?Sprite);
-        std.mem.set(u8, framebufs, 0);
+        sprites.* = [_]?Sprite{null} ** 128;
-
-        const scanline_buf = try alloc.alloc(?u16, width * 2);
-        std.mem.set(?u16, scanline_buf, null);
 
         return Self{
-            .vram = try Vram.init(alloc),
+            .vram = try Vram.init(allocator),
-            .palette = try Palette.init(alloc),
+            .palette = try Palette.init(allocator),
-            .oam = try Oam.init(alloc),
+            .oam = try Oam.init(allocator),
             .sched = sched,
-            .framebuf = FrameBuffer.init(framebufs),
+            .framebuf = try FrameBuffer.init(allocator),
-            .alloc = alloc,
+            .allocator = allocator,
 
             // Registers
             .win = Window.init(),
@@ -75,17 +72,19 @@ pub const Ppu = struct {
             .bldalpha = .{ .raw = 0x0000 },
             .bldy = .{ .raw = 0x0000 },
 
-            .scanline = Scanline.init(scanline_buf),
+            .scanline = try Scanline.init(allocator),
-            .scanline_sprites = [_]?Sprite{null} ** 128,
+            .scanline_sprites = sprites,
         };
     }
 
-    pub fn deinit(self: Self) void {
+    pub fn deinit(self: *Self) void {
-        self.framebuf.deinit(self.alloc);
+        self.allocator.destroy(self.scanline_sprites);
-        self.scanline.deinit(self.alloc);
+        self.framebuf.deinit();
+        self.scanline.deinit();
         self.vram.deinit();
         self.palette.deinit();
         self.oam.deinit();
+        self.* = undefined;
     }
 
     pub fn setBgOffsets(self: *Self, comptime n: u2, word: u32) void {
@@ -399,7 +398,7 @@ pub const Ppu = struct {
                 // Reset Current Scanline Pixel Buffer and list of fetched sprites
                 // in prep for next scanline
                 self.scanline.reset();
-                std.mem.set(?Sprite, &self.scanline_sprites, null);
+                std.mem.set(?Sprite, self.scanline_sprites, null);
             },
             0x1 => {
                 const fb_base = framebuf_pitch * @as(usize, scanline);
@@ -426,7 +425,7 @@ pub const Ppu = struct {
                 // Reset Current Scanline Pixel Buffer and list of fetched sprites
                 // in prep for next scanline
                 self.scanline.reset();
-                std.mem.set(?Sprite, &self.scanline_sprites, null);
+                std.mem.set(?Sprite, self.scanline_sprites, null);
             },
             0x2 => {
                 const fb_base = framebuf_pitch * @as(usize, scanline);
@@ -452,7 +451,7 @@ pub const Ppu = struct {
                 // Reset Current Scanline Pixel Buffer and list of fetched sprites
                 // in prep for next scanline
                 self.scanline.reset();
-                std.mem.set(?Sprite, &self.scanline_sprites, null);
+                std.mem.set(?Sprite, self.scanline_sprites, null);
             },
             0x3 => {
                 const vram_base = width * @sizeOf(u16) * @as(usize, scanline);
@@ -629,20 +628,21 @@ const Palette = struct {
     const Self = @This();
 
     buf: []u8,
-    alloc: Allocator,
+    allocator: Allocator,
 
-    fn init(alloc: Allocator) !Self {
+    fn init(allocator: Allocator) !Self {
-        const buf = try alloc.alloc(u8, palram_size);
+        const buf = try allocator.alloc(u8, palram_size);
         std.mem.set(u8, buf, 0);
 
         return Self{
             .buf = buf,
-            .alloc = alloc,
+            .allocator = allocator,
         };
     }
 
-    fn deinit(self: Self) void {
+    fn deinit(self: *Self) void {
-        self.alloc.free(self.buf);
+        self.allocator.free(self.buf);
+        self.* = undefined;
     }
 
     pub fn read(self: *const Self, comptime T: type, address: usize) T {
@@ -677,20 +677,21 @@ const Vram = struct {
     const Self = @This();
 
     buf: []u8,
-    alloc: Allocator,
+    allocator: Allocator,
 
-    fn init(alloc: Allocator) !Self {
+    fn init(allocator: Allocator) !Self {
-        const buf = try alloc.alloc(u8, vram_size);
+        const buf = try allocator.alloc(u8, vram_size);
         std.mem.set(u8, buf, 0);
 
         return Self{
             .buf = buf,
-            .alloc = alloc,
+            .allocator = allocator,
         };
     }
 
-    fn deinit(self: Self) void {
+    fn deinit(self: *Self) void {
-        self.alloc.free(self.buf);
+        self.allocator.free(self.buf);
+        self.* = undefined;
     }
 
     pub fn read(self: *const Self, comptime T: type, address: usize) T {
@@ -737,20 +738,21 @@ const Oam = struct {
     const Self = @This();
 
     buf: []u8,
-    alloc: Allocator,
+    allocator: Allocator,
 
-    fn init(alloc: Allocator) !Self {
+    fn init(allocator: Allocator) !Self {
-        const buf = try alloc.alloc(u8, oam_size);
+        const buf = try allocator.alloc(u8, oam_size);
         std.mem.set(u8, buf, 0);
 
         return Self{
             .buf = buf,
-            .alloc = alloc,
+            .allocator = allocator,
         };
     }
 
-    fn deinit(self: Self) void {
+    fn deinit(self: *Self) void {
-        self.alloc.free(self.buf);
+        self.allocator.free(self.buf);
+        self.* = undefined;
     }
 
     pub fn read(self: *const Self, comptime T: type, address: usize) T {
@@ -1213,35 +1215,38 @@ fn copyToSpriteBuffer(bldcnt: io.BldCnt, scanline: *Scanline, x: u9, bgr555: u16
 const Scanline = struct {
     const Self = @This();
 
-    buf: [2][]?u16,
+    layers: [2][]?u16,
-    original: []?u16,
+    buf: []?u16,
 
-    fn init(buf: []?u16) Self {
+    allocator: Allocator,
-        std.debug.assert(buf.len == width * 2);
 
-        const top_slice = buf[0..][0..width];
+    fn init(allocator: Allocator) !Self {
-        const btm_slice = buf[width..][0..width];
+        const buf = try allocator.alloc(?u16, width * 2); // Top & Bottom Scanline
+        std.mem.set(?u16, buf, null);
 
         return .{
-            .buf = [_][]?u16{ top_slice, btm_slice },
+            // Top & Bototm Layers
-            .original = buf,
+            .layers = [_][]?u16{ buf[0..][0..width], buf[width..][0..width] },
+            .buf = buf,
+            .allocator = allocator,
         };
     }
 
     fn reset(self: *Self) void {
-        std.mem.set(?u16, self.original, null);
+        std.mem.set(?u16, self.buf, null);
     }
 
-    fn deinit(self: Self, alloc: Allocator) void {
+    fn deinit(self: *Self) void {
-        alloc.free(self.original);
+        self.allocator.free(self.buf);
+        self.* = undefined;
     }
 
     fn top(self: *Self) []?u16 {
-        return self.buf[0];
+        return self.layers[0];
     }
 
     fn btm(self: *Self) []?u16 {
-        return self.buf[1];
+        return self.layers[1];
     }
 };
 
@@ -1249,31 +1254,36 @@ const Scanline = struct {
 const FrameBuffer = struct {
     const Self = @This();
 
-    buf: [2][]u8,
+    layers: [2][]u8,
-    original: []u8,
+    buf: []u8,
     current: u1,
 
+    allocator: Allocator,
+
     // TODO: Rename
     const Device = enum {
         Emulator,
         Renderer,
     };
 
-    pub fn init(bufs: []u8) Self {
+    pub fn init(allocator: Allocator) !Self {
-        std.debug.assert(bufs.len == framebuf_pitch * height * 2);
+        const framebuf_len = framebuf_pitch * height;
-
+        const buf = try allocator.alloc(u8, framebuf_len * 2);
-        const front = bufs[0 .. framebuf_pitch * height];
+        std.mem.set(u8, buf, 0);
-        const back = bufs[framebuf_pitch * height ..];
 
         return .{
-            .buf = [2][]u8{ front, back },
+            // Front and Back Framebuffers
-            .original = bufs,
+            .layers = [_][]u8{ buf[0..][0..framebuf_len], buf[framebuf_len..][0..framebuf_len] },
+            .buf = buf,
             .current = 0,
+
+            .allocator = allocator,
         };
     }
 
-    fn deinit(self: Self, alloc: Allocator) void {
+    fn deinit(self: *Self) void {
-        alloc.free(self.original);
+        self.allocator.free(self.buf);
+        self.* = undefined;
     }
 
     pub fn swap(self: *Self) void {
@@ -1281,6 +1291,6 @@ const FrameBuffer = struct {
     }
 
     pub fn get(self: *Self, comptime dev: Device) []u8 {
-        return self.buf[if (dev == .Emulator) self.current else ~self.current];
+        return self.layers[if (dev == .Emulator) self.current else ~self.current];
     }
 };

src/core/scheduler.zig

@@ -14,15 +14,16 @@ pub const Scheduler = struct {
     tick: u64,
     queue: PriorityQueue(Event, void, lessThan),
 
-    pub fn init(alloc: Allocator) Self {
+    pub fn init(allocator: Allocator) Self {
-        var sched = Self{ .tick = 0, .queue = PriorityQueue(Event, void, lessThan).init(alloc, {}) };
+        var sched = Self{ .tick = 0, .queue = PriorityQueue(Event, void, lessThan).init(allocator, {}) };
         sched.queue.add(.{ .kind = .HeatDeath, .tick = std.math.maxInt(u64) }) catch unreachable;
 
         return sched;
     }
 
-    pub fn deinit(self: Self) void {
+    pub fn deinit(self: *Self) void {
         self.queue.deinit();
+        self.* = undefined;
     }
 
     pub inline fn now(self: *const Self) u64 {

src/core/util.zig

@@ -130,45 +130,45 @@ pub const Logger = struct {
         try self.buf.flush(); // FIXME: On panics, whatever is in the buffer isn't written to file
     }
 
-    pub fn mgbaLog(self: *Self, arm7tdmi: *const Arm7tdmi, opcode: u32) void {
+    pub fn mgbaLog(self: *Self, cpu: *const Arm7tdmi, opcode: u32) void {
         const fmt_base = "{X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} cpsr: {X:0>8} | ";
         const thumb_fmt = fmt_base ++ "{X:0>4}:\n";
         const arm_fmt = fmt_base ++ "{X:0>8}:\n";
 
-        if (arm7tdmi.cpsr.t.read()) {
+        if (cpu.cpsr.t.read()) {
             if (opcode >> 11 == 0x1E) {
                 // Instruction 1 of a BL Opcode, print in ARM mode
-                const low = arm7tdmi.bus.dbgRead(u16, arm7tdmi.r[15]);
+                const low = cpu.bus.dbgRead(u16, cpu.r[15]);
                 const bl_opcode = @as(u32, opcode) << 16 | low;
 
-                self.print(arm_fmt, Self.fmtArgs(arm7tdmi, bl_opcode)) catch @panic("failed to write to log file");
+                self.print(arm_fmt, Self.fmtArgs(cpu, bl_opcode)) catch @panic("failed to write to log file");
             } else {
-                self.print(thumb_fmt, Self.fmtArgs(arm7tdmi, opcode)) catch @panic("failed to write to log file");
+                self.print(thumb_fmt, Self.fmtArgs(cpu, opcode)) catch @panic("failed to write to log file");
             }
         } else {
-            self.print(arm_fmt, Self.fmtArgs(arm7tdmi, opcode)) catch @panic("failed to write to log file");
+            self.print(arm_fmt, Self.fmtArgs(cpu, opcode)) catch @panic("failed to write to log file");
         }
     }
 
-    fn fmtArgs(arm7tdmi: *const Arm7tdmi, opcode: u32) FmtArgTuple {
+    fn fmtArgs(cpu: *const Arm7tdmi, opcode: u32) FmtArgTuple {
         return .{
-            arm7tdmi.r[0],
+            cpu.r[0],
-            arm7tdmi.r[1],
+            cpu.r[1],
-            arm7tdmi.r[2],
+            cpu.r[2],
-            arm7tdmi.r[3],
+            cpu.r[3],
-            arm7tdmi.r[4],
+            cpu.r[4],
-            arm7tdmi.r[5],
+            cpu.r[5],
-            arm7tdmi.r[6],
+            cpu.r[6],
-            arm7tdmi.r[7],
+            cpu.r[7],
-            arm7tdmi.r[8],
+            cpu.r[8],
-            arm7tdmi.r[9],
+            cpu.r[9],
-            arm7tdmi.r[10],
+            cpu.r[10],
-            arm7tdmi.r[11],
+            cpu.r[11],
-            arm7tdmi.r[12],
+            cpu.r[12],
-            arm7tdmi.r[13],
+            cpu.r[13],
-            arm7tdmi.r[14],
+            cpu.r[14],
-            arm7tdmi.r[15] - if (arm7tdmi.cpsr.t.read()) 2 else @as(u32, 4),
+            cpu.r[15] - if (cpu.cpsr.t.read()) 2 else @as(u32, 4),
-            arm7tdmi.cpsr.raw,
+            cpu.cpsr.raw,
             opcode,
         };
     }

src/main.zig

@@ -14,7 +14,7 @@ const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.CLI);
 const width = @import("core/ppu.zig").width;
 const height = @import("core/ppu.zig").height;
-const arm7tdmi_logging = @import("core/emu.zig").cpu_logging;
+const cpu_logging = @import("core/emu.zig").cpu_logging;
 pub const log_level = if (builtin.mode != .Debug) .info else std.log.default_level;
 
 // TODO: Reimpl Logging
@@ -40,27 +40,25 @@ pub fn main() anyerror!void {
     const paths = try handleArguments(allocator, &result);
     defer if (paths.save) |path| allocator.free(path);
 
+    const log_file: ?std.fs.File = if (cpu_logging) try std.fs.cwd().createFile("zba.log", .{}) else null;
+    defer if (log_file) |file| file.close();
+
     // TODO: Take Emulator Init Code out of main.zig
     var scheduler = Scheduler.init(allocator);
     defer scheduler.deinit();
 
-    var bus = try Bus.init(allocator, &scheduler, paths);
+    var bus: Bus = undefined;
+    var cpu = Arm7tdmi.init(&scheduler, &bus, log_file);
+    if (paths.bios == null) cpu.fastBoot();
+
+    try bus.init(allocator, &scheduler, &cpu, paths);
     defer bus.deinit();
 
-    var arm7tdmi = Arm7tdmi.init(&scheduler, &bus);
-
-    const log_file: ?std.fs.File = if (arm7tdmi_logging) try std.fs.cwd().createFile("zba.log", .{}) else null;
-    defer if (log_file) |file| file.close();
-
-    if (log_file) |file| arm7tdmi.attach(file);
-    bus.attach(&arm7tdmi); // TODO: Shrink Surface (only CPSR and  r15?)
-    if (paths.bios == null) arm7tdmi.fastBoot();
-
     var gui = Gui.init(bus.pak.title, width, height);
     gui.initAudio(&bus.apu);
     defer gui.deinit();
 
-    try gui.run(&arm7tdmi, &scheduler);
+    try gui.run(&cpu, &scheduler);
 }
 
 fn getSavePath(allocator: Allocator) !?[]const u8 {