ci: ensure that submodules are updated recursively

Reviewed-on: #6

.github/workflows/main.yml

@@ -1,18 +1,24 @@
+name: Nightly
+
 on:
   push:
+    paths:
+      - "**.zig"
     branches:
       - main
   schedule:
     - cron: '0 0 * * *'
+  workflow_dispatch:
 
 jobs:
   build:
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        # os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest]
     runs-on: ${{matrix.os}}
     steps:
-      - uses: goto-bus-stop/setup-zig@v1
+      - uses: goto-bus-stop/setup-zig@v2
         with:
           version: master
       - name: prepare-linux
@@ -32,9 +38,9 @@ jobs:
             brew install sdl2
       - uses: actions/checkout@v3
         with:
-          submodules: true
+          submodules: recursive
       - name: build 
-        run: zig build -Drelease-safe
+        run: zig build -Doptimize=ReleaseSafe -Dcpu=baseline
       - name: upload
         uses: actions/upload-artifact@v3
         with:
@@ -45,8 +51,8 @@ jobs:
     steps: 
       - uses: actions/checkout@v3
         with:
-          submodules: true
+          submodules: recursive
-      - uses: goto-bus-stop/setup-zig@v1
+      - uses: goto-bus-stop/setup-zig@v2
         with:
           version: master
       - run: zig fmt src/**/*.zig

.gitmodules

@@ -13,3 +13,6 @@
 [submodule "lib/zig-toml"]
 	path = lib/zig-toml
 	url = https://github.com/aeronavery/zig-toml
+[submodule "lib/zba-gdbstub"]
+	path = lib/zba-gdbstub
+	url = https://git.musuka.dev/paoda/zba-gdbstub

.vscode/extensions.json

@@ -1,8 +0,0 @@
-{
-    "recommendations": [
-        "augusterame.zls-vscode",
-        "usernamehw.errorlens",
-        "vadimcn.vscode-lldb",
-        "dan-c-underwood.arm"
-    ]
-}

README.md

@@ -10,10 +10,10 @@ This is a simple (read: incomplete) for-fun long-term project. I hope to get "mo
 
 ### TODO
 
-- [ ] Affine Sprites
+- [x] Affine Sprites
 - [ ] Windowing (see [this branch](https://git.musuka.dev/paoda/zba/src/branch/window))
 - [ ] Audio Resampler (Having issues with SDL2's)
-- [ ] Immediate Mode GUI
+- [x] Immediate Mode GUI (see [this branch](https://git.musuka.dev/paoda/zba/src/branch/imgui))
 - [ ] Refactoring for easy-ish perf boosts
 
 ## Usage
@@ -28,31 +28,45 @@ Finally it's worth noting that ZBA uses a TOML config file it'll store in your O
 
 ## Tests
 
-- [x] [jsmolka's GBA Test Collection](https://github.com/jsmolka/gba-tests)
+GBA Tests | [jsmolka](https://github.com/jsmolka/)
-  - [x] `arm.gba` and `thumb.gba`
+--- | ---
-  - [x] `flash64.gba`, `flash128.gba`, `none.gba`, and `sram.gba`
+`arm.gba`,  `thumb.gba` | PASS
-  - [x] `hello.gba`, `shades.gba`, and `stripes.gba`
+`memory.gba`, `bios.gba` | PASS
-  - [x] `memory.gba`
+`flash64.gba`, `flash128.gba` | PASS
-  - [x] `bios.gba`
+`sram.gba` | PASS
-  - [x] `nes.gba`
+`none.gba` | PASS
-- [ ] [DenSinH's GBA ROMs](https://github.com/DenSinH/GBARoms)
+`hello.gba`, `shades.gba`, `stripes.gba` | PASS
-  - [x] `eeprom-test` and `flash-test`
+`nes.gba` | PASS
-  - [x] `midikey2freq`
+
-  - [ ] `swi-tests-random`
+GBARoms | [DenSinH](https://github.com/DenSinH/)
-- [ ] [destoer's GBA Tests](https://github.com/destoer/gba_tests)
+--- | ---
-  - [x] `cond_invalid.gba`
+`eeprom-test`, `flash-test` | PASS
-  - [x] `dma_priority.gba`
+`midikey2freq` | PASS
-  - [x] `hello_world.gba`
+`swi-tests-random` | FAIL
-  - [x] `if_ack.gba`
+
-  - [ ] `line_timing.gba`
+gba_tests | [destoer](https://github.com/destoer/)
-  - [ ] `lyc_midline.gba`
+--- | ---
-  - [ ] `window_midframe.gba`
+`cond_invalid.gba` | PASS
-- [x] [ladystarbreeze's GBA Test Collection](https://github.com/ladystarbreeze/GBA-Test-Collection)
+`dma_priority.gba` | PASS
-  - [x] `retAddr.gba`
+`hello_world.gba` | PASS
-  - [x] `helloWorld.gba`
+`if_ack.gba` | PASS
-  - [x] `helloAudio.gba`
+`line_timing.gba` | FAIL
-- [x] [`armwrestler-gba-fixed.gba`](https://github.com/destoer/armwrestler-gba-fixed)
+`lyc_midline.gba` | FAIL
-- [x] [FuzzARM](https://github.com/DenSinH/FuzzARM)
+`window_midframe.gba` | FAIL
+
+GBA Test Collection | [ladystarbreeze](https://github.com/ladystarbreeze)
+--- | ---
+`retAddr.gba` | PASS
+`helloWorld.gba` | PASS
+`helloAudio.gba` | PASS
+
+FuzzARM | [DenSinH](https://github.com/DenSinH/)
+--- | ---
+`main.gba` | PASS
+
+arm7wrestler GBA Fixed | [destoer](https://github.com/destoer)
+--- | ---
+`armwrestler-gba-fixed.gba` | PASS
 
 ## Resources
 
@@ -63,31 +77,31 @@ Finally it's worth noting that ZBA uses a TOML config file it'll store in your O
 
 ## Compiling
 
-Most recently built on Zig [v0.10.0](https://github.com/ziglang/zig/tree/0.10.0)
+Most recently built on Zig [v0.11.0-dev.1580+a5b34a61a](https://github.com/ziglang/zig/tree/a5b34a61a)
 
 ### Dependencies
 
-- [SDL.zig](https://github.com/MasterQ32/SDL.zig)
+Dependency | Source
-  - [SDL2](https://www.libsdl.org/download-2.0.php)
+--- | ---
-- [zig-clap](https://github.com/Hejsil/zig-clap)
+SDL.zig | <https://github.com/MasterQ32/SDL.zig>
-- [known-folders](https://github.com/ziglibs/known-folders)
+zig-clap | <https://github.com/Hejsil/zig-clap>
-- [zig-toml](https://github.com/aeronavery/zig-toml)
+known-folders | <https://github.com/ziglibs/known-folders>
-- [zig-datetime](https://github.com/frmdstryr/zig-datetime)
+zig-toml | <https://github.com/aeronavery/zig-toml>
-- [`bitfields.zig`](https://github.com/FlorenceOS/Florence/blob/aaa5a9e568/lib/util/bitfields.zig)
+zig-datetime | <https://github.com/frmdstryr/zig-datetime>
+`bitfields.zig` | [https://github.com/FlorenceOS/Florence](https://github.com/FlorenceOS/Florence/blob/aaa5a9e568/lib/util/bitfields.zig)
+`gl.zig` | <https://github.com/MasterQ32/zig-opengl>
 
-`bitfields.zig` from [FlorenceOS](https://github.com/FlorenceOS) is included under `lib/util/bitfield.zig`.
+Use `git submodule update --init` from the project root to pull the git relevant git submodules
-
-Use `git submodule update --init` from the project root to pull the git submodules `SDL.zig`, `zig-clap`, `known-folders`, `zig-toml` and `zig-datetime`
 
 Be sure to provide SDL2 using:
 
 - Linux: Your distro's package manager
-- MacOS: ¯\\\_(ツ)_/¯
+- macOS: ¯\\\_(ツ)_/¯ (try [this formula](https://formulae.brew.sh/formula/sdl2)?)
 - Windows: [`vcpkg`](https://github.com/Microsoft/vcpkg) (install `sdl2:x64-windows`)
 
 `SDL.zig` will provide a helpful compile error if the zig compiler is unable to find SDL2.
 
-Once you've got all the dependencies, execute `zig build -Drelease-fast`. The executable is located at `zig-out/bin/`.
+Once you've got all the dependencies, execute `zig build -Doptimize=ReleaseSafe`. The executable is located at `zig-out/bin/`.
 
 ## Controls
 

build.zig

@@ -1,46 +1,55 @@
 const std = @import("std");
+const builtin = @import("builtin");
+
 const Sdk = @import("lib/SDL.zig/Sdk.zig");
+const Gdbstub = @import("lib/zba-gdbstub/build.zig");
 
 pub fn build(b: *std.build.Builder) void {
-    // Standard target options allows the person running `zig build` to choose
+    // Minimum Zig Version
-    // what target to build for. Here we do not override the defaults, which
+    const min_ver = std.SemanticVersion.parse("0.11.0-dev.1580+a5b34a61a") catch return; // https://github.com/ziglang/zig/commit/a5b34a61a
-    // means any target is allowed, and the default is native. Other options
+    if (builtin.zig_version.order(min_ver).compare(.lt)) {
-    // for restricting supported target set are available.
+        std.log.err("{s}", .{b.fmt("Zig v{} does not meet the minimum version requirement. (Zig v{})", .{ builtin.zig_version, min_ver })});
+        std.os.exit(1);
+    }
+
     const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
 
-    // Standard release options allow the person running `zig build` to select
+    const exe = b.addExecutable(.{
-    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
+        .name = "zba",
-    const mode = b.standardReleaseOptions();
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
 
-    const exe = b.addExecutable("zba", "src/main.zig");
     exe.setMainPkgPath("."); // Necessary so that src/main.zig can embed example.toml
-    exe.setTarget(target);
 
     // Known Folders (%APPDATA%, XDG, etc.)
-    exe.addPackagePath("known_folders", "lib/known-folders/known-folders.zig");
+    exe.addAnonymousModule("known_folders", .{ .source_file = .{ .path = "lib/known-folders/known-folders.zig" } });
 
     // DateTime Library
-    exe.addPackagePath("datetime", "lib/zig-datetime/src/main.zig");
+    exe.addAnonymousModule("datetime", .{ .source_file = .{ .path = "lib/zig-datetime/src/main.zig" } });
 
     // Bitfield type from FlorenceOS: https://github.com/FlorenceOS/
-    // exe.addPackage(.{ .name = "bitfield", .path = .{ .path = "lib/util/bitfield.zig" } });
+    exe.addAnonymousModule("bitfield", .{ .source_file = .{ .path = "lib/util/bitfield.zig" } });
-    exe.addPackagePath("bitfield", "lib/util/bitfield.zig");
 
     // Argument Parsing Library
-    exe.addPackagePath("clap", "lib/zig-clap/clap.zig");
+    exe.addAnonymousModule("clap", .{ .source_file = .{ .path = "lib/zig-clap/clap.zig" } });
 
     // TOML Library
-    exe.addPackagePath("toml", "lib/zig-toml/src/toml.zig");
+    exe.addAnonymousModule("toml", .{ .source_file = .{ .path = "lib/zig-toml/src/toml.zig" } });
 
     // OpenGL 3.3 Bindings
-    exe.addPackagePath("gl", "lib/gl.zig");
+    exe.addAnonymousModule("gl", .{ .source_file = .{ .path = "lib/gl.zig" } });
+
+    // gdbstub
+    Gdbstub.link(exe);
 
     // Zig SDL Bindings: https://github.com/MasterQ32/SDL.zig
-    const sdk = Sdk.init(b);
+    const sdk = Sdk.init(b, null);
     sdk.link(exe, .dynamic);
-    exe.addPackage(sdk.getNativePackage("sdl2"));
+    exe.addModule("sdl2", sdk.getNativeModule());
 
-    exe.setBuildMode(mode);
     exe.install();
 
     const run_cmd = exe.run();
@@ -52,9 +61,11 @@ pub fn build(b: *std.build.Builder) void {
     const run_step = b.step("run", "Run the app");
     run_step.dependOn(&run_cmd.step);
 
-    const exe_tests = b.addTest("src/main.zig");
+    const exe_tests = b.addTest(.{
-    exe_tests.setTarget(target);
+        .root_source_file = .{ .path = "src/main.zig" },
-    exe_tests.setBuildMode(mode);
+        .target = target,
+        .optimize = optimize,
+    });
 
     const test_step = b.step("test", "Run unit tests");
     test_step.dependOn(&exe_tests.step);

src/config.zig

@@ -49,16 +49,19 @@ pub fn config() *const Config {
 }
 
 /// Reads a config file and then loads it into the global state
-pub fn load(allocator: Allocator, config_path: []const u8) !void {
+pub fn load(allocator: Allocator, file_path: []const u8) !void {
-    var config_file = try std.fs.cwd().openFile(config_path, .{});
+    var config_file = try std.fs.cwd().openFile(file_path, .{});
     defer config_file.close();
 
-    log.info("loaded from {s}", .{config_path});
+    log.info("loaded from {s}", .{file_path});
 
     const contents = try config_file.readToEndAlloc(allocator, try config_file.getEndPos());
     defer allocator.free(contents);
 
-    const table = try toml.parseContents(allocator, contents, null);
+    var parser = try toml.parseFile(allocator, file_path);
+    defer parser.deinit();
+
+    const table = try parser.parse();
     defer table.deinit();
 
     // TODO: Report unknown config options

src/core/Bus.zig

@@ -60,9 +60,8 @@ allocator: Allocator,
 pub fn init(self: *Self, allocator: Allocator, sched: *Scheduler, cpu: *Arm7tdmi, paths: FilePaths) !void {
     const tables = try allocator.alloc(?*anyopaque, 3 * table_len); // Allocate all tables
 
-    const read_table: *[table_len]?*const anyopaque = tables[0..table_len];
+    const read_table = tables[0..table_len];
-    const left_write: *[table_len]?*anyopaque = tables[table_len .. 2 * table_len];
+    const write_tables = .{ tables[table_len .. 2 * table_len], tables[2 * table_len .. 3 * table_len] };
-    const right_write: *[table_len]?*anyopaque = tables[2 * table_len .. 3 * table_len];
 
     self.* = .{
         .pak = try GamePak.init(allocator, cpu, paths.rom, paths.save),
@@ -78,18 +77,15 @@ pub fn init(self: *Self, allocator: Allocator, sched: *Scheduler, cpu: *Arm7tdmi
         .sched = sched,
 
         .read_table = read_table,
-        .write_tables = .{ left_write, right_write },
+        .write_tables = write_tables,
         .allocator = allocator,
     };
 
-    // read_table, write_tables, and *Self are not restricted to the lifetime
+    self.fillReadTable(read_table);
-    // of this init function so we can initialize our tables here
-    fillReadTable(self, read_table);
 
-    // Internal Display Memory behavious unusually on 8-bit reads
+    // Internal Display Memory behaves differently on 8-bit reads
-    // so we have two different tables depending on whether there's an 8-bit read or not
+    self.fillWriteTable(u32, write_tables[0]);
-    fillWriteTable(u32, self, left_write);
+    self.fillWriteTable(u8, write_tables[1]);
-    fillWriteTable(u8, self, right_write);
 }
 
 pub fn deinit(self: *Self) void {
@@ -102,54 +98,54 @@ pub fn deinit(self: *Self) void {
     // This is so I can deallocate the original `allocator.alloc`. I have to re-make the type
     // since I'm not keeping it around, This is very jank and bad though
     // FIXME: please figure out another way
-    self.allocator.free(@ptrCast([*]const ?*anyopaque, self.write_tables[0][0..])[0 .. 3 * table_len]);
+    self.allocator.free(@ptrCast([*]const ?*anyopaque, self.read_table[0..])[0 .. 3 * table_len]);
     self.* = undefined;
 }
 
-fn fillReadTable(bus: *Self, table: *[table_len]?*const anyopaque) void {
+fn fillReadTable(self: *Self, table: *[table_len]?*const anyopaque) void {
     const vramMirror = @import("ppu/Vram.zig").mirror;
 
-    for (table) |*ptr, i| {
+    for (table, 0..) |*ptr, i| {
-        const addr = page_size * i;
+        const addr = @intCast(u32, page_size * i);
 
         ptr.* = switch (addr) {
             // General Internal Memory
             0x0000_0000...0x0000_3FFF => null, // BIOS has it's own checks
-            0x0200_0000...0x02FF_FFFF => &bus.ewram.buf[addr & 0x3FFFF],
+            0x0200_0000...0x02FF_FFFF => &self.ewram.buf[addr & 0x3FFFF],
-            0x0300_0000...0x03FF_FFFF => &bus.iwram.buf[addr & 0x7FFF],
+            0x0300_0000...0x03FF_FFFF => &self.iwram.buf[addr & 0x7FFF],
             0x0400_0000...0x0400_03FF => null, // I/O
 
             // Internal Display Memory
-            0x0500_0000...0x05FF_FFFF => &bus.ppu.palette.buf[addr & 0x3FF],
+            0x0500_0000...0x05FF_FFFF => &self.ppu.palette.buf[addr & 0x3FF],
-            0x0600_0000...0x06FF_FFFF => &bus.ppu.vram.buf[vramMirror(addr)],
+            0x0600_0000...0x06FF_FFFF => &self.ppu.vram.buf[vramMirror(addr)],
-            0x0700_0000...0x07FF_FFFF => &bus.ppu.oam.buf[addr & 0x3FF],
+            0x0700_0000...0x07FF_FFFF => &self.ppu.oam.buf[addr & 0x3FF],
 
             // External Memory (Game Pak)
-            0x0800_0000...0x0DFF_FFFF => fillTableExternalMemory(bus, addr),
+            0x0800_0000...0x0DFF_FFFF => self.fillReadTableExternal(addr),
             0x0E00_0000...0x0FFF_FFFF => null, // SRAM
             else => null,
         };
     }
 }
 
-fn fillWriteTable(comptime T: type, bus: *Self, table: *[table_len]?*const anyopaque) void {
+fn fillWriteTable(self: *Self, comptime T: type, table: *[table_len]?*const anyopaque) void {
     comptime std.debug.assert(T == u32 or T == u16 or T == u8);
     const vramMirror = @import("ppu/Vram.zig").mirror;
 
-    for (table) |*ptr, i| {
+    for (table, 0..) |*ptr, i| {
-        const addr = page_size * i;
+        const addr = @intCast(u32, page_size * i);
 
         ptr.* = switch (addr) {
             // General Internal Memory
             0x0000_0000...0x0000_3FFF => null, // BIOS has it's own checks
-            0x0200_0000...0x02FF_FFFF => &bus.ewram.buf[addr & 0x3FFFF],
+            0x0200_0000...0x02FF_FFFF => &self.ewram.buf[addr & 0x3FFFF],
-            0x0300_0000...0x03FF_FFFF => &bus.iwram.buf[addr & 0x7FFF],
+            0x0300_0000...0x03FF_FFFF => &self.iwram.buf[addr & 0x7FFF],
             0x0400_0000...0x0400_03FF => null, // I/O
 
             // Internal Display Memory
-            0x0500_0000...0x05FF_FFFF => if (T != u8) &bus.ppu.palette.buf[addr & 0x3FF] else null,
+            0x0500_0000...0x05FF_FFFF => if (T != u8) &self.ppu.palette.buf[addr & 0x3FF] else null,
-            0x0600_0000...0x06FF_FFFF => if (T != u8) &bus.ppu.vram.buf[vramMirror(addr)] else null,
+            0x0600_0000...0x06FF_FFFF => if (T != u8) &self.ppu.vram.buf[vramMirror(addr)] else null,
-            0x0700_0000...0x07FF_FFFF => if (T != u8) &bus.ppu.oam.buf[addr & 0x3FF] else null,
+            0x0700_0000...0x07FF_FFFF => if (T != u8) &self.ppu.oam.buf[addr & 0x3FF] else null,
 
             // External Memory (Game Pak)
             0x0800_0000...0x0DFF_FFFF => null, // ROM
@@ -159,24 +155,29 @@ fn fillWriteTable(comptime T: type, bus: *Self, table: *[table_len]?*const anyop
     }
 }
 
-fn fillTableExternalMemory(bus: *Self, addr: usize) ?*anyopaque {
+fn fillReadTableExternal(self: *Self, addr: u32) ?*anyopaque {
     // see `GamePak.zig` for more information about what conditions need to be true
     // so that a simple pointer dereference isn't possible
 
+    std.debug.assert(addr & @as(u32, page_size - 1) == 0); // addr is guaranteed to be page-aligned
+
     const start_addr = addr;
-    const end_addr = addr + page_size;
+    const end_addr = start_addr + page_size;
 
-    const gpio_data = start_addr <= 0x0800_00C4 and 0x0800_00C4 < end_addr;
+    {
-    const gpio_direction = start_addr <= 0x0800_00C6 and 0x0800_00C6 < end_addr;
+        const data = start_addr <= 0x0800_00C4 and 0x0800_00C4 < end_addr; // GPIO Data
-    const gpio_control = start_addr <= 0x0800_00C8 and 0x0800_00C8 < end_addr;
+        const direction = start_addr <= 0x0800_00C6 and 0x0800_00C6 < end_addr; // GPIO Direction
+        const control = start_addr <= 0x0800_00C8 and 0x0800_00C8 < end_addr; // GPIO Control
 
-    if (bus.pak.gpio.device.kind != .None and (gpio_data or gpio_direction or gpio_control)) {
+        const has_gpio = data or direction or control;
-        // We found a GPIO device, and this page a GPIO register. We want to handle this in slowmem
+        const gpio_kind = self.pak.gpio.device.kind;
-        return null;
+
+        // There is a GPIO Device, and the current page contains at least one memory-mapped GPIO register
+        if (gpio_kind != .None and has_gpio) return null;
     }
 
-    if (bus.pak.backup.kind == .Eeprom) {
+    if (self.pak.backup.kind == .Eeprom) {
-        if (bus.pak.buf.len > 0x100_000) {
+        if (self.pak.buf.len > 0x100_000) {
             // We are using a "large" EEPROM which means that if the below check is true
             // this page has an address that's reserved for the EEPROM and therefore must
             // be handled in slowmem
@@ -192,49 +193,9 @@ fn fillTableExternalMemory(bus: *Self, addr: usize) ?*anyopaque {
     // Finally, the GamePak has some unique behaviour for reads past the end of the ROM,
     // so those will be handled by slowmem as well
     const masked_addr = addr & 0x1FF_FFFF;
-    if (masked_addr >= bus.pak.buf.len) return null;
+    if (masked_addr >= self.pak.buf.len) return null;
 
-    return &bus.pak.buf[masked_addr];
+    return &self.pak.buf[masked_addr];
-}
-
-// TODO: Take advantage of fastmem here too?
-pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
-    const page = @truncate(u8, unaligned_address >> 24);
-    const address = forceAlign(T, unaligned_address);
-
-    return switch (page) {
-        // General Internal Memory
-        0x00 => blk: {
-            if (address < Bios.size)
-                break :blk self.bios.dbgRead(T, self.cpu.r[15], address);
-
-            break :blk self.openBus(T, address);
-        },
-        0x02 => self.ewram.read(T, address),
-        0x03 => self.iwram.read(T, address),
-        0x04 => self.readIo(T, address),
-
-        // Internal Display Memory
-        0x05 => self.ppu.palette.read(T, address),
-        0x06 => self.ppu.vram.read(T, address),
-        0x07 => self.ppu.oam.read(T, address),
-
-        // External Memory (Game Pak)
-        0x08...0x0D => self.pak.dbgRead(T, address),
-        0x0E...0x0F => blk: {
-            const value = self.pak.backup.read(unaligned_address);
-
-            const multiplier = switch (T) {
-                u32 => 0x01010101,
-                u16 => 0x0101,
-                u8 => 1,
-                else => @compileError("Backup: Unsupported read width"),
-            };
-
-            break :blk @as(T, value) * multiplier;
-        },
-        else => self.openBus(T, address),
-    };
 }
 
 fn readIo(self: *const Self, comptime T: type, address: u32) T {
@@ -311,13 +272,12 @@ pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
     self.sched.tick += timings[@boolToInt(T == u32)][@truncate(u4, unaligned_address >> 24)];
 
     // We're doing some serious out-of-bounds open-bus reads
-    if (page > table_len) return self.openBus(T, unaligned_address);
+    if (page >= table_len) return self.openBus(T, unaligned_address);
 
     if (self.read_table[page]) |some_ptr| {
         // We have a pointer to a page, cast the pointer to it's underlying type
         const Ptr = [*]const T;
-        const alignment = @alignOf(std.meta.Child(Ptr));
+        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
-        const ptr = @ptrCast(Ptr, @alignCast(alignment, some_ptr));
 
         // Note: We don't check array length, since we force align the
         // lower bits of the address as the GBA would
@@ -327,6 +287,27 @@ pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
     return self.slowRead(T, unaligned_address);
 }
 
+pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
+    const bits = @typeInfo(std.math.IntFittingRange(0, page_size - 1)).Int.bits;
+    const page = unaligned_address >> bits;
+    const offset = unaligned_address & (page_size - 1);
+
+    // We're doing some serious out-of-bounds open-bus reads
+    if (page >= table_len) return self.openBus(T, unaligned_address);
+
+    if (self.read_table[page]) |some_ptr| {
+        // We have a pointer to a page, cast the pointer to it's underlying type
+        const Ptr = [*]const T;
+        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
+
+        // Note: We don't check array length, since we force align the
+        // lower bits of the address as the GBA would
+        return ptr[forceAlign(T, offset) / @sizeOf(T)];
+    }
+
+    return self.dbgSlowRead(T, unaligned_address);
+}
+
 fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
     @setCold(true);
 
@@ -337,7 +318,7 @@ fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
         // General Internal Memory
         0x00 => blk: {
             if (address < Bios.size)
-                break :blk self.bios.read(T, self.cpu.r[15], address);
+                break :blk self.bios.read(T, self.cpu.r[15], unaligned_address);
 
             break :blk self.openBus(T, address);
         },
@@ -352,22 +333,52 @@ fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
 
         // External Memory (Game Pak)
         0x08...0x0D => self.pak.read(T, address),
-        0x0E...0x0F => blk: {
+        0x0E...0x0F => self.readBackup(T, unaligned_address),
-            const value = self.pak.backup.read(unaligned_address);
-
-            const multiplier = switch (T) {
-                u32 => 0x01010101,
-                u16 => 0x0101,
-                u8 => 1,
-                else => @compileError("Backup: Unsupported read width"),
-            };
-
-            break :blk @as(T, value) * multiplier;
-        },
         else => self.openBus(T, address),
     };
 }
 
+fn dbgSlowRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
+    const page = @truncate(u8, unaligned_address >> 24);
+    const address = forceAlign(T, unaligned_address);
+
+    return switch (page) {
+        // General Internal Memory
+        0x00 => blk: {
+            if (address < Bios.size)
+                break :blk self.bios.dbgRead(T, self.cpu.r[15], unaligned_address);
+
+            break :blk self.openBus(T, address);
+        },
+        0x02 => unreachable, // handled by fastmem
+        0x03 => unreachable, // handled by fastmem
+        0x04 => self.readIo(T, address),
+
+        // Internal Display Memory
+        0x05 => unreachable, // handled by fastmem
+        0x06 => unreachable, // handled by fastmem
+        0x07 => unreachable, // handled by fastmem
+
+        // External Memory (Game Pak)
+        0x08...0x0D => self.pak.dbgRead(T, address),
+        0x0E...0x0F => self.readBackup(T, unaligned_address),
+        else => self.openBus(T, address),
+    };
+}
+
+fn readBackup(self: *const Self, comptime T: type, unaligned_address: u32) T {
+    const value = self.pak.backup.read(unaligned_address);
+
+    const multiplier = switch (T) {
+        u32 => 0x01010101,
+        u16 => 0x0101,
+        u8 => 1,
+        else => @compileError("Backup: Unsupported read width"),
+    };
+
+    return @as(T, value) * multiplier;
+}
+
 pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
     const bits = @typeInfo(std.math.IntFittingRange(0, page_size - 1)).Int.bits;
     const page = unaligned_address >> bits;
@@ -377,13 +388,12 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
     self.sched.tick += timings[@boolToInt(T == u32)][@truncate(u4, unaligned_address >> 24)];
 
     // We're doing some serious out-of-bounds open-bus writes, they do nothing though
-    if (page > table_len) return;
+    if (page >= table_len) return;
 
     if (self.write_tables[@boolToInt(T == u8)][page]) |some_ptr| {
         // We have a pointer to a page, cast the pointer to it's underlying type
         const Ptr = [*]T;
-        const alignment = @alignOf(std.meta.Child(Ptr));
+        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
-        const ptr = @ptrCast(Ptr, @alignCast(alignment, some_ptr));
 
         // Note: We don't check array length, since we force align the
         // lower bits of the address as the GBA would
@@ -396,8 +406,34 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
     }
 }
 
-pub fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
+/// Mostly Identical to `Bus.write`, slowmeme is handled by `Bus.dbgSlowWrite`
-    // @setCold(true);
+pub fn dbgWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
+    const bits = @typeInfo(std.math.IntFittingRange(0, page_size - 1)).Int.bits;
+    const page = unaligned_address >> bits;
+    const offset = unaligned_address & (page_size - 1);
+
+    // We're doing some serious out-of-bounds open-bus writes, they do nothing though
+    if (page >= table_len) return;
+
+    if (self.write_tables[@boolToInt(T == u8)][page]) |some_ptr| {
+        // We have a pointer to a page, cast the pointer to it's underlying type
+        const Ptr = [*]T;
+        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
+
+        // Note: We don't check array length, since we force align the
+        // lower bits of the address as the GBA would
+        ptr[forceAlign(T, offset) / @sizeOf(T)] = value;
+    } else {
+        // we can return early if this is an 8-bit OAM write
+        if (T == u8 and @truncate(u8, unaligned_address >> 24) == 0x07) return;
+
+        self.dbgSlowWrite(T, unaligned_address, value);
+    }
+}
+
+fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
+    @setCold(true);
+
     const page = @truncate(u8, unaligned_address >> 24);
     const address = forceAlign(T, unaligned_address);
 
@@ -420,16 +456,41 @@ pub fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T
     }
 }
 
+fn dbgSlowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
+    @setCold(true);
+
+    const page = @truncate(u8, unaligned_address >> 24);
+    const address = forceAlign(T, unaligned_address);
+
+    switch (page) {
+        // General Internal Memory
+        0x00 => self.bios.write(T, address, value),
+        0x02 => unreachable, // completely handled by fastmem
+        0x03 => unreachable, // completely handled by fastmem
+        0x04 => return, // FIXME: Let debug writes mess with I/O
+
+        // Internal Display Memory
+        0x05 => self.ppu.palette.write(T, address, value),
+        0x06 => self.ppu.vram.write(T, self.ppu.dispcnt, address, value),
+        0x07 => unreachable, // completely handled by fastmem
+
+        // External Memory (Game Pak)
+        0x08...0x0D => return, // FIXME: Debug Write to Backup/GPIO w/out messing with state
+        0x0E...0x0F => return, // FIXME: Debug Write to Backup w/out messing with state
+        else => {},
+    }
+}
+
 inline fn rotateBy(comptime T: type, address: u32) u32 {
     return switch (T) {
         u32 => address & 3,
         u16 => address & 1,
         u8 => 0,
-        else => @compileError("Backup: Unsupported write width"),
+        else => @compileError("Unsupported write width"),
     };
 }
 
-inline fn forceAlign(comptime T: type, address: u32) u32 {
+pub inline fn forceAlign(comptime T: type, address: u32) u32 {
     return switch (T) {
         u32 => address & ~@as(u32, 3),
         u16 => address & ~@as(u32, 1),

src/core/apu.zig

@@ -108,106 +108,121 @@ pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
 pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
     const byte_addr = @truncate(u8, addr);
 
+    if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return;
+
     switch (T) {
-        u32 => switch (byte_addr) {
+        u32 => {
-            0x60 => apu.ch1.setSound1Cnt(value),
+            // 0x80 and 0x81 handled in setSoundCnt
-            0x64 => apu.ch1.setSound1CntX(&apu.fs, @truncate(u16, value)),
+            if (byte_addr < 0x80 and !apu.cnt.apu_enable.read()) return;
 
-            0x68 => apu.ch2.setSound2CntL(@truncate(u16, value)),
+            switch (byte_addr) {
-            0x6C => apu.ch2.setSound2CntH(&apu.fs, @truncate(u16, value)),
+                0x60 => apu.ch1.setSound1Cnt(value),
+                0x64 => apu.ch1.setSound1CntX(&apu.fs, @truncate(u16, value)),
 
-            0x70 => apu.ch3.setSound3Cnt(value),
+                0x68 => apu.ch2.setSound2CntL(@truncate(u16, value)),
-            0x74 => apu.ch3.setSound3CntX(&apu.fs, @truncate(u16, value)),
+                0x6C => apu.ch2.setSound2CntH(&apu.fs, @truncate(u16, value)),
 
-            0x78 => apu.ch4.setSound4CntL(@truncate(u16, value)),
+                0x70 => apu.ch3.setSound3Cnt(value),
-            0x7C => apu.ch4.setSound4CntH(&apu.fs, @truncate(u16, value)),
+                0x74 => apu.ch3.setSound3CntX(&apu.fs, @truncate(u16, value)),
 
-            0x80 => apu.setSoundCnt(value),
+                0x78 => apu.ch4.setSound4CntL(@truncate(u16, value)),
-            0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
+                0x7C => apu.ch4.setSound4CntH(&apu.fs, @truncate(u16, value)),
-            0x88 => apu.bias.raw = @truncate(u16, value),
-            0x8C => {},
 
-            0x90, 0x94, 0x98, 0x9C => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
+                0x80 => apu.setSoundCnt(value),
-            0xA0 => apu.chA.push(value), // FIFO_A
+                0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
-            0xA4 => apu.chB.push(value), // FIFO_B
+                0x88 => apu.bias.raw = @truncate(u16, value),
-            else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, addr }),
+                0x8C => {},
+
+                0x90, 0x94, 0x98, 0x9C => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
+                0xA0 => apu.chA.push(value), // FIFO_A
+                0xA4 => apu.chB.push(value), // FIFO_B
+                else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, addr }),
+            }
         },
-        u16 => switch (byte_addr) {
+        u16 => {
-            0x60 => apu.ch1.setSound1CntL(@truncate(u8, value)), // SOUND1CNT_L
+            if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return;
-            0x62 => apu.ch1.setSound1CntH(value),
-            0x64 => apu.ch1.setSound1CntX(&apu.fs, value),
-            0x66 => {},
 
-            0x68 => apu.ch2.setSound2CntL(value),
+            switch (byte_addr) {
-            0x6A => {},
+                0x60 => apu.ch1.setSound1CntL(@truncate(u8, value)), // SOUND1CNT_L
-            0x6C => apu.ch2.setSound2CntH(&apu.fs, value),
+                0x62 => apu.ch1.setSound1CntH(value),
-            0x6E => {},
+                0x64 => apu.ch1.setSound1CntX(&apu.fs, value),
+                0x66 => {},
 
-            0x70 => apu.ch3.setSound3CntL(@truncate(u8, value)),
+                0x68 => apu.ch2.setSound2CntL(value),
-            0x72 => apu.ch3.setSound3CntH(value),
+                0x6A => {},
-            0x74 => apu.ch3.setSound3CntX(&apu.fs, value),
+                0x6C => apu.ch2.setSound2CntH(&apu.fs, value),
-            0x76 => {},
+                0x6E => {},
 
-            0x78 => apu.ch4.setSound4CntL(value),
+                0x70 => apu.ch3.setSound3CntL(@truncate(u8, value)),
-            0x7A => {},
+                0x72 => apu.ch3.setSound3CntH(value),
-            0x7C => apu.ch4.setSound4CntH(&apu.fs, value),
+                0x74 => apu.ch3.setSound3CntX(&apu.fs, value),
-            0x7E => {},
+                0x76 => {},
 
-            0x80 => apu.setSoundCntL(value),
+                0x78 => apu.ch4.setSound4CntL(value),
-            0x82 => apu.setSoundCntH(value),
+                0x7A => {},
-            0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
+                0x7C => apu.ch4.setSound4CntH(&apu.fs, value),
-            0x86 => {},
+                0x7E => {},
-            0x88 => apu.bias.raw = value, // SOUNDBIAS
-            0x8A, 0x8C, 0x8E => {},
 
-            0x90, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
+                0x80 => apu.setSoundCntL(value),
-            0xA0, 0xA2 => log.err("Tried to write 0x{X:0>4}{} to FIFO_A", .{ value, T }),
+                0x82 => apu.setSoundCntH(value),
-            0xA4, 0xA6 => log.err("Tried to write 0x{X:0>4}{} to FIFO_B", .{ value, T }),
+                0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
-            else => util.io.write.undef(log, "Tried to write 0x{X:0>4}{} to 0x{X:0>8}", .{ value, T, addr }),
+                0x86 => {},
+                0x88 => apu.bias.raw = value, // SOUNDBIAS
+                0x8A, 0x8C, 0x8E => {},
+
+                0x90, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
+                0xA0, 0xA2 => log.err("Tried to write 0x{X:0>4}{} to FIFO_A", .{ value, T }),
+                0xA4, 0xA6 => log.err("Tried to write 0x{X:0>4}{} to FIFO_B", .{ value, T }),
+                else => util.io.write.undef(log, "Tried to write 0x{X:0>4}{} to 0x{X:0>8}", .{ value, T, addr }),
+            }
         },
-        u8 => switch (byte_addr) {
+        u8 => {
-            0x60 => apu.ch1.setSound1CntL(value),
+            if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return;
-            0x61 => {},
-            0x62 => apu.ch1.setNr11(value),
-            0x63 => apu.ch1.setNr12(value),
-            0x64 => apu.ch1.setNr13(value),
-            0x65 => apu.ch1.setNr14(&apu.fs, value),
-            0x66, 0x67 => {},
 
-            0x68 => apu.ch2.setNr21(value),
+            switch (byte_addr) {
-            0x69 => apu.ch2.setNr22(value),
+                0x60 => apu.ch1.setSound1CntL(value),
-            0x6A, 0x6B => {},
+                0x61 => {},
-            0x6C => apu.ch2.setNr23(value),
+                0x62 => apu.ch1.setNr11(value),
-            0x6D => apu.ch2.setNr24(&apu.fs, value),
+                0x63 => apu.ch1.setNr12(value),
-            0x6E, 0x6F => {},
+                0x64 => apu.ch1.setNr13(value),
+                0x65 => apu.ch1.setNr14(&apu.fs, value),
+                0x66, 0x67 => {},
 
-            0x70 => apu.ch3.setSound3CntL(value), // NR30
+                0x68 => apu.ch2.setNr21(value),
-            0x71 => {},
+                0x69 => apu.ch2.setNr22(value),
-            0x72 => apu.ch3.setNr31(value),
+                0x6A, 0x6B => {},
-            0x73 => apu.ch3.vol.raw = value, // NR32
+                0x6C => apu.ch2.setNr23(value),
-            0x74 => apu.ch3.setNr33(value),
+                0x6D => apu.ch2.setNr24(&apu.fs, value),
-            0x75 => apu.ch3.setNr34(&apu.fs, value),
+                0x6E, 0x6F => {},
-            0x76, 0x77 => {},
 
-            0x78 => apu.ch4.setNr41(value),
+                0x70 => apu.ch3.setSound3CntL(value), // NR30
-            0x79 => apu.ch4.setNr42(value),
+                0x71 => {},
-            0x7A, 0x7B => {},
+                0x72 => apu.ch3.setNr31(value),
-            0x7C => apu.ch4.poly.raw = value, // NR 43
+                0x73 => apu.ch3.vol.raw = value, // NR32
-            0x7D => apu.ch4.setNr44(&apu.fs, value),
+                0x74 => apu.ch3.setNr33(value),
-            0x7E, 0x7F => {},
+                0x75 => apu.ch3.setNr34(&apu.fs, value),
+                0x76, 0x77 => {},
 
-            0x80, 0x81 => apu.setSoundCntL(setHalf(u16, apu.psg_cnt.raw, byte_addr, value)),
+                0x78 => apu.ch4.setNr41(value),
-            0x82, 0x83 => apu.setSoundCntH(setHalf(u16, apu.dma_cnt.raw, byte_addr, value)),
+                0x79 => apu.ch4.setNr42(value),
-            0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
+                0x7A, 0x7B => {},
-            0x85 => {},
+                0x7C => apu.ch4.poly.raw = value, // NR 43
-            0x86, 0x87 => {},
+                0x7D => apu.ch4.setNr44(&apu.fs, value),
-            0x88, 0x89 => apu.bias.raw = setHalf(u16, apu.bias.raw, byte_addr, value), // SOUNDBIAS
+                0x7E, 0x7F => {},
-            0x8A...0x8F => {},
 
-            0x90...0x9F => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
+                0x80, 0x81 => apu.setSoundCntL(setHalf(u16, apu.psg_cnt.raw, byte_addr, value)),
-            0xA0...0xA3 => log.err("Tried to write 0x{X:0>2}{} to FIFO_A", .{ value, T }),
+                0x82, 0x83 => apu.setSoundCntH(setHalf(u16, apu.dma_cnt.raw, byte_addr, value)),
-            0xA4...0xA7 => log.err("Tried to write 0x{X:0>2}{} to FIFO_B", .{ value, T }),
+                0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
-            else => util.io.write.undef(log, "Tried to write 0x{X:0>2}{} to 0x{X:0>8}", .{ value, T, addr }),
+                0x85 => {},
+                0x86, 0x87 => {},
+                0x88, 0x89 => apu.bias.raw = setHalf(u16, apu.bias.raw, byte_addr, value), // SOUNDBIAS
+                0x8A...0x8F => {},
+
+                0x90...0x9F => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
+                0xA0...0xA3 => log.err("Tried to write 0x{X:0>2}{} to FIFO_A", .{ value, T }),
+                0xA4...0xA7 => log.err("Tried to write 0x{X:0>2}{} to FIFO_B", .{ value, T }),
+                else => util.io.write.undef(log, "Tried to write 0x{X:0>2}{} to 0x{X:0>8}", .{ value, T, addr }),
+            }
         },
         else => @compileError("APU: Unsupported write width"),
     }
@@ -275,15 +290,20 @@ pub const Apu = struct {
     }
 
     fn reset(self: *Self) void {
+        // All PSG Registers between 0x0400_0060..0x0400_0081 are zeroed
+        // 0x0400_0082 and 0x0400_0088 retain their values
         self.ch1.reset();
         self.ch2.reset();
         self.ch3.reset();
         self.ch4.reset();
+
+        // GBATEK says 4000060h..4000081h I take this to mean inclusive
+        self.psg_cnt.raw = 0x0000;
     }
 
     /// SOUNDCNT
     fn setSoundCnt(self: *Self, value: u32) void {
-        self.setSoundCntL(@truncate(u16, value));
+        if (self.cnt.apu_enable.read()) self.setSoundCntL(@truncate(u16, value));
         self.setSoundCntH(@truncate(u16, value >> 16));
     }
 
@@ -322,11 +342,14 @@ pub const Apu = struct {
             self.fs.step = 0; // Reset Frame Sequencer
 
             // Reset Square Wave Offsets
-            self.ch1.square.pos = 0;
+            self.ch1.square.reset();
-            self.ch2.square.pos = 0;
+            self.ch2.square.reset();
 
-            // Reset Wave Device Offsets
+            // Reset Wave
-            self.ch3.wave_dev.offset = 0;
+            self.ch3.wave_dev.reset();
+
+            // Rest Noise
+            self.ch4.lfsr.reset();
         } else {
             self.reset();
         }
@@ -395,8 +418,8 @@ pub const Apu = struct {
         right += if (self.dma_cnt.chB_right.read()) chB_sample else 0;
 
         // Add SOUNDBIAS
-        // FIXME: Is SOUNDBIAS 9-bit or 10-bit?
+        // FIXME: SOUNDBIAS is 10-bit but The waveform is centered around 0 if I treat it as 11-bit
-        const bias = @as(i16, self.bias.level.read()) << 1;
+        const bias = @as(i16, self.bias.level.read()) << 2;
         left += bias;
         right += bias;
 

src/core/apu/Noise.zig

@@ -49,10 +49,13 @@ pub fn init(sched: *Scheduler) Self {
 }
 
 pub fn reset(self: *Self) void {
-    self.len = 0;
+    self.len = 0; // NR41
-    self.envelope.raw = 0;
+    self.envelope.raw = 0; // NR42
-    self.poly.raw = 0;
+    self.poly.raw = 0; // NR43
-    self.cnt.raw = 0;
+    self.cnt.raw = 0; // NR44
+
+    self.len_dev.reset();
+    self.env_dev.reset();
 
     self.sample = 0;
     self.enabled = false;

src/core/apu/Tone.zig

@@ -43,9 +43,12 @@ pub fn init(sched: *Scheduler) Self {
 }
 
 pub fn reset(self: *Self) void {
-    self.duty.raw = 0;
+    self.duty.raw = 0; // NR21
-    self.envelope.raw = 0;
+    self.envelope.raw = 0; // NR22
-    self.freq.raw = 0;
+    self.freq.raw = 0; // NR32, NR24
+
+    self.len_dev.reset();
+    self.env_dev.reset();
 
     self.sample = 0;
     self.enabled = false;

src/core/apu/ToneSweep.zig

@@ -50,12 +50,14 @@ pub fn init(sched: *Scheduler) Self {
 }
 
 pub fn reset(self: *Self) void {
-    self.sweep.raw = 0;
+    self.sweep.raw = 0; // NR10
-    self.sweep_dev.calc_performed = false;
+    self.duty.raw = 0; // NR11
+    self.envelope.raw = 0; // NR12
+    self.freq.raw = 0; // NR13, NR14
 
-    self.duty.raw = 0;
+    self.len_dev.reset();
-    self.envelope.raw = 0;
+    self.sweep_dev.reset();
-    self.freq.raw = 0;
+    self.env_dev.reset();
 
     self.sample = 0;
     self.enabled = false;
@@ -92,10 +94,9 @@ pub fn sound1CntL(self: *const Self) u8 {
 pub fn setSound1CntL(self: *Self, value: u8) void {
     const new = io.Sweep{ .raw = value };
 
-    if (self.sweep.direction.read() and !new.direction.read()) {
+    if (!new.direction.read()) {
-        // Sweep Negate bit has been cleared
+        // If at least one (1) sweep calculation has been made with
-        // If At least 1 Sweep Calculation has been made since
+        // the negate bit set (since last trigger), disable the channel
-        // the last trigger, the channel is immediately disabled
 
         if (self.sweep_dev.calc_performed) self.enabled = false;
     }

src/core/apu/Wave.zig

@@ -42,10 +42,13 @@ pub fn init(sched: *Scheduler) Self {
 }
 
 pub fn reset(self: *Self) void {
-    self.select.raw = 0;
+    self.select.raw = 0; // NR30
-    self.length = 0;
+    self.length = 0; // NR31
-    self.vol.raw = 0;
+    self.vol.raw = 0; // NR32
-    self.freq.raw = 0;
+    self.freq.raw = 0; // NR33, NR34
+
+    self.len_dev.reset();
+    self.wave_dev.reset();
 
     self.sample = 0;
     self.enabled = false;

src/core/apu/device/Envelope.zig

@@ -11,6 +11,11 @@ pub fn create() Self {
     return .{ .timer = 0, .vol = 0 };
 }
 
+pub fn reset(self: *Self) void {
+    self.timer = 0;
+    self.vol = 0;
+}
+
 pub fn tick(self: *Self, nrx2: io.Envelope) void {
     if (nrx2.period.read() != 0) {
         if (self.timer != 0) self.timer -= 1;

src/core/apu/device/Length.zig

@@ -6,6 +6,10 @@ pub fn create() Self {
     return .{ .timer = 0 };
 }
 
+pub fn reset(self: *Self) void {
+    self.timer = 0;
+}
+
 pub fn tick(self: *Self, enabled: bool, ch_enable: *bool) void {
     if (enabled) {
         if (self.timer == 0) return;

src/core/apu/device/Sweep.zig

@@ -18,13 +18,19 @@ pub fn create() Self {
     };
 }
 
+pub fn reset(self: *Self) void {
+    self.timer = 0;
+    self.enabled = false;
+    self.shadow = 0;
+    self.calc_performed = false;
+}
+
 pub fn tick(self: *Self, ch1: *ToneSweep) void {
     if (self.timer != 0) self.timer -= 1;
 
     if (self.timer == 0) {
         const period = ch1.sweep.period.read();
         self.timer = if (period == 0) 8 else period;
-        if (!self.calc_performed) self.calc_performed = true;
 
         if (self.enabled and period != 0) {
             const new_freq = self.calculate(ch1.sweep, &ch1.enabled);
@@ -45,7 +51,10 @@ pub fn calculate(self: *Self, sweep: io.Sweep, ch_enable: *bool) u12 {
     const shadow_shifted = shadow >> sweep.shift.read();
     const decrease = sweep.direction.read();
 
-    const freq = if (decrease) shadow - shadow_shifted else shadow + shadow_shifted;
+    const freq = if (decrease) blk: {
+        self.calc_performed = true;
+        break :blk shadow - shadow_shifted;
+    } else shadow + shadow_shifted;
     if (freq > 0x7FF) ch_enable.* = false;
 
     return freq;

src/core/apu/signal/Lfsr.zig

@@ -19,6 +19,11 @@ pub fn create(sched: *Scheduler) Self {
     };
 }
 
+pub fn reset(self: *Self) void {
+    self.shift = 0;
+    self.timer = 0;
+}
+
 pub fn sample(self: *const Self) i8 {
     return if ((~self.shift & 1) == 1) 1 else -1;
 }

src/core/apu/signal/Square.zig

@@ -20,6 +20,11 @@ pub fn init(sched: *Scheduler) Self {
     };
 }
 
+pub fn reset(self: *Self) void {
+    self.timer = 0;
+    self.pos = 0;
+}
+
 /// Scheduler Event Handler for Square Synth Timer Expire
 pub fn onSquareTimerExpire(self: *Self, comptime T: type, nrx34: io.Frequency, late: u64) void {
     comptime std.debug.assert(T == ToneSweep or T == Tone);

src/core/apu/signal/Wave.zig

@@ -38,6 +38,13 @@ pub fn init(sched: *Scheduler) Self {
     };
 }
 
+pub fn reset(self: *Self) void {
+    self.timer = 0;
+    self.offset = 0;
+
+    // sample buffer isn't reset because it's outside of the range of what NR52{7}'s effects
+}
+
 /// Reload internal Wave Timer
 pub fn reload(self: *Self, value: u11) void {
     self.sched.removeScheduledEvent(.{ .ApuChannel = 2 });

src/core/bus/Bios.zig

@@ -3,6 +3,9 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.Bios);
 
+const rotr = @import("../../util.zig").rotr;
+const forceAlign = @import("../Bus.zig").forceAlign;
+
 /// Size of the BIOS in bytes
 pub const size = 0x4000;
 const Self = @This();
@@ -10,21 +13,37 @@ const Self = @This();
 buf: ?[]u8,
 allocator: Allocator,
 
-addr_latch: u32,
+addr_latch: u32 = 0,
 
-pub fn read(self: *Self, comptime T: type, r15: u32, addr: u32) T {
+// https://github.com/ITotalJustice/notorious_beeg/issues/106
+pub fn read(self: *Self, comptime T: type, r15: u32, address: u32) T {
     if (r15 < Self.size) {
+        const addr = forceAlign(T, address);
+
         self.addr_latch = addr;
         return self._read(T, addr);
     }
 
-    log.debug("Rejected read since r15=0x{X:0>8}", .{r15});
+    log.warn("Open Bus! Read from 0x{X:0>8}, but PC was 0x{X:0>8}", .{ address, r15 });
-    return @truncate(T, self._read(T, self.addr_latch));
+    const value = self._read(u32, self.addr_latch);
+
+    return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address)));
 }
 
-pub fn dbgRead(self: *const Self, comptime T: type, r15: u32, addr: u32) T {
+fn rotateBy(comptime T: type, address: u32) u32 {
-    if (r15 < Self.size) return self._read(T, addr);
+    return switch (T) {
-    return @truncate(T, self._read(T, self.addr_latch + 8));
+        u8 => address & 3,
+        u16 => address & 2,
+        u32 => 0,
+        else => @compileError("bios: unsupported read width"),
+    };
+}
+
+pub fn dbgRead(self: *const Self, comptime T: type, r15: u32, address: u32) T {
+    if (r15 < Self.size) return self._read(T, forceAlign(T, address));
+
+    const value = self._read(u32, self.addr_latch);
+    return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address)));
 }
 
 /// Read without the GBA safety checks
@@ -43,18 +62,19 @@ pub fn write(_: *Self, comptime T: type, addr: u32, value: T) void {
 }
 
 pub fn init(allocator: Allocator, maybe_path: ?[]const u8) !Self {
-    const buf: ?[]u8 = if (maybe_path) |path| blk: {
+    if (maybe_path == null) return .{ .buf = null, .allocator = allocator };
-        const file = try std.fs.cwd().openFile(path, .{});
+    const path = maybe_path.?;
-        defer file.close();
 
-        break :blk try file.readToEndAlloc(allocator, try file.getEndPos());
+    const buf = try allocator.alloc(u8, Self.size);
-    } else null;
+    errdefer allocator.free(buf);
 
-    return Self{
+    const file = try std.fs.cwd().openFile(path, .{});
-        .buf = buf,
+    defer file.close();
-        .allocator = allocator,
+
-        .addr_latch = 0,
+    const file_len = try file.readAll(buf);
-    };
+    if (file_len != Self.size) log.err("Expected BIOS to be {}B, was {}B", .{ Self.size, file_len });
+
+    return Self{ .buf = buf, .allocator = allocator };
 }
 
 pub fn deinit(self: *Self) void {

src/core/bus/GamePak.zig

@@ -213,6 +213,7 @@ fn guessDevice(buf: []const u8) Gpio.Device.Kind {
     // Try to Guess if ROM uses RTC
     const needle = "RTC_V"; // I was told SIIRTC_V, though Pokemen Firered (USA) is a false negative
 
+    // TODO: Use new for loop syntax?
     var i: usize = 0;
     while ((i + needle.len) < buf.len) : (i += 1) {
         if (std.mem.eql(u8, needle, buf[i..(i + needle.len)])) return .Rtc;

src/core/bus/backup.zig

@@ -6,7 +6,6 @@ const Eeprom = @import("backup/eeprom.zig").Eeprom;
 const Flash = @import("backup/Flash.zig");
 
 const escape = @import("../../util.zig").escape;
-const span = @import("../../util.zig").span;
 
 const Needle = struct { str: []const u8, kind: Backup.Kind };
 const backup_kinds = [6]Needle{
@@ -138,6 +137,7 @@ pub const Backup = struct {
         for (backup_kinds) |needle| {
             const needle_len = needle.str.len;
 
+            // TODO: Use new for loop syntax?
             var i: usize = 0;
             while ((i + needle_len) < rom.len) : (i += 1) {
                 if (std.mem.eql(u8, needle.str, rom[i..][0..needle_len])) return needle.kind;
@@ -195,7 +195,7 @@ pub const Backup = struct {
     }
 
     fn saveName(self: *const Self, allocator: Allocator) ![]const u8 {
-        const title_str = span(&escape(self.title));
+        const title_str = std.mem.sliceTo(&escape(self.title), 0);
         const name = if (title_str.len != 0) title_str else "untitled";
 
         return try std.mem.concat(allocator, u8, &[_][]const u8{ name, ".sav" });

src/core/bus/dma.zig

@@ -5,7 +5,7 @@ const DmaControl = @import("io.zig").DmaControl;
 const Bus = @import("../Bus.zig");
 const Arm7tdmi = @import("../cpu.zig").Arm7tdmi;
 
-pub const DmaTuple = std.meta.Tuple(&[_]type{ DmaController(0), DmaController(1), DmaController(2), DmaController(3) });
+pub const DmaTuple = struct { DmaController(0), DmaController(1), DmaController(2), DmaController(3) };
 const log = std.log.scoped(.DmaTransfer);
 
 const getHalf = util.getHalf;
@@ -256,11 +256,16 @@ fn DmaController(comptime id: u2) type {
                 cpu.bus.write(u16, dad_addr, @truncate(u16, rotr(u32, self.data_latch, 8 * (dad_addr & 3))));
             }
 
-            switch (sad_adj) {
+            switch (@truncate(u8, sad_addr >> 24)) {
-                .Increment => self.sad_latch +%= offset,
+                // according to fleroviux, DMAs with a source address in ROM misbehave
-                .Decrement => self.sad_latch -%= offset,
+                // the resultant behaviour is that the source address will increment despite what DMAXCNT says
-                .IncrementReload => log.err("{} is a prohibited adjustment on SAD", .{sad_adj}),
+                0x08...0x0D => self.sad_latch +%= offset, // obscure behaviour
-                .Fixed => {},
+                else => switch (sad_adj) {
+                    .Increment => self.sad_latch +%= offset,
+                    .Decrement => self.sad_latch -%= offset,
+                    .IncrementReload => log.err("{} is a prohibited adjustment on SAD", .{sad_adj}),
+                    .Fixed => {},
+                },
             }
 
             switch (dad_adj) {
@@ -334,10 +339,7 @@ fn DmaController(comptime id: u2) type {
 }
 
 pub fn onBlanking(bus: *Bus, comptime kind: DmaKind) void {
-    comptime var i: usize = 0;
+    inline for (0..4) |i| bus.dma[i].poll(kind);
-    inline while (i < 4) : (i += 1) {
-        bus.dma[i].poll(kind);
-    }
 }
 
 const Adjustment = enum(u2) {

src/core/bus/gpio.zig

@@ -293,13 +293,13 @@ pub const Clock = struct {
         self.cpu.sched.push(.RealTimeClock, (1 << 24) -| late); // Reschedule
 
         const now = DateTime.now();
-        self.year = bcd(u8, @intCast(u8, now.date.year - 2000));
+        self.year = bcd(@intCast(u8, now.date.year - 2000));
-        self.month = bcd(u5, now.date.month);
+        self.month = @truncate(u5, bcd(now.date.month));
-        self.day = bcd(u6, now.date.day);
+        self.day = @truncate(u6, bcd(now.date.day));
-        self.weekday = bcd(u3, (now.date.weekday() + 1) % 7); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
+        self.weekday = @truncate(u3, bcd((now.date.weekday() + 1) % 7)); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
-        self.hour = bcd(u6, now.time.hour);
+        self.hour = @truncate(u6, bcd(now.time.hour));
-        self.minute = bcd(u7, now.time.minute);
+        self.minute = @truncate(u7, bcd(now.time.minute));
-        self.second = bcd(u7, now.time.second);
+        self.second = @truncate(u7, bcd(now.time.second));
     }
 
     fn step(self: *Self, value: Data) u4 {
@@ -449,16 +449,8 @@ pub const Clock = struct {
     }
 };
 
-fn bcd(comptime T: type, value: u8) T {
+/// Converts an 8-bit unsigned integer to its BCD representation.
-    var input = value;
+/// Note: Algorithm only works for values between 0 and 99 inclusive.
-    var ret: u8 = 0;
+fn bcd(value: u8) u8 {
-    var shift: u3 = 0;
+    return ((value / 10) << 4) + (value % 10);
-
-    while (input > 0) {
-        ret |= (input % 10) << (shift << 2);
-        shift += 1;
-        input /= 10;
-    }
-
-    return @truncate(T, ret);
 }

src/core/bus/io.zig

@@ -24,14 +24,14 @@ pub const Io = struct {
     postflg: PostFlag,
     waitcnt: WaitControl,
     haltcnt: HaltControl,
-    keyinput: KeyInput,
+    keyinput: AtomicKeyInput,
 
     pub fn init() Self {
         return .{
             .ime = false,
             .ie = .{ .raw = 0x0000 },
             .irq = .{ .raw = 0x0000 },
-            .keyinput = .{ .raw = 0x03FF },
+            .keyinput = AtomicKeyInput.init(.{ .raw = 0x03FF }),
             .waitcnt = .{ .raw = 0x0000_0000 }, // Bit 15 == 0 for GBA
             .postflg = .FirstBoot,
             .haltcnt = .Execute,
@@ -92,7 +92,7 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
             0x0400_0128 => util.io.read.todo(log, "Read {} from SIOCNT", .{T}),
 
             // Keypad Input
-            0x0400_0130 => bus.io.keyinput.raw,
+            0x0400_0130 => bus.io.keyinput.load(.Monotonic).raw,
 
             // Serial Communication 2
             0x0400_0134 => util.io.read.todo(log, "Read {} from RCNT", .{T}),
@@ -376,6 +376,31 @@ const KeyInput = extern union {
     raw: u16,
 };
 
+const AtomicKeyInput = struct {
+    const Self = @This();
+    const Ordering = std.atomic.Ordering;
+
+    inner: KeyInput,
+
+    pub fn init(value: KeyInput) Self {
+        return .{ .inner = value };
+    }
+
+    pub inline fn load(self: *const Self, comptime ordering: Ordering) KeyInput {
+        return .{ .raw = switch (ordering) {
+            .AcqRel, .Release => @compileError("not supported for atomic loads"),
+            else => @atomicLoad(u16, &self.inner.raw, ordering),
+        } };
+    }
+
+    pub inline fn store(self: *Self, value: u16, comptime ordering: Ordering) void {
+        switch (ordering) {
+            .AcqRel, .Acquire => @compileError("not supported for atomic stores"),
+            else => @atomicStore(u16, &self.inner.raw, value, ordering),
+        }
+    }
+};
+
 // Read / Write
 pub const BackgroundControl = extern union {
     priority: Bitfield(u16, 0, 2),

src/core/bus/timer.zig

@@ -5,7 +5,7 @@ const TimerControl = @import("io.zig").TimerControl;
 const Scheduler = @import("../scheduler.zig").Scheduler;
 const Arm7tdmi = @import("../cpu.zig").Arm7tdmi;
 
-pub const TimerTuple = std.meta.Tuple(&[_]type{ Timer(0), Timer(1), Timer(2), Timer(3) });
+pub const TimerTuple = struct { Timer(0), Timer(1), Timer(2), Timer(3) };
 const log = std.log.scoped(.Timer);
 
 const getHalf = util.getHalf;
@@ -150,21 +150,36 @@ fn Timer(comptime id: u2) type {
         pub fn setTimcntH(self: *Self, halfword: u16) void {
             const new = TimerControl{ .raw = halfword };
 
-            // If Timer happens to be enabled, It will either be resheduled or disabled
+            if (self.cnt.enabled.read()) {
-            self.sched.removeScheduledEvent(.{ .TimerOverflow = id });
+                // timer was already enabled
 
-            if (self.cnt.enabled.read() and (new.cascade.read() or !new.enabled.read())) {
+                // If enabled falling edge or cascade falling edge, timer is paused
-                // Either through the cascade bit or the enable bit, the timer has effectively been disabled
+                if (!new.enabled.read() or (!self.cnt.cascade.read() and new.cascade.read())) {
-                // The Counter should hold whatever value it should have been at when it was disabled
+                    self.sched.removeScheduledEvent(.{ .TimerOverflow = id });
-                self._counter +%= @truncate(u16, (self.sched.now() - self._start_timestamp) / self.frequency());
+
+                    // Counter should hold the value it stopped at meaning we have to calculate it now
+                    self._counter +%= @truncate(u16, (self.sched.now() - self._start_timestamp) / self.frequency());
+                }
+
+                // the timer has always been enabled, but the cascade bit which was blocking the timer has been unset
+                if (new.enabled.read() and (self.cnt.cascade.read() and !new.cascade.read())) {
+                    // we want to reschedule the timer event, however we won't reload the counter.
+                    // the invariant here is that self._counter holds the already calculated paused value
+
+                    self.rescheduleTimerExpire(0);
+                }
+            } else {
+                // the timer was previously disabeld
+
+                if (new.enabled.read()) {
+                    // timer should start counting (with a reloaded counter value)
+                    self._counter = self._reload;
+
+                    // if cascade happens to be set, the timer doesn't actually do anything though
+                    if (!new.cascade.read()) self.rescheduleTimerExpire(0);
+                }
             }
 
-            // The counter is only reloaded on the rising edge of the enable bit
-            if (!self.cnt.enabled.read() and new.enabled.read()) self._counter = self._reload;
-
-            // If Timer is enabled and we're not cascading, we need to schedule an overflow event
-            if (new.enabled.read() and !new.cascade.read()) self.rescheduleTimerExpire(0);
-
             self.cnt.raw = halfword;
         }
 
@@ -202,7 +217,8 @@ fn Timer(comptime id: u2) type {
             }
 
             // Reschedule Timer if we're not cascading
-            if (!self.cnt.cascade.read()) {
+            // TIM0 cascade value is N/A
+            if (id == 0 or !self.cnt.cascade.read()) {
                 self._counter = self._reload;
                 self.rescheduleTimerExpire(late);
             }

src/core/cpu.zig

@@ -7,6 +7,7 @@ const Scheduler = @import("scheduler.zig").Scheduler;
 const Logger = @import("../util.zig").Logger;
 
 const File = std.fs.File;
+const log = std.log.scoped(.Arm7Tdmi);
 
 // ARM Instructions
 pub const arm = struct {
@@ -38,13 +39,12 @@ pub const arm = struct {
     }
 
     fn populate() [0x1000]InstrFn {
-        return comptime {
+        comptime {
             @setEvalBranchQuota(0xE000);
-            var ret = [_]InstrFn{und} ** 0x1000;
+            var table = [_]InstrFn{und} ** 0x1000;
 
-            var i: usize = 0;
+            for (&table, 0..) |*handler, i| {
-            while (i < ret.len) : (i += 1) {
+                handler.* = switch (@as(u2, i >> 10)) {
-                ret[i] = switch (@as(u2, i >> 10)) {
                     0b00 => if (i == 0x121) blk: {
                         break :blk branchExchange;
                     } else if (i & 0xFCF == 0x009) blk: {
@@ -106,8 +106,8 @@ pub const arm = struct {
                 };
             }
 
-            return ret;
+            return table;
-        };
+        }
     }
 };
 
@@ -135,13 +135,12 @@ pub const thumb = struct {
     }
 
     fn populate() [0x400]InstrFn {
-        return comptime {
+        comptime {
             @setEvalBranchQuota(5025); // This is exact
-            var ret = [_]InstrFn{und} ** 0x400;
+            var table = [_]InstrFn{und} ** 0x400;
 
-            var i: usize = 0;
+            for (&table, 0..) |*handler, i| {
-            while (i < ret.len) : (i += 1) {
+                handler.* = switch (@as(u3, i >> 7 & 0x7)) {
-                ret[i] = switch (@as(u3, i >> 7 & 0x7)) {
                     0b000 => if (i >> 5 & 0x3 == 0b11) blk: {
                         const I = i >> 4 & 1 == 1;
                         const is_sub = i >> 3 & 1 == 1;
@@ -229,13 +228,11 @@ pub const thumb = struct {
                 };
             }
 
-            return ret;
+            return table;
-        };
+        }
     }
 };
 
-const log = std.log.scoped(.Arm7Tdmi);
-
 pub const Arm7tdmi = struct {
     const Self = @This();
 
@@ -246,18 +243,64 @@ pub const Arm7tdmi = struct {
     cpsr: PSR,
     spsr: PSR,
 
-    /// Storage  for R8_fiq -> R12_fiq and their normal counterparts
+    bank: Bank,
-    /// e.g [r[0 + 8], fiq_r[0 + 8], r[1 + 8], fiq_r[1 + 8]...]
-    banked_fiq: [2 * 5]u32,
-
-    /// Storage for r13_<mode>, r14_<mode>
-    /// e.g. [r13, r14, r13_svc, r14_svc]
-    banked_r: [2 * 6]u32,
-
-    banked_spsr: [5]PSR,
 
     logger: ?Logger,
 
+    /// Bank of Registers from other CPU Modes
+    const Bank = struct {
+        /// Storage for r13_<mode>, r14_<mode>
+        /// e.g. [r13, r14, r13_svc, r14_svc]
+        r: [2 * 6]u32,
+
+        /// Storage  for R8_fiq -> R12_fiq and their normal counterparts
+        /// e.g [r[0 + 8], fiq_r[0 + 8], r[1 + 8], fiq_r[1 + 8]...]
+        fiq: [2 * 5]u32,
+
+        spsr: [5]PSR,
+
+        const Kind = enum(u1) {
+            R13 = 0,
+            R14,
+        };
+
+        pub fn create() Bank {
+            return .{
+                .r = [_]u32{0x00} ** 12,
+                .fiq = [_]u32{0x00} ** 10,
+                .spsr = [_]PSR{.{ .raw = 0x0000_0000 }} ** 5,
+            };
+        }
+
+        inline fn regIdx(mode: Mode, kind: Kind) usize {
+            const idx: usize = switch (mode) {
+                .User, .System => 0,
+                .Supervisor => 1,
+                .Abort => 2,
+                .Undefined => 3,
+                .Irq => 4,
+                .Fiq => 5,
+            };
+
+            return (idx * 2) + if (kind == .R14) @as(usize, 1) else 0;
+        }
+
+        inline fn spsrIdx(mode: Mode) usize {
+            return switch (mode) {
+                .Supervisor => 0,
+                .Abort => 1,
+                .Undefined => 2,
+                .Irq => 3,
+                .Fiq => 4,
+                else => std.debug.panic("[CPU/Mode] {} does not have a SPSR Register", .{mode}),
+            };
+        }
+
+        inline fn fiqIdx(i: usize, mode: Mode) usize {
+            return (i * 2) + if (mode == .Fiq) @as(usize, 1) else 0;
+        }
+    };
+
     pub fn init(sched: *Scheduler, bus: *Bus, log_file: ?std.fs.File) Self {
         return Self{
             .r = [_]u32{0x00} ** 16,
@@ -266,41 +309,11 @@ pub const Arm7tdmi = struct {
             .bus = bus,
             .cpsr = .{ .raw = 0x0000_001F },
             .spsr = .{ .raw = 0x0000_0000 },
-            .banked_fiq = [_]u32{0x00} ** 10,
+            .bank = Bank.create(),
-            .banked_r = [_]u32{0x00} ** 12,
-            .banked_spsr = [_]PSR{.{ .raw = 0x0000_0000 }} ** 5,
             .logger = if (log_file) |file| Logger.init(file) else null,
         };
     }
 
-    inline fn bankedIdx(mode: Mode, kind: BankedKind) usize {
-        const idx: usize = switch (mode) {
-            .User, .System => 0,
-            .Supervisor => 1,
-            .Abort => 2,
-            .Undefined => 3,
-            .Irq => 4,
-            .Fiq => 5,
-        };
-
-        return (idx * 2) + if (kind == .R14) @as(usize, 1) else 0;
-    }
-
-    inline fn bankedSpsrIndex(mode: Mode) usize {
-        return switch (mode) {
-            .Supervisor => 0,
-            .Abort => 1,
-            .Undefined => 2,
-            .Irq => 3,
-            .Fiq => 4,
-            else => std.debug.panic("[CPU/Mode] {} does not have a SPSR Register", .{mode}),
-        };
-    }
-
-    inline fn bankedFiqIdx(i: usize, mode: Mode) usize {
-        return (i * 2) + if (mode == .Fiq) @as(usize, 1) else 0;
-    }
-
     pub inline fn hasSPSR(self: *const Self) bool {
         const mode = getModeChecked(self, self.cpsr.mode.read());
         return switch (mode) {
@@ -336,14 +349,14 @@ pub const Arm7tdmi = struct {
         switch (idx) {
             8...12 => {
                 if (current == .Fiq) {
-                    self.banked_fiq[bankedFiqIdx(idx - 8, .User)] = value;
+                    self.bank.fiq[Bank.fiqIdx(idx - 8, .User)] = value;
                 } else self.r[idx] = value;
             },
             13, 14 => switch (current) {
                 .User, .System => self.r[idx] = value,
                 else => {
-                    const kind = std.meta.intToEnum(BankedKind, idx - 13) catch unreachable;
+                    const kind = std.meta.intToEnum(Bank.Kind, idx - 13) catch unreachable;
-                    self.banked_r[bankedIdx(.User, kind)] = value;
+                    self.bank.r[Bank.regIdx(.User, kind)] = value;
                 },
             },
             else => self.r[idx] = value, // R0 -> R7  and R15
@@ -354,12 +367,12 @@ pub const Arm7tdmi = struct {
         const current = getModeChecked(self, self.cpsr.mode.read());
 
         return switch (idx) {
-            8...12 => if (current == .Fiq) self.banked_fiq[bankedFiqIdx(idx - 8, .User)] else self.r[idx],
+            8...12 => if (current == .Fiq) self.bank.fiq[Bank.fiqIdx(idx - 8, .User)] else self.r[idx],
             13, 14 => switch (current) {
                 .User, .System => self.r[idx],
                 else => blk: {
-                    const kind = std.meta.intToEnum(BankedKind, idx - 13) catch unreachable;
+                    const kind = std.meta.intToEnum(Bank.Kind, idx - 13) catch unreachable;
-                    break :blk self.banked_r[bankedIdx(.User, kind)];
+                    break :blk self.bank.r[Bank.regIdx(.User, kind)];
                 },
             },
             else => self.r[idx], // R0 -> R7  and R15
@@ -370,40 +383,38 @@ pub const Arm7tdmi = struct {
         const now = getModeChecked(self, self.cpsr.mode.read());
 
         // Bank R8 -> r12
-        var i: usize = 0;
+        for (0..5) |i| {
-        while (i < 5) : (i += 1) {
+            self.bank.fiq[Bank.fiqIdx(i, now)] = self.r[8 + i];
-            self.banked_fiq[bankedFiqIdx(i, now)] = self.r[8 + i];
         }
 
         // Bank r13, r14, SPSR
         switch (now) {
             .User, .System => {
-                self.banked_r[bankedIdx(now, .R13)] = self.r[13];
+                self.bank.r[Bank.regIdx(now, .R13)] = self.r[13];
-                self.banked_r[bankedIdx(now, .R14)] = self.r[14];
+                self.bank.r[Bank.regIdx(now, .R14)] = self.r[14];
             },
             else => {
-                self.banked_r[bankedIdx(now, .R13)] = self.r[13];
+                self.bank.r[Bank.regIdx(now, .R13)] = self.r[13];
-                self.banked_r[bankedIdx(now, .R14)] = self.r[14];
+                self.bank.r[Bank.regIdx(now, .R14)] = self.r[14];
-                self.banked_spsr[bankedSpsrIndex(now)] = self.spsr;
+                self.bank.spsr[Bank.spsrIdx(now)] = self.spsr;
             },
         }
 
         // Grab R8 -> R12
-        i = 0;
+        for (0..5) |i| {
-        while (i < 5) : (i += 1) {
+            self.r[8 + i] = self.bank.fiq[Bank.fiqIdx(i, next)];
-            self.r[8 + i] = self.banked_fiq[bankedFiqIdx(i, next)];
         }
 
         // Grab r13, r14, SPSR
         switch (next) {
             .User, .System => {
-                self.r[13] = self.banked_r[bankedIdx(next, .R13)];
+                self.r[13] = self.bank.r[Bank.regIdx(next, .R13)];
-                self.r[14] = self.banked_r[bankedIdx(next, .R14)];
+                self.r[14] = self.bank.r[Bank.regIdx(next, .R14)];
             },
             else => {
-                self.r[13] = self.banked_r[bankedIdx(next, .R13)];
+                self.r[13] = self.bank.r[Bank.regIdx(next, .R13)];
-                self.r[14] = self.banked_r[bankedIdx(next, .R14)];
+                self.r[14] = self.bank.r[Bank.regIdx(next, .R14)];
-                self.spsr = self.banked_spsr[bankedSpsrIndex(next)];
+                self.spsr = self.bank.spsr[Bank.spsrIdx(next)];
             },
         }
 
@@ -424,8 +435,8 @@ pub const Arm7tdmi = struct {
         self.r[13] = 0x0300_7F00;
         self.r[15] = 0x0800_0000;
 
-        self.banked_r[bankedIdx(.Irq, .R13)] = 0x0300_7FA0;
+        self.bank.r[Bank.regIdx(.Irq, .R13)] = 0x0300_7FA0;
-        self.banked_r[bankedIdx(.Supervisor, .R13)] = 0x0300_7FE0;
+        self.bank.r[Bank.regIdx(.Supervisor, .R13)] = 0x0300_7FE0;
 
         // self.cpsr.raw = 0x6000001F;
         self.cpsr.raw = 0x0000_001F;
@@ -455,8 +466,7 @@ pub const Arm7tdmi = struct {
     }
 
     pub fn stepDmaTransfer(self: *Self) bool {
-        comptime var i: usize = 0;
+        inline for (0..4) |i| {
-        inline while (i < 4) : (i += 1) {
             if (self.bus.dma[i].in_progress) {
                 self.bus.dma[i].step(self);
                 return true;
@@ -515,10 +525,10 @@ pub const Arm7tdmi = struct {
             std.debug.print("R{}: 0x{X:0>8}\tR{}: 0x{X:0>8}\tR{}: 0x{X:0>8}\tR{}: 0x{X:0>8}\n", .{ i, self.r[i], i_1, self.r[i_1], i_2, self.r[i_2], i_3, self.r[i_3] });
         }
         std.debug.print("cpsr: 0x{X:0>8} ", .{self.cpsr.raw});
-        prettyPrintPsr(&self.cpsr);
+        self.cpsr.toString();
 
         std.debug.print("spsr: 0x{X:0>8} ", .{self.spsr.raw});
-        prettyPrintPsr(&self.spsr);
+        self.spsr.toString();
 
         std.debug.print("pipeline: {??X:0>8}\n", .{self.pipe.stage});
 
@@ -536,76 +546,6 @@ pub const Arm7tdmi = struct {
 
         std.debug.panic(format, args);
     }
-
-    fn prettyPrintPsr(psr: *const PSR) void {
-        std.debug.print("[", .{});
-
-        if (psr.n.read()) std.debug.print("N", .{}) else std.debug.print("-", .{});
-        if (psr.z.read()) std.debug.print("Z", .{}) else std.debug.print("-", .{});
-        if (psr.c.read()) std.debug.print("C", .{}) else std.debug.print("-", .{});
-        if (psr.v.read()) std.debug.print("V", .{}) else std.debug.print("-", .{});
-        if (psr.i.read()) std.debug.print("I", .{}) else std.debug.print("-", .{});
-        if (psr.f.read()) std.debug.print("F", .{}) else std.debug.print("-", .{});
-        if (psr.t.read()) std.debug.print("T", .{}) else std.debug.print("-", .{});
-        std.debug.print("|", .{});
-        if (getMode(psr.mode.read())) |mode| std.debug.print("{s}", .{modeString(mode)}) else std.debug.print("---", .{});
-
-        std.debug.print("]\n", .{});
-    }
-
-    fn modeString(mode: Mode) []const u8 {
-        return switch (mode) {
-            .User => "usr",
-            .Fiq => "fiq",
-            .Irq => "irq",
-            .Supervisor => "svc",
-            .Abort => "abt",
-            .Undefined => "und",
-            .System => "sys",
-        };
-    }
-
-    fn mgbaLog(self: *const Self, file: *const File, opcode: u32) !void {
-        const thumb_fmt = "{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} | {X:0>4}:\n";
-        const arm_fmt = "{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} | {X:0>8}:\n";
-        var buf: [0x100]u8 = [_]u8{0x00} ** 0x100; // this is larger than it needs to be
-
-        const r0 = self.r[0];
-        const r1 = self.r[1];
-        const r2 = self.r[2];
-        const r3 = self.r[3];
-        const r4 = self.r[4];
-        const r5 = self.r[5];
-        const r6 = self.r[6];
-        const r7 = self.r[7];
-        const r8 = self.r[8];
-        const r9 = self.r[9];
-        const r10 = self.r[10];
-        const r11 = self.r[11];
-        const r12 = self.r[12];
-        const r13 = self.r[13];
-        const r14 = self.r[14];
-        const r15 = self.r[15] -| if (self.cpsr.t.read()) 2 else @as(u32, 4);
-
-        const c_psr = self.cpsr.raw;
-
-        var log_str: []u8 = undefined;
-        if (self.cpsr.t.read()) {
-            if (opcode >> 11 == 0x1E) {
-                // Instruction 1 of a BL Opcode, print in ARM mode
-                const other_half = self.bus.debugRead(u16, self.r[15] - 2);
-                const bl_opcode = @as(u32, opcode) << 16 | other_half;
-
-                log_str = try std.fmt.bufPrint(&buf, arm_fmt, .{ r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, c_psr, bl_opcode });
-            } else {
-                log_str = try std.fmt.bufPrint(&buf, thumb_fmt, .{ r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, c_psr, opcode });
-            }
-        } else {
-            log_str = try std.fmt.bufPrint(&buf, arm_fmt, .{ r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, c_psr, opcode });
-        }
-
-        _ = try file.writeAll(log_str);
-    }
 };
 
 const condition_lut = [_]u16{
@@ -652,9 +592,7 @@ const Pipeline = struct {
     pub fn step(self: *Self, cpu: *Arm7tdmi, comptime T: type) ?u32 {
         comptime std.debug.assert(T == u32 or T == u16);
 
-        // FIXME: https://github.com/ziglang/zig/issues/12642
+        const opcode = self.stage[0];
-        var opcode = self.stage[0];
-
         self.stage[0] = self.stage[1];
         self.stage[1] = cpu.fetch(T, cpu.r[15]);
 
@@ -686,6 +624,22 @@ pub const PSR = extern union {
     z: Bit(u32, 30),
     n: Bit(u32, 31),
     raw: u32,
+
+    fn toString(self: PSR) void {
+        std.debug.print("[", .{});
+
+        if (self.n.read()) std.debug.print("N", .{}) else std.debug.print("-", .{});
+        if (self.z.read()) std.debug.print("Z", .{}) else std.debug.print("-", .{});
+        if (self.c.read()) std.debug.print("C", .{}) else std.debug.print("-", .{});
+        if (self.v.read()) std.debug.print("V", .{}) else std.debug.print("-", .{});
+        if (self.i.read()) std.debug.print("I", .{}) else std.debug.print("-", .{});
+        if (self.f.read()) std.debug.print("F", .{}) else std.debug.print("-", .{});
+        if (self.t.read()) std.debug.print("T", .{}) else std.debug.print("-", .{});
+        std.debug.print("|", .{});
+        if (getMode(self.mode.read())) |m| std.debug.print("{s}", .{m.toString()}) else std.debug.print("---", .{});
+
+        std.debug.print("]\n", .{});
+    }
 };
 
 const Mode = enum(u5) {
@@ -696,11 +650,18 @@ const Mode = enum(u5) {
     Abort = 0b10111,
     Undefined = 0b11011,
     System = 0b11111,
-};
 
-const BankedKind = enum(u1) {
+    fn toString(self: Mode) []const u8 {
-    R13 = 0,
+        return switch (self) {
-    R14,
+            .User => "usr",
+            .Fiq => "fiq",
+            .Irq => "irq",
+            .Supervisor => "svc",
+            .Abort => "abt",
+            .Undefined => "und",
+            .System => "sys",
+        };
+    }
 };
 
 fn getMode(bits: u5) ?Mode {

src/core/cpu/arm/data_processing.zig

@@ -24,7 +24,7 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
             if (!I and opcode >> 4 & 1 == 1) cpu.r[15] -= 4;
 
             var result: u32 = undefined;
-            var overflow: bool = undefined;
+            var overflow: u1 = undefined;
 
             // Perform Data Processing Logic
             switch (kind) {
@@ -62,7 +62,9 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
                     if (rd == 0xF)
                         return undefinedTestBehaviour(cpu);
 
-                    overflow = @addWithOverflow(u32, op1, op2, &result);
+                    const tmp = @addWithOverflow(op1, op2);
+                    result = tmp[0];
+                    overflow = tmp[1];
                 },
                 0xC => result = op1 | op2, // ORR
                 0xD => result = op2, // MOV
@@ -110,7 +112,7 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
                     // ADD, ADC Flags
                     cpu.cpsr.n.write(result >> 31 & 1 == 1);
                     cpu.cpsr.z.write(result == 0);
-                    cpu.cpsr.c.write(overflow);
+                    cpu.cpsr.c.write(overflow == 0b1);
                     cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                 },
                 0x6, 0x7 => if (S and rd != 0xF) {
@@ -141,7 +143,7 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
                         cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
                     } else if (kind == 0xB) {
                         // CMN specific
-                        cpu.cpsr.c.write(overflow);
+                        cpu.cpsr.c.write(overflow == 0b1);
                         cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                     } else {
                         // TST, TEQ specific
@@ -162,19 +164,19 @@ pub fn sbc(left: u32, right: u32, old_carry: u1) u32 {
     return ret;
 }
 
-pub fn add(overflow: *bool, left: u32, right: u32) u32 {
+pub fn add(overflow: *u1, left: u32, right: u32) u32 {
-    var ret: u32 = undefined;
+    const ret = @addWithOverflow(left, right);
-    overflow.* = @addWithOverflow(u32, left, right, &ret);
+    overflow.* = ret[1];
-    return ret;
+
+    return ret[0];
 }
 
-pub fn adc(overflow: *bool, left: u32, right: u32, old_carry: u1) u32 {
+pub fn adc(overflow: *u1, left: u32, right: u32, old_carry: u1) u32 {
-    var ret: u32 = undefined;
+    const tmp = @addWithOverflow(left, right);
-    const first = @addWithOverflow(u32, left, right, &ret);
+    const ret = @addWithOverflow(tmp[0], old_carry);
-    const second = @addWithOverflow(u32, ret, old_carry, &ret);
+    overflow.* = tmp[1] | ret[1];
 
-    overflow.* = first or second;
+    return ret[0];
-    return ret;
 }
 
 fn undefinedTestBehaviour(cpu: *Arm7tdmi) void {

src/core/cpu/arm/single_data_transfer.zig

@@ -11,9 +11,7 @@ pub fn singleDataTransfer(comptime I: bool, comptime P: bool, comptime U: bool,
             const rn = opcode >> 16 & 0xF;
             const rd = opcode >> 12 & 0xF;
 
-            // rn is r15 and L is not set, the PC is 12 ahead
+            const base = cpu.r[rn];
-            const base = cpu.r[rn] + if (!L and rn == 0xF) 4 else @as(u32, 0);
-
             const offset = if (I) shifter.immediate(false, cpu, opcode) else opcode & 0xFFF;
 
             const modified_base = if (U) base +% offset else base -% offset;

src/core/cpu/thumb/alu.zig

@@ -21,7 +21,8 @@ pub fn fmt4(comptime op: u4) InstrFn {
             const op2 = cpu.r[rs];
 
             var result: u32 = undefined;
-            var overflow: bool = undefined;
+            var overflow: u1 = undefined;
+
             switch (op) {
                 0x0 => result = op1 & op2, // AND
                 0x1 => result = op1 ^ op2, // EOR
@@ -34,7 +35,12 @@ pub fn fmt4(comptime op: u4) InstrFn {
                 0x8 => result = op1 & op2, // TST
                 0x9 => result = 0 -% op2, // NEG
                 0xA => result = op1 -% op2, // CMP
-                0xB => overflow = @addWithOverflow(u32, op1, op2, &result), // CMN
+                0xB => {
+                    // CMN
+                    const tmp = @addWithOverflow(op1, op2);
+                    result = tmp[0];
+                    overflow = tmp[1];
+                },
                 0xC => result = op1 | op2, // ORR
                 0xD => result = @truncate(u32, @as(u64, op2) * @as(u64, op1)),
                 0xE => result = op1 & ~op2,
@@ -71,7 +77,7 @@ pub fn fmt4(comptime op: u4) InstrFn {
                     // ADC, CMN
                     cpu.cpsr.n.write(result >> 31 & 1 == 1);
                     cpu.cpsr.z.write(result == 0);
-                    cpu.cpsr.c.write(overflow);
+                    cpu.cpsr.c.write(overflow == 0b1);
                     cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                 },
                 0x6 => {

src/core/cpu/thumb/block_data_transfer.zig

@@ -92,8 +92,7 @@ pub fn fmt15(comptime L: bool, comptime rb: u3) InstrFn {
 inline fn countRlist(opcode: u16) u32 {
     var count: u32 = 0;
 
-    comptime var i: u4 = 0;
+    inline for (0..8) |i| {
-    inline while (i < 8) : (i += 1) {
         if (opcode >> (7 - i) & 1 == 1) count += 1;
     }
 

src/core/cpu/thumb/data_processing.zig

@@ -64,7 +64,7 @@ pub fn fmt5(comptime op: u2, comptime h1: u1, comptime h2: u1) InstrFn {
             const op2 = cpu.r[rs];
 
             var result: u32 = undefined;
-            var overflow: bool = undefined;
+            var overflow: u1 = undefined;
             switch (op) {
                 0b00 => result = add(&overflow, op1, op2), // ADD
                 0b01 => result = op1 -% op2, // CMP
@@ -126,13 +126,13 @@ pub fn fmt2(comptime I: bool, is_sub: bool, rn: u3) InstrFn {
                 cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
             } else {
                 // ADD
-                var overflow: bool = undefined;
+                var overflow: u1 = undefined;
                 const result = add(&overflow, op1, op2);
                 cpu.r[rd] = result;
 
                 cpu.cpsr.n.write(result >> 31 & 1 == 1);
                 cpu.cpsr.z.write(result == 0);
-                cpu.cpsr.c.write(overflow);
+                cpu.cpsr.c.write(overflow == 0b1);
                 cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
             }
         }
@@ -145,7 +145,7 @@ pub fn fmt3(comptime op: u2, comptime rd: u3) InstrFn {
             const op1 = cpu.r[rd];
             const op2: u32 = opcode & 0xFF; // Offset
 
-            var overflow: bool = undefined;
+            var overflow: u1 = undefined;
             const result: u32 = switch (op) {
                 0b00 => op2, // MOV
                 0b01 => op1 -% op2, // CMP
@@ -169,7 +169,7 @@ pub fn fmt3(comptime op: u2, comptime rd: u3) InstrFn {
                 },
                 0b10 => {
                     // ADD
-                    cpu.cpsr.c.write(overflow);
+                    cpu.cpsr.c.write(overflow == 0b1);
                     cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                 },
             }

src/core/emu.zig

@@ -56,7 +56,7 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), schedule
         .Unlimited, .UnlimitedFPS => {
             log.info("Emulation w/out video sync", .{});
 
-            while (!quit.load(.SeqCst)) {
+            while (!quit.load(.Monotonic)) {
                 runFrame(scheduler, cpu);
                 audioSync(audio_sync, cpu.bus.apu.stream, &cpu.bus.apu.is_buffer_full);
 
@@ -68,7 +68,7 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), schedule
             var timer = Timer.start() catch @panic("failed to initalize std.timer.Timer");
             var wake_time: u64 = frame_period;
 
-            while (!quit.load(.SeqCst)) {
+            while (!quit.load(.Monotonic)) {
                 runFrame(scheduler, cpu);
                 const new_wake_time = videoSync(&timer, wake_time);
 
@@ -94,7 +94,7 @@ pub fn runFrame(sched: *Scheduler, cpu: *Arm7tdmi) void {
         if (!cpu.stepDmaTransfer()) {
             if (cpu.isHalted()) {
                 // Fast-forward to next Event
-                sched.tick = sched.queue.peek().?.tick;
+                sched.tick = sched.nextTimestamp();
             } else {
                 cpu.step();
             }
@@ -146,9 +146,8 @@ fn sleep(timer: *Timer, wake_time: u64) ?u64 {
 
     const step = 2 * std.time.ns_per_ms; // Granularity of 2ms
     const times = sleep_for / step;
-    var i: usize = 0;
 
-    while (i < times) : (i += 1) {
+    for (0..times) |_| {
         std.time.sleep(step);
 
         // Upon wakeup, check to see if this particular sleep was longer than expected
@@ -163,3 +162,59 @@ fn sleep(timer: *Timer, wake_time: u64) ?u64 {
 fn spinLoop(timer: *Timer, wake_time: u64) void {
     while (true) if (timer.read() > wake_time) break;
 }
+
+pub const EmuThing = struct {
+    const Self = @This();
+    const Interface = @import("gdbstub").Emulator;
+    const Allocator = std.mem.Allocator;
+
+    cpu: *Arm7tdmi,
+    scheduler: *Scheduler,
+
+    pub fn init(cpu: *Arm7tdmi, scheduler: *Scheduler) Self {
+        return .{ .cpu = cpu, .scheduler = scheduler };
+    }
+
+    pub fn interface(self: *Self, allocator: Allocator) Interface {
+        return Interface.init(allocator, self);
+    }
+
+    pub fn read(self: *const Self, addr: u32) u8 {
+        return self.cpu.bus.dbgRead(u8, addr);
+    }
+
+    pub fn write(self: *Self, addr: u32, value: u8) void {
+        self.cpu.bus.dbgWrite(u8, addr, value);
+    }
+
+    pub fn registers(self: *const Self) *[16]u32 {
+        return &self.cpu.r;
+    }
+
+    pub fn cpsr(self: *const Self) u32 {
+        return self.cpu.cpsr.raw;
+    }
+
+    pub fn step(self: *Self) void {
+        const cpu = self.cpu;
+        const sched = self.scheduler;
+
+        // Is true when we have executed one (1) instruction
+        var did_step: bool = false;
+
+        // TODO: How can I make it easier to keep this in lock-step with runFrame?
+        while (!did_step) {
+            if (!cpu.stepDmaTransfer()) {
+                if (cpu.isHalted()) {
+                    // Fast-forward to next Event
+                    sched.tick = sched.queue.peek().?.tick;
+                } else {
+                    cpu.step();
+                    did_step = true;
+                }
+            }
+
+            if (sched.tick >= sched.nextTimestamp()) sched.handleEvent(cpu);
+        }
+    }
+};

src/core/ppu.zig

@@ -323,7 +323,15 @@ pub const Ppu = struct {
             // Only consider enabled Sprites
             if (attr0.is_affine.read() or !attr0.disabled.read()) {
                 const attr1 = @bitCast(Attr1, self.oam.read(u16, i + 2));
-                const sprite_height = spriteDimensions(attr0.shape.read(), attr1.size.read())[1];
+                const d = spriteDimensions(attr0.shape.read(), attr1.size.read());
+
+                // Account for double-size affine sprites
+                const sprite_height = d[1] << blk: {
+                    if (!attr0.is_affine.read()) break :blk 0;
+
+                    const aff_attr0: AffineAttr0 = .{ .raw = attr0.raw };
+                    break :blk if (aff_attr0.double_size.read()) 1 else 0;
+                };
 
                 // When fetching sprites we only care about ones that could be rendered
                 // on this scanline
@@ -332,6 +340,8 @@ pub const Ppu = struct {
 
                 // Sprites are expected to be able to wraparound, we perform the same check
                 // for unsigned and signed values so that we handle all valid sprite positions
+
+                // FIXME: Wrapping for Double-Size Sprites is not properly implemented
                 if (y_pos <= y and y < (y_pos + sprite_height)) {
                     for (self.scanline_sprites) |*maybe_sprite| {
                         if (maybe_sprite.* == null) {
@@ -364,28 +374,61 @@ pub const Ppu = struct {
         const obj_mapping = self.dispcnt.obj_mapping.read();
         const tile_row_offset: u32 = if (is_8bpp) 8 else 4;
         const tile_len: u32 = if (is_8bpp) 0x40 else 0x20;
+        const double_size = sprite.attr0.double_size.read();
 
         const char_base = 0x4000 * 4;
-
         const y = self.vcount.scanline.read();
 
+        var sprite_x: i16 = sprite.x();
+        if (sprite_x >= 240) sprite_x -= 512;
+
+        var sprite_y: i16 = sprite.y();
+        if (sprite_y >= 160) sprite_y -= 256;
+
+        const base = 32 * @as(u32, sprite.matrixId());
+        const pa = self.oam.read(u16, base + 3 * @sizeOf(u16));
+        const pb = self.oam.read(u16, base + 7 * @sizeOf(u16));
+        const pc = self.oam.read(u16, base + 11 * @sizeOf(u16));
+        const pd = self.oam.read(u16, base + 15 * @sizeOf(u16));
+
+        const matrix = @bitCast([4]i16, [_]u16{ pa, pb, pc, pd });
+
+        const sprite_width = sprite.width << if (double_size) 1 else 0;
+        const sprite_height = sprite.height << if (double_size) 1 else 0;
+
+        const half_width = sprite_width >> 1;
+        const half_height = sprite_height >> 1;
+
         var i: u9 = 0;
-        while (i < sprite.width) : (i += 1) {
+        while (i < sprite_width) : (i += 1) {
-            const x = (sprite.x() +% i) % width;
+            // TODO: Something is wrong here
+            const x = @truncate(u9, @bitCast(u16, sprite_x + i));
+            if (x >= width) continue;
+
             if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue;
 
-            var x_pos: i32 = sprite.x();
+            // Check to see if sprite pixel is in bounds
-            if (x_pos >= 240) x_pos -= 512;
+            // TODO: Are any of the checks here redundant?
-
+            if (sprite_x > x and x >= (sprite_x + sprite.width)) continue;
-            if (!(x_pos <= x and x < (x_pos + sprite.width))) continue;
 
             // Sprite is within bounds and therefore should be rendered
-            // std.math.absInt is branchless
+            const local_x = @as(i16, x) - sprite_x;
-            const tile_x = @bitCast(u32, @as(i32, std.math.absInt(@as(i32, x) - x_pos) catch unreachable));
+            const local_y = @as(i16, y) - sprite_y;
-            const tile_y = @bitCast(u32, @as(i32, std.math.absInt(@bitCast(i8, y) -% @bitCast(i8, sprite.y())) catch unreachable));
+
+            var rot_x = ((matrix[0] *% (local_x - half_width) +% matrix[1] *% (local_y - half_width)) >> 8);
+            var rot_y = ((matrix[2] *% (local_x - half_width) +% matrix[3] *% (local_y - half_width)) >> 8);
+
+            rot_x +%= half_width >> if (double_size) 1 else 0;
+            rot_y +%= half_height >> if (double_size) 1 else 0;
+
+            // Maybe this is the necessary check?
+            if (rot_x >= sprite.width or rot_y >= sprite.height or rot_x < 0 or rot_y < 0) continue;
+
+            const tile_x = @bitCast(u16, rot_x);
+            const tile_y = @bitCast(u16, rot_y);
 
-            const row = @truncate(u3, tile_y);
             const col = @truncate(u3, tile_x);
+            const row = @truncate(u3, tile_y);
 
             // TODO: Finish that 2D Sprites Test ROM
             const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
@@ -395,10 +438,12 @@ pub const Ppu = struct {
             const tile = self.vram.buf[tile_base + tile_offset];
             const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile;
 
+            const global_x = @truncate(u9, @bitCast(u16, local_x + sprite_x));
+
             // Sprite Palette starts at 0x0500_0200
             if (pal_id != 0) {
                 const bgr555 = self.palette.read(u16, 0x200 + pal_id * 2);
-                copyToSpriteBuffer(self.bld.cnt, &self.scanline, x, bgr555);
+                drawSpritePixel(self.bld.cnt, &self.scanline, @bitCast(Attr0, sprite.attr0), global_x, bgr555);
             }
         }
     }
@@ -411,31 +456,36 @@ pub const Ppu = struct {
         const tile_len: u32 = if (is_8bpp) 0x40 else 0x20;
 
         const char_base = 0x4000 * 4;
-
         const y = self.vcount.scanline.read();
 
+        var sprite_x: i16 = sprite.x();
+        if (sprite_x >= 240) sprite_x -= 512;
+
+        var sprite_y: i16 = sprite.y();
+        if (sprite_y >= 160) sprite_y -= 256;
+
         var i: u9 = 0;
         while (i < sprite.width) : (i += 1) {
-            const x = (sprite.x() +% i) % width;
+            // TODO: Something is Wrong Here
+            const x = @truncate(u9, @bitCast(u16, sprite_x + i));
+            if (x >= width) continue;
+
             if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue;
 
-            var x_pos: i32 = sprite.x();
+            if (sprite_x > x and x >= (sprite_x + sprite.width)) continue;
-            if (x_pos >= 240) x_pos -= 512;
-
-            if (!(x_pos <= x and x < (x_pos + sprite.width))) continue;
 
             // Sprite is within bounds and therefore should be rendered
-            const x_diff: i32 = std.math.absInt(@as(i32, x) - x_pos) catch unreachable;
+            const local_x = @as(i16, x) - sprite_x;
-            const y_diff: i32 = std.math.absInt(@bitCast(i8, y) -% @bitCast(i8, sprite.y())) catch unreachable;
+            const local_y = @as(i16, y) - sprite_y;
 
             // Note that we flip the tile_pos not the (tile_pos % 8) like we do for
             // Background Tiles. By doing this we mirror the entire sprite instead of
             // just a specific tile (see how sprite.width and sprite.height are involved)
-            const tile_x = @intCast(u9, x_diff) ^ if (sprite.hFlip()) (sprite.width - 1) else 0;
+            const tile_x = @intCast(u9, local_x) ^ if (sprite.hFlip()) (sprite.width - 1) else 0;
-            const tile_y = @intCast(u8, y_diff) ^ if (sprite.vFlip()) (sprite.height - 1) else 0;
+            const tile_y = @intCast(u8, local_y) ^ if (sprite.vFlip()) (sprite.height - 1) else 0;
 
-            const row = @truncate(u3, tile_y);
             const col = @truncate(u3, tile_x);
+            const row = @truncate(u3, tile_y);
 
             // TODO: Finish that 2D Sprites Test ROM
             const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
@@ -445,10 +495,12 @@ pub const Ppu = struct {
             const tile = self.vram.buf[tile_base + tile_offset];
             const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile;
 
+            const global_x = @truncate(u9, @bitCast(u16, local_x + sprite_x));
+
             // Sprite Palette starts at 0x0500_0200
             if (pal_id != 0) {
                 const bgr555 = self.palette.read(u16, 0x200 + pal_id * 2);
-                copyToSpriteBuffer(self.bld.cnt, &self.scanline, x, bgr555);
+                drawSpritePixel(self.bld.cnt, &self.scanline, sprite.attr0, global_x, bgr555);
             }
         }
     }
@@ -475,10 +527,10 @@ pub const Ppu = struct {
             aff_x += self.aff_bg[n - 2].pa;
             aff_y += self.aff_bg[n - 2].pc;
 
-            const x = @bitCast(u32, ix);
+            const _x = @truncate(u9, @bitCast(u32, ix));
-            const y = @bitCast(u32, iy);
+            const _y = @truncate(u8, @bitCast(u32, iy));
 
-            const win_bounds = self.windowBounds(@truncate(u9, x), @truncate(u8, y));
+            const win_bounds = self.windowBounds(_x, _y);
             if (!shouldDrawBackground(self, n, win_bounds, i)) continue;
 
             if (self.bg[n].cnt.display_overflow.read()) {
@@ -486,6 +538,9 @@ pub const Ppu = struct {
                 iy = if (iy > px_height) @rem(iy, px_height) else if (iy < 0) px_height + @rem(iy, px_height) else iy;
             } else if (ix > px_width or iy > px_height or ix < 0 or iy < 0) continue;
 
+            const x = @bitCast(u32, ix);
+            const y = @bitCast(u32, iy);
+
             const tile_id: u32 = self.vram.read(u8, screen_base + ((y / 8) * @bitCast(u32, tile_width) + (x / 8)));
             const row = y & 7;
             const col = x & 7;
@@ -493,10 +548,7 @@ pub const Ppu = struct {
             const tile_addr = char_base + (tile_id * 0x40) + (row * 0x8) + col;
             const pal_id: u16 = self.vram.buf[tile_addr];
 
-            if (pal_id != 0) {
+            if (pal_id != 0) self.drawBackgroundPixel(n, i, self.palette.read(u16, pal_id * 2));
-                const bgr555 = self.palette.read(u16, pal_id * 2);
-                self.copyToBackgroundBuffer(n, win_bounds, i, bgr555);
-            }
         }
 
         // Update BGxX and BGxY
@@ -551,10 +603,7 @@ pub const Ppu = struct {
             // and then we can index the palette
             const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(entry.pal_bank.read(), col, tile) else tile;
 
-            if (pal_id != 0) {
+            if (pal_id != 0) self.drawBackgroundPixel(n, i, self.palette.read(u16, pal_id * 2));
-                const bgr555 = self.palette.read(u16, pal_id * 2);
-                self.copyToBackgroundBuffer(n, win_bounds, i, bgr555);
-            }
         }
     }
 
@@ -573,11 +622,10 @@ pub const Ppu = struct {
 
         switch (bg_mode) {
             0x0 => {
-                const fb_base = framebuf_pitch * @as(usize, scanline);
+                const framebuf_base = width * @as(usize, scanline);
                 if (obj_enable) self.fetchSprites();
 
-                var layer: usize = 0;
+                for (0..4) |layer| {
-                while (layer < 4) : (layer += 1) {
                     self.drawSprites(@truncate(u2, layer));
                     if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0);
                     if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1);
@@ -585,93 +633,57 @@ pub const Ppu = struct {
                     if (layer == self.bg[3].cnt.priority.read() and bg_enable >> 3 & 1 == 1) self.drawBackground(3);
                 }
 
-                // Copy Drawn Scanline to Frame Buffer
+                self.drawTextMode(framebuf_base);
-                // If there are any nulls present in self.scanline it means that no background drew a pixel there, so draw backdrop
-                for (self.scanline.top()) |maybe_px, i| {
-                    const maybe_top = maybe_px;
-                    const maybe_btm = self.scanline.btm()[i];
-
-                    const bgr555 = self.getBgr555(maybe_top, maybe_btm);
-                    std.mem.writeIntNative(u32, self.framebuf.get(.Emulator)[fb_base + i * @sizeOf(u32) ..][0..@sizeOf(u32)], rgba888(bgr555));
-                }
-
-                // 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);
             },
             0x1 => {
-                const fb_base = framebuf_pitch * @as(usize, scanline);
+                const framebuf_base = width * @as(usize, scanline);
                 if (obj_enable) self.fetchSprites();
 
-                var layer: usize = 0;
+                for (0..4) |layer| {
-                while (layer < 4) : (layer += 1) {
                     self.drawSprites(@truncate(u2, layer));
                     if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0);
                     if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1);
                     if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2);
                 }
 
-                // Copy Drawn Scanline to Frame Buffer
+                self.drawTextMode(framebuf_base);
-                // If there are any nulls present in self.scanline.top() it means that no background drew a pixel there, so draw backdrop
-                for (self.scanline.top()) |maybe_px, i| {
-                    const maybe_top = maybe_px;
-                    const maybe_btm = self.scanline.btm()[i];
-
-                    const bgr555 = self.getBgr555(maybe_top, maybe_btm);
-                    std.mem.writeIntNative(u32, self.framebuf.get(.Emulator)[fb_base + i * @sizeOf(u32) ..][0..@sizeOf(u32)], rgba888(bgr555));
-                }
-
-                // 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);
             },
             0x2 => {
-                const fb_base = framebuf_pitch * @as(usize, scanline);
+                const framebuf_base = width * @as(usize, scanline);
                 if (obj_enable) self.fetchSprites();
 
-                var layer: usize = 0;
+                for (0..4) |layer| {
-                while (layer < 4) : (layer += 1) {
                     self.drawSprites(@truncate(u2, layer));
                     if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2);
                     if (layer == self.bg[3].cnt.priority.read() and bg_enable >> 3 & 1 == 1) self.drawAffineBackground(3);
                 }
 
-                // Copy Drawn Scanline to Frame Buffer
+                self.drawTextMode(framebuf_base);
-                // If there are any nulls present in self.scanline.top() it means that no background drew a pixel there, so draw backdrop
-                for (self.scanline.top()) |maybe_px, i| {
-                    const maybe_top = maybe_px;
-                    const maybe_btm = self.scanline.btm()[i];
-
-                    const bgr555 = self.getBgr555(maybe_top, maybe_btm);
-                    std.mem.writeIntNative(u32, self.framebuf.get(.Emulator)[fb_base + i * @sizeOf(u32) ..][0..@sizeOf(u32)], rgba888(bgr555));
-                }
-
-                // 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);
             },
             0x3 => {
-                const vram_base = width * @sizeOf(u16) * @as(usize, scanline);
+                const vram_base = width * @as(usize, scanline);
-                const fb_base = framebuf_pitch * @as(usize, scanline);
+                const framebuf_base = width * @as(usize, scanline);
 
-                var i: usize = 0;
+                // FIXME: @ptrCast between slices changing the length isn't implemented yet
-                while (i < width) : (i += 1) {
+                const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf));
-                    const bgr555 = self.vram.read(u16, vram_base + i * @sizeOf(u16));
+                const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
-                    std.mem.writeIntNative(u32, self.framebuf.get(.Emulator)[fb_base + i * @sizeOf(u32) ..][0..@sizeOf(u32)], rgba888(bgr555));
+
+                for (vram_buf[vram_base .. vram_base + width], 0..) |bgr555, i| {
+                    framebuf[framebuf_base + i] = rgba888(bgr555);
                 }
             },
             0x4 => {
                 const sel = self.dispcnt.frame_select.read();
-                const vram_base = width * @as(usize, scanline) + if (sel) 0xA000 else @as(usize, 0);
-                const fb_base = framebuf_pitch * @as(usize, scanline);
 
-                // Render Current Scanline
+                const vram_base = width * @as(usize, scanline) + if (sel) 0xA000 else @as(usize, 0);
-                for (self.vram.buf[vram_base .. vram_base + width]) |byte, i| {
+                const framebuf_base = width * @as(usize, scanline);
-                    const bgr555 = self.palette.read(u16, @as(u16, byte) * @sizeOf(u16));
+
-                    std.mem.writeIntNative(u32, self.framebuf.get(.Emulator)[fb_base + i * @sizeOf(u32) ..][0..@sizeOf(u32)], rgba888(bgr555));
+                // FIXME: @ptrCast between slices changing the length isn't implemented yet
+                const pal_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.palette.buf));
+                const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
+
+                for (self.vram.buf[vram_base .. vram_base + width], 0..) |pal_id, i| {
+                    framebuf[framebuf_base + i] = rgba888(pal_buf[pal_id]);
                 }
             },
             0x5 => {
@@ -679,28 +691,65 @@ pub const Ppu = struct {
                 const m5_height = 128;
 
                 const sel = self.dispcnt.frame_select.read();
-                const vram_base = m5_width * @sizeOf(u16) * @as(usize, scanline) + if (sel) 0xA000 else @as(usize, 0);
+                const vram_base = m5_width * @as(usize, scanline) + if (sel) 0xA000 else @as(usize, 0);
-                const fb_base = framebuf_pitch * @as(usize, scanline);
+                const framebuf_base = width * @as(usize, scanline);
 
-                var i: usize = 0;
+                // FIXME: @ptrCast between slices changing the length isn't implemented yet
-                while (i < width) : (i += 1) {
+                const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf));
-                    // If we're outside of the bounds of mode 5, draw the background colour
+                const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
-                    const bgr555 =
-                        if (scanline < m5_height and i < m5_width) self.vram.read(u16, vram_base + i * @sizeOf(u16)) else self.palette.backdrop();
 
-                    std.mem.writeIntNative(u32, self.framebuf.get(.Emulator)[fb_base + i * @sizeOf(u32) ..][0..@sizeOf(u32)], rgba888(bgr555));
+                for (0..width) |i| {
+                    const bgr555 = if (scanline < m5_height and i < m5_width) vram_buf[vram_base + i] else self.palette.backdrop();
+                    framebuf[framebuf_base + i] = rgba888(bgr555);
                 }
             },
             else => std.debug.panic("[PPU] TODO: Implement BG Mode {}", .{bg_mode}),
         }
     }
 
-    fn getBgr555(self: *Self, maybe_top: ?u16, maybe_btm: ?u16) u16 {
+    fn drawTextMode(self: *Self, framebuf_base: usize) void {
-        if (maybe_btm) |btm| {
+        // Copy Drawn Scanline to Frame Buffer
-            return switch (self.bld.cnt.mode.read()) {
+        // If there are any nulls present in self.scanline.top() it means that no background drew a pixel there, so draw backdrop
-                0b00 => if (maybe_top) |top| top else btm,
+
-                0b01 => if (maybe_top) |top| alphaBlend(btm, top, self.bld.alpha) else btm,
+        // FIXME: @ptrCast between slices changing the length isn't implemented yet
-                0b10 => blk: {
+        const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
+
+        for (self.scanline.top(), 0..) |maybe_top, i| {
+            const maybe_btm = self.scanline.btm()[i];
+
+            const bgr555 = self.getBgr555(maybe_top, maybe_btm);
+            framebuf[framebuf_base + i] = rgba888(bgr555);
+        }
+
+        // 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);
+    }
+
+    fn getBgr555(self: *Self, maybe_top: Scanline.Pixel, maybe_btm: Scanline.Pixel) u16 {
+        return switch (self.bld.cnt.mode.read()) {
+            0b00 => switch (maybe_top) {
+                .set, .obj_set => |top| top,
+                else => self.palette.backdrop(),
+            },
+            0b01 => switch (maybe_top) {
+                .set, .obj_set => |top| switch (maybe_btm) {
+                    .set, .obj_set => |btm| alphaBlend(top, btm, self.bld.alpha), // ALPHA_BLEND
+                    else => top,
+                },
+                else => switch (maybe_btm) {
+                    .set, .obj_set => |btm| btm,
+                    else => self.palette.backdrop(),
+                },
+            },
+            0b10 => switch (maybe_btm) {
+                .set, .obj_set => |btm| blk: {
+                    // If there's a top pixel + this btm pixel came from a sprite
+                    // don't display top pixel + don't blend btm pixel
+                    if (maybe_btm == .obj_set and maybe_top.isSet()) break :blk btm;
+
+                    // BLD_WHITE
                     const evy: u16 = self.bld.y.evy.read();
 
                     const r = btm & 0x1F;
@@ -713,110 +762,191 @@ pub const Ppu = struct {
 
                     break :blk (bld_b << 10) | (bld_g << 5) | bld_r;
                 },
-                0b11 => blk: {
+                else => switch (maybe_top) {
+                    .set, .obj_set => |top| top,
+                    else => self.palette.backdrop(),
+                },
+            },
+            0b11 => switch (maybe_btm) {
+                .set, .obj_set => |btm| blk: {
+                    // If there's a top pixel + this btm pixel came from a sprite
+                    // don't display top pixel + don't blend btm pixel
+                    if (maybe_btm == .obj_set and maybe_top.isSet()) break :blk btm;
+
+                    // BLD_BLACK
                     const evy: u16 = self.bld.y.evy.read();
 
-                    const btm_r = btm & 0x1F;
+                    const r = btm & 0x1F;
-                    const btm_g = (btm >> 5) & 0x1F;
+                    const g = (btm >> 5) & 0x1F;
-                    const btm_b = (btm >> 10) & 0x1F;
+                    const b = (btm >> 10) & 0x1F;
 
-                    const bld_r = btm_r - ((btm_r * evy) >> 4);
+                    const bld_r = r - ((r * evy) >> 4);
-                    const bld_g = btm_g - ((btm_g * evy) >> 4);
+                    const bld_g = g - ((g * evy) >> 4);
-                    const bld_b = btm_b - ((btm_b * evy) >> 4);
+                    const bld_b = b - ((b * evy) >> 4);
 
                     break :blk (bld_b << 10) | (bld_g << 5) | bld_r;
                 },
-            };
+                else => switch (maybe_top) {
-        }
+                    .set, .obj_set => |top| top,
-
+                    else => self.palette.backdrop(),
-        if (maybe_top) |top| return top;
+                },
-        return self.palette.backdrop();
+            },
+        };
     }
 
-    fn copyToBackgroundBuffer(self: *Self, comptime n: u2, bounds: ?WindowBounds, i: usize, bgr555: u16) void {
+    fn drawBackgroundPixel(self: *Self, comptime layer: u2, i: usize, bgr555: u16) void {
-        if (self.bld.cnt.mode.read() != 0b00) {
+        // When writing to the scanline buffer, we want to be aware of a top and bottom layer. Some preconditions were
-            // Standard Alpha Blending
+        // already determined by shouldDrawBackground, so we should be aware of what we can assume to be true or false
-            const a_layers = self.bld.cnt.layer_a.read();
-            const is_blend_enabled = (a_layers >> n) & 1 == 1;
 
-            // If Alpha Blending is enabled and we've found an eligible layer for
+        switch (self.bld.cnt.mode.read()) {
-            // Pixel A, store the pixel in the bottom pixel buffer
+            0b00 => {}, // pass through
+            0b01 => {
+                // We are to alpha blend here so we should pay attention to which layer ths pixel should be written to
+                // FIXME: We redo work here that we've already figured out. Is this worth refactorning?
 
-            const win_part = if (bounds) |win| blk: {
+                // If the current layer is makred as Layer A, write to top buffer
-                // Window Enabled
+                const top_layer = self.bld.cnt.layer_a.read();
-                break :blk switch (win) {
+                const is_top_layer = (top_layer >> layer) & 1 == 1;
-                    .win0 => self.win.in.w0_bld.read(),
-                    .win1 => self.win.in.w1_bld.read(),
-                    .out => self.win.out.out_bld.read(),
-                };
-            } else true;
 
-            if (win_part and is_blend_enabled) {
+                if (is_top_layer) {
-                self.scanline.btm()[i] = bgr555;
+                    self.scanline.top()[i] = Scanline.Pixel.from(.Background, bgr555);
-                return;
+                    return;
-            }
+                }
+
+                // If the current layer is marked as Layer B, we want to continue if there's an available space on that buffer
+                const btm_layer = self.bld.cnt.layer_b.read();
+                const is_btm_layer = (btm_layer >> layer) & 1 == 1;
+
+                if (is_btm_layer) {
+                    self.scanline.btm()[i] = Scanline.Pixel.from(.Background, bgr555);
+                    return;
+                }
+
+                // The code we're about to fall-through to assumes that alpha blending takes place. In order to withold all invariants
+                // we need to discard anything that might be in the bottom buffer.
+                self.scanline.btm()[i] = .hidden;
+            },
+            0b10, 0b11 => {
+                // BLD_WHITE, BLD_BLACK
+                // Weare to blend with White or black here. By convention we store regular ol' pixels in the top layer, which means that if we want to
+                // treat some pixels (in this case the ones relegated to blending) we need to keep them separate as we can't apply the blending to the top layer.
+
+                // While in these modes, (and since this is a scanline renderer), the bottom layer will be completely unused. While it's a bit unintuitive, since we'll
+                // be moving layer A pixels there, we will repurpose the bottom layer as the "to blend", layer
+
+                // If the current layer is makred as Layer A, write to top buffer
+                const top_layer = self.bld.cnt.layer_a.read();
+                const is_top_layer = (top_layer >> layer) & 1 == 1;
+
+                if (is_top_layer) {
+                    const pixel = self.scanline.btm()[i];
+
+                    // FIXME: Can't I do this check ealier? Test Amazing Mirror File Select, bld_demo.gba
+                    if (!pixel.isSet())
+                        self.scanline.btm()[i] = Scanline.Pixel.from(.Background, bgr555); // this is intentional
+
+                    return;
+                }
+            },
         }
 
-        self.scanline.top()[i] = bgr555;
+        // If we aren't blending here at all, just add the pixel to the top layer
+        self.scanline.top()[i] = Scanline.Pixel.from(.Background, bgr555);
     }
 
     const WindowBounds = enum { win0, win1, out };
 
     fn windowBounds(self: *Self, x: u9, y: u8) ?WindowBounds {
-        const win0 = self.dispcnt.win_enable.read() & 1 == 1;
+        _ = y;
-        const win1 = (self.dispcnt.win_enable.read() >> 1) & 1 == 1;
+        _ = x;
-        const winObj = self.dispcnt.obj_win_enable.read();
+        _ = self;
+        // FIXME: Remove to enable PPU Window Emulation
+        return null;
 
-        if (!(win0 or win1 or winObj)) return null;
+        // const win0 = self.dispcnt.win_enable.read() & 1 == 1;
+        // const win1 = (self.dispcnt.win_enable.read() >> 1) & 1 == 1;
+        // const winObj = self.dispcnt.obj_win_enable.read();
 
-        if (win0 and self.win.inRange(0, x, y)) return .win0;
+        // if (!(win0 or win1 or winObj)) return null;
-        if (win1 and self.win.inRange(1, x, y)) return .win1;
 
-        return .out;
+        // if (win0 and self.win.inRange(0, x, y)) return .win0;
+        // if (win1 and self.win.inRange(1, x, y)) return .win1;
+
+        // return .out;
     }
 
-    fn shouldDrawBackground(self: *Self, comptime n: u2, bounds: ?WindowBounds, i: usize) bool {
+    fn shouldDrawBackground(self: *Self, comptime layer: u2, bounds: ?WindowBounds, i: usize) bool {
-        // If a pixel has been drawn on the top layer, it's because:
+        switch (self.bld.cnt.mode.read()) {
-        // 1. The pixel is to be blended with a pixel on the bottom layer
+            0b00 => if (self.scanline.top()[i].isSet()) return false, // pass through
-        // 2. The pixel is not to be blended at all
+            0b01 => blk: {
-        // Also, if we find a pixel on the top layer we don't need to bother with this I think?
+                // BLD_ALPHA
-        if (self.scanline.top()[i] != null) return false;
 
-        if (bounds) |win| {
+                // If the current layer is marked as Layer B, we want to continue if there's an available space on that buffer
-            switch (win) {
+                const btm_layer = self.bld.cnt.layer_b.read();
-                .win0 => if ((self.win.in.w0_bg.read() >> n) & 1 == 0) return false,
+                const is_btm_layer = (btm_layer >> layer) & 1 == 1;
-                .win1 => if ((self.win.in.w1_bg.read() >> n) & 1 == 0) return false,
+
-                .out => if ((self.win.out.out_bg.read() >> n) & 1 == 0) return false,
+                if (is_btm_layer) {
+                    if (self.scanline.btm()[i].isSet()) return false;
+
+                    // In some previous iteration we have determined that an opaque pixel was drawn at this position
+                    // therefore there's no reason to draw anything here
+                    if (self.scanline.btm()[i] == .hidden) return false;
+
+                    // We have a pixel and we know it to be a part of hte bottom layer.
+                    // when getBgr555 sees that thre's a pixel in the top and bottom layer it chooses to blend the two
+                    // Meaning that if we want to prevent Alpha Blending from happening (like for example if a window is preventing it)
+                    // we need to make that happen now.
+
+                    // We can do this by not drawing the bottom pixel, since with alpha blending disabled it wouldn't be visible anyways
+
+                    // if (bounds) |win| {
+                    //     switch (win) {
+                    //         .win0 => if (!self.win.in.w0_bld.read()) return false,
+                    //         .win1 => if (!self.win.in.w1_bld.read()) return false,
+                    //         .out => if (!self.win.out.out_bld.read()) return false,
+                    //     }
+                    // }
+
+                    break :blk;
+                }
+
+                if (self.scanline.top()[i].isSet()) return false;
+            },
+            0b10, 0b11 => {
+                // BLD_WHITE and BLD_BLACK
+
+                // we want to treat the bottom layer the same as the top (despite it being repurposed)
+                // so we should apply the same logic to the bottom layer
+
+                if (self.scanline.top()[i].isSet()) return false;
+
+                // If the bottom pixel comes rom a sprite, draw the pixel anyways
+                if (self.scanline.btm()[i] == .set) return false;
+            },
+        }
+
+        // At this point we will have exited early if we determined that we'd be overwriting a pixel
+        // with a higher priority. We can now move own to determining whether the pixel is visible or not
+
+        // The first thing that may or may not affect visibility is windowing. We should check to see if ths pixel is in bounds
+        // of of the background Window if it is enabled
+        // TODO: Do Window Bounds checking here instead of outside this function?
+
+        if (bounds) |window| {
+            // If this parameter is non-null, we know that:
+            // 1. Win0, Win1 or WinObj are enabled
+            // 2. This specific pixel exists within the range of a window
+
+            // Here, we check to see if the Window for this background is enabled. If not, we won't render the pixel
+            // FIXME: We perform needless computations on Window Bounds by checking for enable here after we've already computed this information
+            switch (window) {
+                .win0 => if ((self.win.in.w0_bg.read() >> layer) & 1 == 0) return false,
+                .win1 => if ((self.win.in.w1_bg.read() >> layer) & 1 == 0) return false,
+                .out => if ((self.win.out.out_bg.read() >> layer) & 1 == 0) return false,
             }
         }
 
-        if (self.scanline.btm()[i] != null) {
+        // Otherwise, return true
-            // The pixel found in the bottom layer is:
-            // 1. From a higher priority background
-            // 2. From a background that is marked for blending (Pixel A)
-
-            // If Alpha Blending isn't enabled, then we've already found a higher prio
-            // pixel, we can return early
-            if (self.bld.cnt.mode.read() != 0b01) return false;
-
-            const b_layers = self.bld.cnt.layer_b.read();
-
-            const win_part = if (bounds) |win| blk: {
-                // Window Enabled
-                break :blk switch (win) {
-                    .win0 => self.win.in.w0_bld.read(),
-                    .win1 => self.win.in.w1_bld.read(),
-                    .out => self.win.out.out_bld.read(),
-                };
-            } else true;
-
-            // If the Background is not marked for blending, we've already found
-            // a higher priority pixel, move on.
-
-            const is_blend_enabled = win_part and ((b_layers >> n) & 1 == 1);
-            if (!is_blend_enabled) return false;
-        }
-
         return true;
     }
 
@@ -856,8 +986,7 @@ pub const Ppu = struct {
             cpu.handleInterrupt();
         }
 
-        // See if HBlank DMA is present and not enabled
+        // If we're not also in VBlank, attempt to run any pending DMA Reqs
-
         if (!self.dispstat.vblank.read())
             dma.onBlanking(cpu.bus, .HBlank);
 
@@ -1299,56 +1428,124 @@ fn alphaBlend(top: u16, btm: u16, bldalpha: io.BldAlpha) u16 {
 }
 
 fn shouldDrawSprite(bldcnt: io.BldCnt, scanline: *Scanline, x: u9) bool {
-    if (scanline.top()[x] != null) return false;
+    switch (bldcnt.mode.read()) {
+        0b00 => if (scanline.top()[x].isSet()) return false,
+        0b01 => {
+            // BLD_ALPHA
 
-    if (scanline.btm()[x] != null) {
+            // We want to check if we're concerned aout the bottom layer first
-        if (bldcnt.mode.read() != 0b01) return false;
+            // because if so, the top layer already having a pixel is OK
+            const btm_layers = bldcnt.layer_b.read();
+            const is_btm_layer = (btm_layers >> 4) & 1 == 1;
 
-        const b_layers = bldcnt.layer_b.read();
+            if (is_btm_layer and scanline.btm()[x].isSet()) return false;
-        const is_blend_enabled = (b_layers >> 4) & 1 == 1;
+
-        if (!is_blend_enabled) return false;
+            if (scanline.top()[x].isSet()) return false;
+        },
+        0b10, 0b11 => {
+            if (scanline.top()[x].isSet()) return false;
+            if (scanline.btm()[x].isSet()) return false;
+        },
     }
 
     return true;
 }
 
-fn copyToSpriteBuffer(bldcnt: io.BldCnt, scanline: *Scanline, x: u9, bgr555: u16) void {
+fn drawSpritePixel(bldcnt: io.BldCnt, scanline: *Scanline, attr0: Attr0, x: u9, bgr555: u16) void {
-    if (bldcnt.mode.read() != 0b00) {
+    if (attr0.mode.read() == 1) {
-        // Alpha Blending
+        // TODO: Force Alpha Blend in all moes?
-        const a_layers = bldcnt.layer_a.read();
+        scanline.top()[x] = Scanline.Pixel.from(.Sprite, bgr555);
-        const is_blend_enabled = (a_layers >> 4) & 1 == 1;
+        return;
-
-        if (is_blend_enabled) {
-            scanline.btm()[x] = bgr555;
-            return;
-        }
     }
 
-    scanline.top()[x] = bgr555;
+    switch (bldcnt.mode.read()) {
+        0b00 => {}, // pass through
+        0b01 => {
+            // BLD_ALPHA
+            const top_layers = bldcnt.layer_a.read();
+            const is_top_layer = (top_layers >> 4) & 1 == 1;
+
+            if (is_top_layer) {
+                scanline.top()[x] = Scanline.Pixel.from(.Sprite, bgr555);
+                return;
+            }
+
+            const btm_layers = bldcnt.layer_b.read();
+            const is_btm_layer = (btm_layers >> 4) & 1 == 1;
+
+            if (is_btm_layer) {
+                scanline.btm()[x] = Scanline.Pixel.from(.Sprite, bgr555);
+                return;
+            }
+
+            // We're rendering a normal pixel that isn't alpha blended
+            // we can mark the pixel on the bottom layer as hidden
+            scanline.btm()[x] = .hidden;
+        },
+
+        0b10, 0b11 => {
+            // This is explained in drawBackgroundPixel, we're reusing the bottom layer to draw layer A pixels we will want to
+            // later blend with WHITE or BLACK
+
+            const top_layers = bldcnt.layer_a.read();
+            const is_top_layer = (top_layers >> 4) & 1 == 1;
+
+            if (is_top_layer) {
+                scanline.btm()[x] = Scanline.Pixel.from(.Sprite, bgr555); // This is intentional
+                return;
+            }
+        },
+    }
+
+    scanline.top()[x] = Scanline.Pixel.from(.Sprite, bgr555);
 }
 
 const Scanline = struct {
     const Self = @This();
 
-    layers: [2][]?u16,
+    const Pixel = union(enum) {
-    buf: []?u16,
+        // TODO: Rename
+        const Layer = enum { Background, Sprite };
+
+        set: u16,
+        obj_set: u16,
+        unset: void,
+        hidden: void,
+
+        fn from(comptime layer: Layer, bgr555: u16) Pixel {
+            return switch (layer) {
+                .Background => .{ .set = bgr555 },
+                .Sprite => .{ .obj_set = bgr555 },
+            };
+        }
+
+        pub fn isSet(self: @This()) bool {
+            return switch (self) {
+                .set, .obj_set => true,
+                .unset, .hidden => false,
+            };
+        }
+    };
+
+    layers: [2][]Pixel,
+    buf: []Pixel,
 
     allocator: Allocator,
 
     fn init(allocator: Allocator) !Self {
-        const buf = try allocator.alloc(?u16, width * 2); // Top & Bottom Scanline
+        const buf = try allocator.alloc(Pixel, width * 2); // Top & Bottom Scanline
-        std.mem.set(?u16, buf, null);
+        std.mem.set(Pixel, buf, .unset);
 
         return .{
             // Top & Bototm Layers
-            .layers = [_][]?u16{ buf[0..][0..width], buf[width..][0..width] },
+            .layers = [_][]Pixel{ buf[0..][0..width], buf[width..][0..width] },
             .buf = buf,
             .allocator = allocator,
         };
     }
 
     fn reset(self: *Self) void {
-        std.mem.set(?u16, self.buf, null);
+        std.mem.set(Pixel, self.buf, .unset);
     }
 
     fn deinit(self: *Self) void {
@@ -1356,11 +1553,11 @@ const Scanline = struct {
         self.* = undefined;
     }
 
-    fn top(self: *Self) []?u16 {
+    fn top(self: *Self) []Pixel {
         return self.layers[0];
     }
 
-    fn btm(self: *Self) []?u16 {
+    fn btm(self: *Self) []Pixel {
         return self.layers[1];
     }
 };

src/core/ppu/Palette.zig

@@ -42,6 +42,6 @@ pub fn deinit(self: *Self) void {
     self.* = undefined;
 }
 
-pub fn backdrop(self: *const Self) u16 {
+pub inline fn backdrop(self: *const Self) u16 {
-    return self.read(u16, 0);
+    return std.mem.readIntNative(u16, self.buf[0..2]);
 }

src/core/scheduler.zig

@@ -31,61 +31,55 @@ pub const Scheduler = struct {
     }
 
     pub fn handleEvent(self: *Self, cpu: *Arm7tdmi) void {
-        if (self.queue.removeOrNull()) |event| {
+        const event = self.queue.remove();
-            const late = self.tick - event.tick;
+        const late = self.tick - event.tick;
 
-            switch (event.kind) {
+        switch (event.kind) {
-                .HeatDeath => {
+            .HeatDeath => {
-                    log.err("u64 overflow. This *actually* should never happen.", .{});
+                log.err("u64 overflow. This *actually* should never happen.", .{});
-                    unreachable;
+                unreachable;
-                },
+            },
-                .Draw => {
+            .Draw => {
-                    // The end of a VDraw
+                // The end of a VDraw
-                    cpu.bus.ppu.drawScanline();
+                cpu.bus.ppu.drawScanline();
-                    cpu.bus.ppu.onHdrawEnd(cpu, late);
+                cpu.bus.ppu.onHdrawEnd(cpu, late);
-                },
+            },
-                .TimerOverflow => |id| {
+            .TimerOverflow => |id| {
-                    switch (id) {
+                switch (id) {
-                        inline 0...3 => |idx| cpu.bus.tim[idx].onTimerExpire(cpu, late),
+                    inline 0...3 => |idx| cpu.bus.tim[idx].onTimerExpire(cpu, late),
-                    }
+                }
-                },
+            },
-                .ApuChannel => |id| {
+            .ApuChannel => |id| {
-                    switch (id) {
+                switch (id) {
-                        0 => cpu.bus.apu.ch1.onToneSweepEvent(late),
+                    0 => cpu.bus.apu.ch1.onToneSweepEvent(late),
-                        1 => cpu.bus.apu.ch2.onToneEvent(late),
+                    1 => cpu.bus.apu.ch2.onToneEvent(late),
-                        2 => cpu.bus.apu.ch3.onWaveEvent(late),
+                    2 => cpu.bus.apu.ch3.onWaveEvent(late),
-                        3 => cpu.bus.apu.ch4.onNoiseEvent(late),
+                    3 => cpu.bus.apu.ch4.onNoiseEvent(late),
-                    }
+                }
-                },
+            },
-                .RealTimeClock => {
+            .RealTimeClock => {
-                    const device = &cpu.bus.pak.gpio.device;
+                const device = &cpu.bus.pak.gpio.device;
-                    if (device.kind != .Rtc or device.ptr == null) return;
+                if (device.kind != .Rtc or device.ptr == null) return;
 
-                    const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), device.ptr.?));
+                const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), device.ptr.?));
-                    clock.onClockUpdate(late);
+                clock.onClockUpdate(late);
-                },
+            },
-                .FrameSequencer => cpu.bus.apu.onSequencerTick(late),
+            .FrameSequencer => cpu.bus.apu.onSequencerTick(late),
-                .SampleAudio => cpu.bus.apu.sampleAudio(late),
+            .SampleAudio => cpu.bus.apu.sampleAudio(late),
-                .HBlank => cpu.bus.ppu.onHblankEnd(cpu, late), // The end of a HBlank
+            .HBlank => cpu.bus.ppu.onHblankEnd(cpu, late), // The end of a HBlank
-                .VBlank => cpu.bus.ppu.onHdrawEnd(cpu, late), // The end of a VBlank
+            .VBlank => cpu.bus.ppu.onHdrawEnd(cpu, late), // The end of a VBlank
-            }
         }
     }
 
     /// Removes the **first** scheduled event of type `needle`
     pub fn removeScheduledEvent(self: *Self, needle: EventKind) void {
-        var it = self.queue.iterator();
+        for (self.queue.items, 0..) |event, i| {
-
-        var i: usize = 0;
-        while (it.next()) |event| : (i += 1) {
             if (std.meta.eql(event.kind, needle)) {
 
-                // This invalidates the iterator
+                // invalidates the slice we're iterating over
                 _ = self.queue.removeIndex(i);
 
-                // Since removing something from the PQ invalidates the iterator,
+                log.debug("Removed {?}@{}", .{ event.kind, event.tick });
-                // this implementation can safely only remove the first instance of
-                // a Scheduled Event. Exit Early
                 break;
             }
         }

src/main.zig

@@ -4,14 +4,17 @@ const known_folders = @import("known_folders");
 const clap = @import("clap");
 
 const config = @import("config.zig");
+const emu = @import("core/emu.zig");
 
 const Gui = @import("platform.zig").Gui;
 const Bus = @import("core/Bus.zig");
 const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
 const Scheduler = @import("core/scheduler.zig").Scheduler;
 const FilePaths = @import("util.zig").FilePaths;
-
+const FpsTracker = @import("util.zig").FpsTracker;
 const Allocator = std.mem.Allocator;
+const Atomic = std.atomic.Atomic;
+
 const log = std.log.scoped(.Cli);
 const width = @import("core/ppu.zig").width;
 const height = @import("core/ppu.zig").height;
@@ -22,37 +25,49 @@ const params = clap.parseParamsComptime(
     \\-h, --help            Display this help and exit.
     \\-s, --skip            Skip BIOS.
     \\-b, --bios <str>      Optional path to a GBA BIOS ROM.
+    \\ --gdb                Run ZBA from the context of a GDB Server
     \\<str>                 Path to the GBA GamePak ROM.
     \\
 );
 
-pub fn main() anyerror!void {
+pub fn main() void {
     // Main Allocator for ZBA
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     defer std.debug.assert(!gpa.deinit());
 
     const allocator = gpa.allocator();
 
-    // Determine the Data Directory (stores saves, config file, etc.)
+    // Determine the Data Directory (stores saves)
     const data_path = blk: {
         const result = known_folders.getPath(allocator, .data);
-        const option = result catch |e| exitln("interrupted while attempting to find a data directory: {}", .{e});
+        const option = result catch |e| exitln("interrupted while determining the data folder: {}", .{e});
-        const path = option orelse exitln("no valid data directory could be found", .{});
+        const path = option orelse exitln("no valid data folder found", .{});
-        ensureDirectoriesExist(path) catch |e| exitln("failed to create directories under \"{s}\": {}", .{ path, e });
+        ensureDataDirsExist(path) catch |e| exitln("failed to create folders under \"{s}\": {}", .{ path, e });
 
         break :blk path;
     };
     defer allocator.free(data_path);
 
+    // Determine the Config Directory
+    const config_path = blk: {
+        const result = known_folders.getPath(allocator, .roaming_configuration);
+        const option = result catch |e| exitln("interreupted while determining the config folder: {}", .{e});
+        const path = option orelse exitln("no valid config folder found", .{});
+        ensureConfigDirExists(path) catch |e| exitln("failed to create required folder \"{s}\": {}", .{ path, e });
+
+        break :blk path;
+    };
+    defer allocator.free(config_path);
+
     // Parse CLI
     const result = clap.parse(clap.Help, &params, clap.parsers.default, .{}) catch |e| exitln("failed to parse cli: {}", .{e});
     defer result.deinit();
 
     // TODO: Move config file to XDG Config directory?
-    const config_path = configFilePath(allocator, data_path) catch |e| exitln("failed to determine the config file path for ZBA: {}", .{e});
+    const cfg_file_path = configFilePath(allocator, config_path) catch |e| exitln("failed to ready config file for access: {}", .{e});
-    defer allocator.free(config_path);
+    defer allocator.free(cfg_file_path);
 
-    config.load(allocator, config_path) catch |e| exitln("failed to read config file: {}", .{e});
+    config.load(allocator, cfg_file_path) catch |e| exitln("failed to load config file: {}", .{e});
 
     const paths = handleArguments(allocator, data_path, &result) catch |e| exitln("failed to handle cli arguments: {}", .{e});
     defer if (paths.save) |path| allocator.free(path);
@@ -76,13 +91,49 @@ pub fn main() anyerror!void {
         cpu.fastBoot();
     }
 
-    var gui = Gui.init(&bus.pak.title, &bus.apu, width, height);
+    var quit = Atomic(bool).init(false);
+    var gui = Gui.init(&bus.pak.title, &bus.apu, width, height) catch |e| exitln("failed to init gui: {}", .{e});
     defer gui.deinit();
 
-    gui.run(&cpu, &scheduler) catch |e| exitln("failed to run gui thread: {}", .{e});
+    if (result.args.gdb) {
+        const Server = @import("gdbstub").Server;
+        const EmuThing = @import("core/emu.zig").EmuThing;
+
+        var wrapper = EmuThing.init(&cpu, &scheduler);
+        var emulator = wrapper.interface(allocator);
+        defer emulator.deinit();
+
+        log.info("Ready to connect", .{});
+
+        var server = Server.init(emulator) catch |e| exitln("failed to init gdb server: {}", .{e});
+        defer server.deinit(allocator);
+
+        log.info("Starting GDB Server Thread", .{});
+
+        const thread = std.Thread.spawn(.{}, Server.run, .{ &server, allocator, &quit }) catch |e| exitln("gdb server thread crashed: {}", .{e});
+        defer thread.join();
+
+        gui.run(.{
+            .cpu = &cpu,
+            .scheduler = &scheduler,
+            .quit = &quit,
+        }) catch |e| exitln("main thread panicked: {}", .{e});
+    } else {
+        var tracker = FpsTracker.init();
+
+        const thread = std.Thread.spawn(.{}, emu.run, .{ &quit, &scheduler, &cpu, &tracker }) catch |e| exitln("emu thread panicked: {}", .{e});
+        defer thread.join();
+
+        gui.run(.{
+            .cpu = &cpu,
+            .scheduler = &scheduler,
+            .tracker = &tracker,
+            .quit = &quit,
+        }) catch |e| exitln("main thread panicked: {}", .{e});
+    }
 }
 
-pub fn handleArguments(allocator: Allocator, data_path: []const u8, result: *const clap.Result(clap.Help, &params, clap.parsers.default)) !FilePaths {
+fn handleArguments(allocator: Allocator, data_path: []const u8, result: *const clap.Result(clap.Help, &params, clap.parsers.default)) !FilePaths {
     const rom_path = romPath(result);
     log.info("ROM path: {s}", .{rom_path});
 
@@ -99,8 +150,8 @@ pub fn handleArguments(allocator: Allocator, data_path: []const u8, result: *con
     };
 }
 
-fn configFilePath(allocator: Allocator, data_path: []const u8) ![]const u8 {
+fn configFilePath(allocator: Allocator, config_path: []const u8) ![]const u8 {
-    const path = try std.fs.path.join(allocator, &[_][]const u8{ data_path, "zba", "config.toml" });
+    const path = try std.fs.path.join(allocator, &[_][]const u8{ config_path, "zba", "config.toml" });
     errdefer allocator.free(path);
 
     // We try to create the file exclusively, meaning that we err out if the file already exists.
@@ -109,7 +160,7 @@ fn configFilePath(allocator: Allocator, data_path: []const u8) ![]const u8 {
     std.fs.accessAbsolute(path, .{}) catch |e| {
         if (e != error.FileNotFound) return e;
 
-        const config_file = try std.fs.createFileAbsolute(path, .{});
+        const config_file = std.fs.createFileAbsolute(path, .{}) catch |err| exitln("failed to create \"{s}\": {}", .{ path, err });
         defer config_file.close();
 
         try config_file.writeAll(@embedFile("../example.toml"));
@@ -118,17 +169,21 @@ fn configFilePath(allocator: Allocator, data_path: []const u8) ![]const u8 {
     return path;
 }
 
-fn ensureDirectoriesExist(data_path: []const u8) !void {
+fn ensureDataDirsExist(data_path: []const u8) !void {
     var dir = try std.fs.openDirAbsolute(data_path, .{});
     defer dir.close();
 
-    // We want to make sure: %APPDATA%/zba and %APPDATA%/zba/save exist
-    // (~/.local/share/zba/save for linux, ??? for macOS)
-
     // Will recursively create directories
     try dir.makePath("zba" ++ std.fs.path.sep_str ++ "save");
 }
 
+fn ensureConfigDirExists(config_path: []const u8) !void {
+    var dir = try std.fs.openDirAbsolute(config_path, .{});
+    defer dir.close();
+
+    try dir.makePath("zba");
+}
+
 fn romPath(result: *const clap.Result(clap.Help, &params, clap.parsers.default)) []const u8 {
     return switch (result.positionals.len) {
         1 => result.positionals[0],

src/platform.zig

@@ -9,15 +9,13 @@ const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
 const Scheduler = @import("core/scheduler.zig").Scheduler;
 const FpsTracker = @import("util.zig").FpsTracker;
 
-const span = @import("util.zig").span;
-
 const gba_width = @import("core/ppu.zig").width;
 const gba_height = @import("core/ppu.zig").height;
 
 pub const sample_rate = 1 << 15;
 pub const sample_format = SDL.AUDIO_U16;
 
-const default_title: []const u8 = "ZBA";
+const default_title = "ZBA";
 
 pub const Gui = struct {
     const Self = @This();
@@ -46,7 +44,7 @@ pub const Gui = struct {
 
     program_id: gl.GLuint,
 
-    pub fn init(title: *const [12]u8, apu: *Apu, width: i32, height: i32) Self {
+    pub fn init(title: *const [12]u8, apu: *Apu, width: i32, height: i32) !Self {
         if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_EVENTS | SDL.SDL_INIT_AUDIO) < 0) panic();
         if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_PROFILE_MASK, SDL.SDL_GL_CONTEXT_PROFILE_CORE) < 0) panic();
         if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_MAJOR_VERSION, 3) < 0) panic();
@@ -55,7 +53,7 @@ pub const Gui = struct {
         const win_scale = @intCast(c_int, config.config().host.win_scale);
 
         const window = SDL.SDL_CreateWindow(
-            default_title.ptr,
+            default_title,
             SDL.SDL_WINDOWPOS_CENTERED,
             SDL.SDL_WINDOWPOS_CENTERED,
             @as(c_int, width * win_scale),
@@ -66,21 +64,21 @@ pub const Gui = struct {
         const ctx = SDL.SDL_GL_CreateContext(window) orelse panic();
         if (SDL.SDL_GL_MakeCurrent(window, ctx) < 0) panic();
 
-        gl.load(ctx, Self.glGetProcAddress) catch @panic("gl.load failed");
+        gl.load(ctx, Self.glGetProcAddress) catch {};
         if (SDL.SDL_GL_SetSwapInterval(@boolToInt(config.config().host.vsync)) < 0) panic();
 
-        const program_id = compileShaders();
+        const program_id = try compileShaders();
 
         return Self{
             .window = window,
-            .title = span(title),
+            .title = std.mem.sliceTo(title, 0),
             .ctx = ctx,
             .program_id = program_id,
             .audio = Audio.init(apu),
         };
     }
 
-    fn compileShaders() gl.GLuint {
+    fn compileShaders() !gl.GLuint {
         // TODO: Panic on Shader Compiler Failure + Error Message
         const vert_shader = @embedFile("shader/pixelbuf.vert");
         const frag_shader = @embedFile("shader/pixelbuf.frag");
@@ -91,12 +89,16 @@ pub const Gui = struct {
         gl.shaderSource(vs, 1, &[_][*c]const u8{vert_shader}, 0);
         gl.compileShader(vs);
 
+        if (!shader.didCompile(vs)) return error.VertexCompileError;
+
         const fs = gl.createShader(gl.FRAGMENT_SHADER);
         defer gl.deleteShader(fs);
 
         gl.shaderSource(fs, 1, &[_][*c]const u8{frag_shader}, 0);
         gl.compileShader(fs);
 
+        if (!shader.didCompile(fs)) return error.FragmentCompileError;
+
         const program = gl.createProgram();
         gl.attachShader(program, vs);
         gl.attachShader(program, fs);
@@ -106,7 +108,7 @@ pub const Gui = struct {
     }
 
     // Returns the VAO ID since it's used in run()
-    fn generateBuffers() [3]c_uint {
+    fn generateBuffers() struct { c_uint, c_uint, c_uint } {
         var vao_id: c_uint = undefined;
         var vbo_id: c_uint = undefined;
         var ebo_id: c_uint = undefined;
@@ -152,72 +154,86 @@ pub const Gui = struct {
         return tex_id;
     }
 
-    pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
+    const RunOptions = struct {
-        var quit = std.atomic.Atomic(bool).init(false);
+        quit: *std.atomic.Atomic(bool),
-        var tracker = FpsTracker.init();
+        tracker: ?*FpsTracker = null,
+        cpu: *Arm7tdmi,
+        scheduler: *Scheduler,
+    };
 
-        const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, scheduler, cpu, &tracker });
+    pub fn run(self: *Self, opt: RunOptions) !void {
-        defer thread.join();
+        const cpu = opt.cpu;
+        const tracker = opt.tracker;
+        const quit = opt.quit;
 
-        var title_buf: [0x100]u8 = [_]u8{0} ** 0x100;
+        var buffer_ids = Self.generateBuffers();
+        defer {
+            gl.deleteBuffers(1, &buffer_ids[2]); // EBO
+            gl.deleteBuffers(1, &buffer_ids[1]); // VBO
+            gl.deleteVertexArrays(1, &buffer_ids[0]); // VAO
+        }
+        const vao_id = buffer_ids[0];
 
-        const vao_id = Self.generateBuffers()[0];
+        const tex_id = Self.generateTexture(cpu.bus.ppu.framebuf.get(.Renderer));
-        _ = Self.generateTexture(cpu.bus.ppu.framebuf.get(.Renderer));
+        defer gl.deleteTextures(1, &tex_id);
+
+        var title_buf: [0x100]u8 = undefined;
 
         emu_loop: while (true) {
             var event: SDL.SDL_Event = undefined;
+
+            // This might be true if the emu is running via a gdbstub server
+            // and the gdb stub exits first
+            if (quit.load(.Monotonic)) break :emu_loop;
+
             while (SDL.SDL_PollEvent(&event) != 0) {
                 switch (event.type) {
                     SDL.SDL_QUIT => break :emu_loop,
                     SDL.SDL_KEYDOWN => {
-                        const io = &cpu.bus.io;
                         const key_code = event.key.keysym.sym;
+                        var keyinput = cpu.bus.io.keyinput.load(.Monotonic);
 
                         switch (key_code) {
-                            SDL.SDLK_UP => io.keyinput.up.unset(),
+                            SDL.SDLK_UP => keyinput.up.unset(),
-                            SDL.SDLK_DOWN => io.keyinput.down.unset(),
+                            SDL.SDLK_DOWN => keyinput.down.unset(),
-                            SDL.SDLK_LEFT => io.keyinput.left.unset(),
+                            SDL.SDLK_LEFT => keyinput.left.unset(),
-                            SDL.SDLK_RIGHT => io.keyinput.right.unset(),
+                            SDL.SDLK_RIGHT => keyinput.right.unset(),
-                            SDL.SDLK_x => io.keyinput.a.unset(),
+                            SDL.SDLK_x => keyinput.a.unset(),
-                            SDL.SDLK_z => io.keyinput.b.unset(),
+                            SDL.SDLK_z => keyinput.b.unset(),
-                            SDL.SDLK_a => io.keyinput.shoulder_l.unset(),
+                            SDL.SDLK_a => keyinput.shoulder_l.unset(),
-                            SDL.SDLK_s => io.keyinput.shoulder_r.unset(),
+                            SDL.SDLK_s => keyinput.shoulder_r.unset(),
-                            SDL.SDLK_RETURN => io.keyinput.start.unset(),
+                            SDL.SDLK_RETURN => keyinput.start.unset(),
-                            SDL.SDLK_RSHIFT => io.keyinput.select.unset(),
+                            SDL.SDLK_RSHIFT => keyinput.select.unset(),
                             else => {},
                         }
+
+                        cpu.bus.io.keyinput.store(keyinput.raw, .Monotonic);
                     },
                     SDL.SDL_KEYUP => {
-                        const io = &cpu.bus.io;
                         const key_code = event.key.keysym.sym;
+                        var keyinput = cpu.bus.io.keyinput.load(.Monotonic);
 
                         switch (key_code) {
-                            SDL.SDLK_UP => io.keyinput.up.set(),
+                            SDL.SDLK_UP => keyinput.up.set(),
-                            SDL.SDLK_DOWN => io.keyinput.down.set(),
+                            SDL.SDLK_DOWN => keyinput.down.set(),
-                            SDL.SDLK_LEFT => io.keyinput.left.set(),
+                            SDL.SDLK_LEFT => keyinput.left.set(),
-                            SDL.SDLK_RIGHT => io.keyinput.right.set(),
+                            SDL.SDLK_RIGHT => keyinput.right.set(),
-                            SDL.SDLK_x => io.keyinput.a.set(),
+                            SDL.SDLK_x => keyinput.a.set(),
-                            SDL.SDLK_z => io.keyinput.b.set(),
+                            SDL.SDLK_z => keyinput.b.set(),
-                            SDL.SDLK_a => io.keyinput.shoulder_l.set(),
+                            SDL.SDLK_a => keyinput.shoulder_l.set(),
-                            SDL.SDLK_s => io.keyinput.shoulder_r.set(),
+                            SDL.SDLK_s => keyinput.shoulder_r.set(),
-                            SDL.SDLK_RETURN => io.keyinput.start.set(),
+                            SDL.SDLK_RETURN => keyinput.start.set(),
-                            SDL.SDLK_RSHIFT => io.keyinput.select.set(),
+                            SDL.SDLK_RSHIFT => keyinput.select.set(),
                             SDL.SDLK_i => {
                                 comptime std.debug.assert(sample_format == SDL.AUDIO_U16);
                                 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_j => log.err("Scheduler Capacity: {} | Scheduler Event Count: {}", .{ scheduler.queue.capacity(), scheduler.queue.count() }),
-                            SDL.SDLK_k => {
+                            SDL.SDLK_k => {},
-                                // Dump IWRAM to file
-                                log.info("PC: 0x{X:0>8}", .{cpu.r[15]});
-                                log.info("LR: 0x{X:0>8}", .{cpu.r[14]});
-                                // const iwram_file = try std.fs.cwd().createFile("iwram.bin", .{});
-                                // defer iwram_file.close();
-
-                                // try iwram_file.writeAll(cpu.bus.iwram.buf);
-                            },
                             else => {},
                         }
+
+                        cpu.bus.io.keyinput.store(keyinput.raw, .Monotonic);
                     },
                     else => {},
                 }
@@ -232,16 +248,17 @@ pub const Gui = struct {
             gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null);
             SDL.SDL_GL_SwapWindow(self.window);
 
-            const dyn_title = std.fmt.bufPrint(&title_buf, "ZBA | {s} [Emu: {}fps] ", .{ self.title, tracker.value() }) catch unreachable;
+            if (tracker) |t| {
-            SDL.SDL_SetWindowTitle(self.window, dyn_title.ptr);
+                const dyn_title = std.fmt.bufPrintZ(&title_buf, "ZBA | {s} [Emu: {}fps] ", .{ self.title, t.value() }) catch unreachable;
+                SDL.SDL_SetWindowTitle(self.window, dyn_title.ptr);
+            }
         }
 
-        quit.store(true, .SeqCst); // Terminate Emulator Thread
+        quit.store(true, .Monotonic); // Terminate Emulator Thread
     }
 
     pub fn deinit(self: *Self) void {
         self.audio.deinit();
-        // TODO: Buffer deletions
         gl.deleteProgram(self.program_id);
         SDL.SDL_GL_DeleteContext(self.ctx);
         SDL.SDL_DestroyWindow(self.window);
@@ -298,6 +315,28 @@ const Audio = struct {
     }
 };
 
+const shader = struct {
+    const Kind = enum { vertex, fragment };
+    const log = std.log.scoped(.Shader);
+
+    fn didCompile(id: gl.GLuint) bool {
+        var success: gl.GLint = undefined;
+        gl.getShaderiv(id, gl.COMPILE_STATUS, &success);
+
+        if (success == 0) err(id);
+
+        return success == 1;
+    }
+
+    fn err(id: gl.GLuint) void {
+        const buf_len = 512;
+        var error_msg: [buf_len]u8 = undefined;
+
+        gl.getShaderInfoLog(id, buf_len, 0, &error_msg);
+        log.err("{s}", .{std.mem.sliceTo(&error_msg, 0)});
+    }
+};
+
 fn panic() noreturn {
     const str = @as(?[*:0]const u8, SDL.SDL_GetError()) orelse "unknown error";
     @panic(std.mem.sliceTo(str, 0));

src/util.zig

@@ -49,7 +49,7 @@ pub const FpsTracker = struct {
 
     pub fn value(self: *Self) u32 {
         if (self.timer.read() >= std.time.ns_per_s) {
-            self.fps = self.count.swap(0, .SeqCst);
+            self.fps = self.count.swap(0, .Monotonic);
             self.timer.reset();
         }
 
@@ -68,57 +68,6 @@ pub fn intToBytes(comptime T: type, value: anytype) [@sizeOf(T)]u8 {
     return result;
 }
 
-/// The Title from the GBA Cartridge is an Uppercase ASCII string which is
-/// null-padded to 12 bytes
-///
-/// This function returns a slice of the ASCII string without the null terminator(s)
-/// (essentially, a proper Zig/Rust/Any modern language String)
-pub fn span(title: *const [12]u8) []const u8 {
-    const end = std.mem.indexOfScalar(u8, title, '\x00');
-    return title[0 .. end orelse title.len];
-}
-
-test "span" {
-    var example: *const [12]u8 = "POKEMON_EMER";
-    try std.testing.expectEqualSlices(u8, "POKEMON_EMER", span(example));
-
-    example = "POKEMON_EME\x00";
-    try std.testing.expectEqualSlices(u8, "POKEMON_EME", span(example));
-
-    example = "POKEMON_EM\x00\x00";
-    try std.testing.expectEqualSlices(u8, "POKEMON_EM", span(example));
-
-    example = "POKEMON_E\x00\x00\x00";
-    try std.testing.expectEqualSlices(u8, "POKEMON_E", span(example));
-
-    example = "POKEMON_\x00\x00\x00\x00";
-    try std.testing.expectEqualSlices(u8, "POKEMON_", span(example));
-
-    example = "POKEMON\x00\x00\x00\x00\x00";
-    try std.testing.expectEqualSlices(u8, "POKEMON", span(example));
-
-    example = "POKEMO\x00\x00\x00\x00\x00\x00";
-    try std.testing.expectEqualSlices(u8, "POKEMO", span(example));
-
-    example = "POKEM\x00\x00\x00\x00\x00\x00\x00";
-    try std.testing.expectEqualSlices(u8, "POKEM", span(example));
-
-    example = "POKE\x00\x00\x00\x00\x00\x00\x00\x00";
-    try std.testing.expectEqualSlices(u8, "POKE", span(example));
-
-    example = "POK\x00\x00\x00\x00\x00\x00\x00\x00\x00";
-    try std.testing.expectEqualSlices(u8, "POK", span(example));
-
-    example = "PO\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
-    try std.testing.expectEqualSlices(u8, "PO", span(example));
-
-    example = "P\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
-    try std.testing.expectEqualSlices(u8, "P", span(example));
-
-    example = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
-    try std.testing.expectEqualSlices(u8, "", span(example));
-}
-
 /// Creates a copy of a title with all Filesystem-invalid characters replaced
 ///
 /// e.g. POKEPIN R/S to POKEPIN R_S
@@ -199,7 +148,7 @@ pub const Logger = struct {
         if (cpu.cpsr.t.read()) {
             if (opcode >> 11 == 0x1E) {
                 // Instruction 1 of a BL Opcode, print in ARM mode
-                const low = cpu.bus.dbgRead(u16, cpu.r[15]);
+                const low = cpu.bus.dbgRead(u16, cpu.r[15] - 2);
                 const bl_opcode = @as(u32, opcode) << 16 | low;
 
                 self.print(arm_fmt, Self.fmtArgs(cpu, bl_opcode)) catch @panic("failed to write to log file");