fix: ignore missing opengl proc addresses

is this really a fix? the error never happens with mach-glfw

README.md

@@ -10,7 +10,7 @@ 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
@@ -77,7 +77,7 @@ arm7wrestler GBA Fixed | [destoer](https://github.com/destoer)
 
 ## Compiling
 
-Most recently built on Zig [0.11.0-dev.368+1829b6eab](https://github.com/ziglang/zig/tree/1829b6eab)
+Most recently built on Zig [v0.11.0-dev.987+a1d82352d](https://github.com/ziglang/zig/tree/a1d82352d)
 
 ### Dependencies
 

build.zig

@@ -4,7 +4,7 @@ const Sdk = @import("lib/SDL.zig/Sdk.zig");
 
 pub fn build(b: *std.build.Builder) void {
     // Minimum Zig Version
-    const min_ver = std.SemanticVersion.parse("0.11.0-dev.323+30eb2a175") catch return; // https://github.com/ziglang/zig/commit/30eb2a175
+    const min_ver = std.SemanticVersion.parse("0.11.0-dev.987+a1d82352d") catch return; // https://github.com/ziglang/zig/commit/19056cb68
     if (builtin.zig_version.order(min_ver).compare(.lt)) {
         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);

lib/zig-clap

@@ -1 +1 @@
-Subproject commit 8a38c14266d1d00e0c3aee16b2e2b69675209147
+Subproject commit 88edafd00ec25dcc01deb8fc69e9864a16f8717c

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 {
@@ -106,50 +102,50 @@ pub fn deinit(self: *Self) void {
     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| {
-        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| {
-        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,9 +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];
 }
 
 pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
@@ -208,8 +209,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
     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
@@ -227,7 +227,7 @@ fn dbgSlowRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
         // General Internal Memory
         0x00 => blk: {
             if (address < Bios.size)
-                break :blk self.bios.dbgRead(T, self.cpu.r[15], address);
+                break :blk self.bios.dbgRead(T, self.cpu.r[15], unaligned_address);
 
             break :blk self.openBus(T, address);
         },
@@ -326,8 +326,7 @@ pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
     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
@@ -347,7 +346,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);
         },
@@ -394,8 +393,7 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
     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
@@ -408,8 +406,9 @@ 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 {
+fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
-    // @setCold(true);
+    @setCold(true);
+
     const page = @truncate(u8, unaligned_address >> 24);
     const address = forceAlign(T, unaligned_address);
 
@@ -437,11 +436,11 @@ inline fn rotateBy(comptime T: type, address: u32) u32 {
         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/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 path = maybe_path.?;
+
+    const buf = try allocator.alloc(u8, Self.size);
+    errdefer allocator.free(buf);
+
     const file = try std.fs.cwd().openFile(path, .{});
     defer file.close();
 
-        break :blk try file.readToEndAlloc(allocator, try file.getEndPos());
+    const file_len = try file.readAll(buf);
-    } else null;
+    if (file_len != Self.size) log.err("Expected BIOS to be {}B, was {}B", .{ Self.size, file_len });
 
-    return Self{
+    return Self{ .buf = buf, .allocator = allocator };
-        .buf = buf,
-        .allocator = allocator,
-        .addr_latch = 0,
-    };
 }
 
 pub fn deinit(self: *Self) void {

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/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/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

@@ -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();
             }

src/core/ppu.zig

@@ -340,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) {
@@ -407,7 +409,7 @@ pub const Ppu = struct {
 
             // Check to see if sprite pixel is in bounds
             // TODO: Are any of the checks here redundant?
-            if (!(sprite_x <= x and x < (sprite_x + sprite_width))) continue;
+            if (sprite_x > x and x >= (sprite_x + sprite.width)) continue;
 
             // Sprite is within bounds and therefore should be rendered
             const local_x = @as(i16, x) - sprite_x;
@@ -433,9 +435,6 @@ pub const Ppu = struct {
             const mapping_offset = if (obj_mapping) sprite.width >> 3 else if (is_8bpp) @as(u32, 0x10) else 0x20;
             const tile_offset = (tile_x >> 3) * tile_len + (tile_y >> 3) * tile_len * mapping_offset;
 
-            // TODO: This is not the proper check
-            // if (tile_base + tile_offset >= self.vram.buf.len) continue;
-
             const tile = self.vram.buf[tile_base + tile_offset];
             const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile;
 
@@ -457,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;
@@ -491,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);
-                drawSpritePixel(self.bld.cnt, &self.scanline, sprite.attr0, x, bgr555);
+                drawSpritePixel(self.bld.cnt, &self.scanline, sprite.attr0, global_x, bgr555);
             }
         }
     }
@@ -521,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()) {
@@ -532,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;

src/core/scheduler.zig

@@ -31,7 +31,7 @@ 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;
 
         switch (event.kind) {
@@ -70,22 +70,16 @@ pub const Scheduler = struct {
             .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) |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/platform.zig

@@ -64,7 +64,7 @@ pub const Gui = struct {
         const ctx = SDL.SDL_GL_CreateContext(window) orelse panic();
         if (SDL.SDL_GL_MakeCurrent(window, ctx) < 0) panic();
 
-        try gl.load(ctx, Self.glGetProcAddress);
+        gl.load(ctx, Self.glGetProcAddress) catch {};
         if (SDL.SDL_GL_SetSwapInterval(@boolToInt(config.config().host.vsync)) < 0) panic();
 
         const program_id = try compileShaders();