chore: instantly refill the pipeline on flush

I believe this to be necessary in order to get hardware interrupts
working.

thumb.gba test 108 fails but I'm committing anyways (despite the
regression) because this is kind of rebase/merge hell and I have
something that at least sort of works rn

lib/SDL.zig

@@ -1 +1 @@
-Subproject commit d66925011971fbe221fc2a7f7cb4cd8c181d9ba3
+Subproject commit 401c50ff3d0b83ad4bd89caf580ce1bd90fb5618

lib/util/bitfield.zig

@@ -14,7 +14,7 @@ fn PtrCastPreserveCV(comptime T: type, comptime PtrToT: type, comptime NewT: typ
 fn BitType(comptime FieldType: type, comptime ValueType: type, comptime shamt: usize) type {
     const self_bit: FieldType = (1 << shamt);
 
-    return extern struct {
+    return struct {
         bits: Bitfield(FieldType, shamt, 1),
 
         pub fn set(self: anytype) void {
@@ -63,7 +63,7 @@ pub fn Bitfield(comptime FieldType: type, comptime shamt: usize, comptime num_bi
 
     const ValueType = std.meta.Int(.unsigned, num_bits);
 
-    return extern struct {
+    return struct {
         dummy: FieldType,
 
         fn field(self: anytype) PtrCastPreserveCV(@This(), @TypeOf(self), FieldType) {

src/Gui.zig

@@ -11,6 +11,7 @@ const pitch = @import("core/ppu.zig").framebuf_pitch;
 const scale = @import("core/emu.zig").win_scale;
 
 const emu = @import("core/emu.zig");
+const asString = @import("core/util.zig").asString;
 const log = std.log.scoped(.GUI);
 
 const default_title: []const u8 = "ZBA";

src/core/bus/Bios.zig

@@ -13,12 +13,12 @@ alloc: Allocator,
 addr_latch: u32,
 
 pub fn init(alloc: Allocator, maybe_path: ?[]const u8) !Self {
-    const buf: ?[]u8 = if (maybe_path) |path| blk: {
+    var buf: ?[]u8 = null;
+    if (maybe_path) |path| {
         const file = try std.fs.cwd().openFile(path, .{});
         defer file.close();
-
-        break :blk try file.readToEndAlloc(alloc, try file.getEndPos());
-    } else null;
+        buf = try file.readToEndAlloc(alloc, try file.getEndPos());
+    }
 
     return Self{
         .buf = buf,

src/core/bus/backup.zig

@@ -3,7 +3,7 @@ const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.Backup);
 
 const escape = @import("../util.zig").escape;
-const asStringSlice = @import("../util.zig").asStringSlice;
+const asString = @import("../util.zig").asString;
 
 const backup_kinds = [5]Needle{
     .{ .str = "EEPROM_V", .kind = .Eeprom },
@@ -18,7 +18,7 @@ pub const Backup = struct {
 
     buf: []u8,
     alloc: Allocator,
-    kind: Kind,
+    kind: BackupKind,
 
     title: [12]u8,
     save_path: ?[]const u8,
@@ -26,15 +26,7 @@ pub const Backup = struct {
     flash: Flash,
     eeprom: Eeprom,
 
-    const Kind = enum {
-        Eeprom,
-        Sram,
-        Flash,
-        Flash1M,
-        None,
-    };
-
-    pub fn init(allocator: Allocator, kind: Kind, title: [12]u8, path: ?[]const u8) !Self {
+    pub fn init(alloc: Allocator, kind: BackupKind, title: [12]u8, path: ?[]const u8) !Self {
         log.info("Kind: {}", .{kind});
 
         const buf_size: usize = switch (kind) {
@@ -44,24 +36,24 @@ pub const Backup = struct {
             .None, .Eeprom => 0, // EEPROM is handled upon first Read Request to it
         };
 
-        const buf = try allocator.alloc(u8, buf_size);
+        const buf = try alloc.alloc(u8, buf_size);
         std.mem.set(u8, buf, 0xFF);
 
         var backup = Self{
             .buf = buf,
-            .alloc = allocator,
+            .alloc = alloc,
             .kind = kind,
             .title = title,
             .save_path = path,
             .flash = Flash.init(),
-            .eeprom = Eeprom.init(allocator),
+            .eeprom = Eeprom.init(alloc),
         };
 
-        if (backup.save_path) |p| backup.loadSaveFromDisk(allocator, p) catch |e| log.err("Failed to load save: {}", .{e});
+        if (backup.save_path) |p| backup.loadSaveFromDisk(p) catch |e| log.err("Failed to load save: {}", .{e});
         return backup;
     }
 
-    pub fn guessKind(rom: []const u8) ?Kind {
+    pub fn guessKind(rom: []const u8) ?BackupKind {
         for (backup_kinds) |needle| {
             const needle_len = needle.str.len;
 
@@ -75,13 +67,13 @@ pub const Backup = struct {
     }
 
     pub fn deinit(self: Self) void {
-        if (self.save_path) |path| self.writeSaveToDisk(self.alloc, path) catch |e| log.err("Failed to write save: {}", .{e});
+        if (self.save_path) |path| self.writeSaveToDisk(path) catch |e| log.err("Failed to write save: {}", .{e});
         self.alloc.free(self.buf);
     }
 
-    fn loadSaveFromDisk(self: *Self, allocator: Allocator, path: []const u8) !void {
-        const file_path = try self.getSaveFilePath(allocator, path);
-        defer allocator.free(file_path);
+    fn loadSaveFromDisk(self: *Self, path: []const u8) !void {
+        const file_path = try self.getSaveFilePath(path);
+        defer self.alloc.free(file_path);
 
         // FIXME: Don't rely on this lol
         if (std.mem.eql(u8, file_path[file_path.len - 12 .. file_path.len], "untitled.sav")) {
@@ -89,8 +81,8 @@ pub const Backup = struct {
         }
 
         const file: std.fs.File = try std.fs.openFileAbsolute(file_path, .{});
-        const file_buf = try file.readToEndAlloc(allocator, try file.getEndPos());
-        defer allocator.free(file_buf);
+        const file_buf = try file.readToEndAlloc(self.alloc, try file.getEndPos());
+        defer self.alloc.free(file_buf);
 
         switch (self.kind) {
             .Sram, .Flash, .Flash1M => {
@@ -105,7 +97,7 @@ pub const Backup = struct {
                 if (file_buf.len == 0x200 or file_buf.len == 0x2000) {
                     self.eeprom.kind = if (file_buf.len == 0x200) .Small else .Large;
 
-                    self.buf = try allocator.alloc(u8, file_buf.len);
+                    self.buf = try self.alloc.alloc(u8, file_buf.len);
                     std.mem.copy(u8, self.buf, file_buf);
                     return log.info("Loaded Save from {s}", .{file_path});
                 }
@@ -119,23 +111,23 @@ pub const Backup = struct {
         }
     }
 
-    fn getSaveFilePath(self: *const Self, allocator: Allocator, path: []const u8) ![]const u8 {
-        const filename = try self.getSaveFilename(allocator);
-        defer allocator.free(filename);
+    fn getSaveFilePath(self: *const Self, path: []const u8) ![]const u8 {
+        const filename = try self.getSaveFilename();
+        defer self.alloc.free(filename);
 
-        return try std.fs.path.join(allocator, &[_][]const u8{ path, filename });
+        return try std.fs.path.join(self.alloc, &[_][]const u8{ path, filename });
     }
 
-    fn getSaveFilename(self: *const Self, allocator: Allocator) ![]const u8 {
-        const title_str = asStringSlice(&escape(self.title));
-        const name = if (title_str.len != 0) title_str else "untitled";
+    fn getSaveFilename(self: *const Self) ![]const u8 {
+        const title = asString(escape(self.title));
+        const name = if (title.len != 0) title else "untitled";
 
-        return try std.mem.concat(allocator, u8, &[_][]const u8{ name, ".sav" });
+        return try std.mem.concat(self.alloc, u8, &[_][]const u8{ name, ".sav" });
     }
 
-    fn writeSaveToDisk(self: Self, allocator: Allocator, path: []const u8) !void {
-        const file_path = try self.getSaveFilePath(allocator, path);
-        defer allocator.free(file_path);
+    fn writeSaveToDisk(self: Self, path: []const u8) !void {
+        const file_path = try self.getSaveFilePath(path);
+        defer self.alloc.free(file_path);
 
         switch (self.kind) {
             .Sram, .Flash, .Flash1M, .Eeprom => {
@@ -209,13 +201,21 @@ pub const Backup = struct {
     }
 };
 
+const BackupKind = enum {
+    Eeprom,
+    Sram,
+    Flash,
+    Flash1M,
+    None,
+};
+
 const Needle = struct {
     const Self = @This();
 
     str: []const u8,
-    kind: Backup.Kind,
+    kind: BackupKind,
 
-    fn init(str: []const u8, kind: Backup.Kind) Self {
+    fn init(str: []const u8, kind: BackupKind) Self {
         return .{
             .str = str,
             .kind = kind,
@@ -230,7 +230,7 @@ const SaveError = error{
 const Flash = struct {
     const Self = @This();
 
-    state: State,
+    state: FlashState,
 
     id_mode: bool,
     set_bank: bool,
@@ -239,12 +239,6 @@ const Flash = struct {
 
     bank: u1,
 
-    const State = enum {
-        Ready,
-        Set,
-        Command,
-    };
-
     fn init() Self {
         return .{
             .state = .Ready,
@@ -299,6 +293,12 @@ const Flash = struct {
     }
 };
 
+const FlashState = enum {
+    Ready,
+    Set,
+    Command,
+};
+
 const Eeprom = struct {
     const Self = @This();
 

src/core/cpu.zig

@@ -12,7 +12,7 @@ const File = std.fs.File;
 
 // ARM Instructions
 pub const arm = struct {
-    pub const InstrFn = *const fn (*Arm7tdmi, *Bus, u32) void;
+    pub const InstrFn = fn (*Arm7tdmi, *Bus, u32) void;
     const lut: [0x1000]InstrFn = populate();
 
     const processing = @import("cpu/arm/data_processing.zig").dataProcessing;
@@ -110,7 +110,7 @@ pub const arm = struct {
 
 // THUMB Instructions
 pub const thumb = struct {
-    pub const InstrFn = *const fn (*Arm7tdmi, *Bus, u16) void;
+    pub const InstrFn = fn (*Arm7tdmi, *Bus, u16) void;
     const lut: [0x400]InstrFn = populate();
 
     const processing = @import("cpu/thumb/data_processing.zig");
@@ -685,8 +685,7 @@ const Pipline = 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..1][0];
+        const opcode = self.stage[0];
 
         self.stage[0] = self.stage[1];
         self.stage[1] = cpu.bus.read(T, cpu.r[15]);

src/core/util.zig

@@ -69,7 +69,7 @@ pub fn intToBytes(comptime T: type, value: anytype) [@sizeOf(T)]u8 {
 ///
 /// This function returns a slice of everything just before the first
 /// `\0`
-pub fn asStringSlice(title: *const [12]u8) []const u8 {
+pub fn asString(title: [12]u8) []const u8 {
     var len = title.len;
     for (title) |char, i| {
         if (char == 0) {