chore: expose arm namespace

build.zig

@@ -15,33 +15,39 @@ pub fn build(b: *std.Build) void {
     // set a preferred release mode, allowing the user to decide how to optimize.
     const optimize = b.standardOptimizeOption(.{});
 
-    const lib = b.addStaticLibrary(.{
-        .name = "arm32",
-        // In this case the main source file is merely a path, however, in more
-        // complicated build scripts, this could be a generated file.
-        .root_source_file = .{ .path = "src/lib.zig" },
-        .target = target,
-        .optimize = optimize,
-    });
+    const util_dep = b.dependency("zba-util", .{});
+    const bitfield_mod = b.createModule(.{ .source_file = .{ .path = "lib/bitfield.zig" }, .dependencies = &.{} });
 
-    // This declares intent for the library to be installed into the standard
-    // location when the user invokes the "install" step (the default step when
-    // running `zig build`).
-    b.installArtifact(lib);
+    _ = b.addModule("arm32", .{
+        .source_file = .{ .path = "src/lib.zig" },
+        .dependencies = &.{
+            .{
+                .name = "zba-util",
+                .module = util_dep.module("zba-util"),
+            },
+            .{
+                .name = "bitfield",
+                .module = bitfield_mod,
+            },
+        },
+    });
 
     // Creates a step for unit testing. This only builds the test executable
     // but does not run it.
-    const main_tests = b.addTest(.{
+    const lib_tests = b.addTest(.{
         .root_source_file = .{ .path = "src/lib.zig" },
         .target = target,
         .optimize = optimize,
     });
 
-    const run_main_tests = b.addRunArtifact(main_tests);
+    lib_tests.addModule("zba-util", util_dep.module("zba-util")); // https://git.musuka.dev/paoda/zba-util
+    lib_tests.addModule("bitfield", bitfield_mod);
+
+    const run_lib_tests = b.addRunArtifact(lib_tests);
 
     // This creates a build step. It will be visible in the `zig build --help` menu,
     // and can be selected like this: `zig build test`
     // This will evaluate the `test` step rather than the default, which is "install".
     const test_step = b.step("test", "Run library tests");
-    test_step.dependOn(&run_main_tests.step);
+    test_step.dependOn(&run_lib_tests.step);
 }

build.zig.zon

@@ -0,0 +1,10 @@
+.{
+    .name = "arm32",
+    .version = "0.1.0",
+    .dependencies = .{
+        .@"zba-util" = .{
+            .url = "https://git.musuka.dev/paoda/zba-util/archive/e616cf09e53f5c402c8f040d14baa211683e70e3.tar.gz",
+            .hash = "1220b80b2c0989dcc47275ab9d7d70da4858ef3c1fe1f934e8d838e65028127f6ef3",
+        },
+    },
+}

lib/bitfield.zig

@@ -0,0 +1,146 @@
+const std = @import("std");
+
+fn PtrCastPreserveCV(comptime T: type, comptime PtrToT: type, comptime NewT: type) type {
+    return switch (PtrToT) {
+        *T => *NewT,
+        *const T => *const NewT,
+        *volatile T => *volatile NewT,
+        *const volatile T => *const volatile NewT,
+
+        else => @compileError("wtf you doing"),
+    };
+}
+
+fn BitType(comptime FieldType: type, comptime ValueType: type, comptime shamt: usize) type {
+    const self_bit: FieldType = (1 << shamt);
+
+    return extern struct {
+        bits: Bitfield(FieldType, shamt, 1),
+
+        pub fn set(self: anytype) void {
+            self.bits.field().* |= self_bit;
+        }
+
+        pub fn unset(self: anytype) void {
+            self.bits.field().* &= ~self_bit;
+        }
+
+        pub fn read(self: anytype) ValueType {
+            return @bitCast(ValueType, @truncate(u1, self.bits.field().* >> shamt));
+        }
+
+        // Since these are mostly used with MMIO, I want to avoid
+        // reading the memory just to write it again, also races
+        pub fn write(self: anytype, val: ValueType) void {
+            if (@bitCast(bool, val)) {
+                self.set();
+            } else {
+                self.unset();
+            }
+        }
+    };
+}
+
+// Original Bit Constructor
+// pub fn Bit(comptime FieldType: type, comptime shamt: usize) type {
+//     return BitType(FieldType, u1, shamt);
+// }
+
+pub fn Bit(comptime FieldType: type, comptime shamt: usize) type {
+    return BitType(FieldType, bool, shamt);
+}
+
+fn Boolean(comptime FieldType: type, comptime shamt: usize) type {
+    return BitType(FieldType, bool, shamt);
+}
+
+pub fn Bitfield(comptime FieldType: type, comptime shamt: usize, comptime num_bits: usize) type {
+    if (shamt + num_bits > @bitSizeOf(FieldType)) {
+        @compileError("bitfield doesn't fit");
+    }
+
+    const self_mask: FieldType = ((1 << num_bits) - 1) << shamt;
+
+    const ValueType = std.meta.Int(.unsigned, num_bits);
+
+    return extern struct {
+        dummy: FieldType,
+
+        fn field(self: anytype) PtrCastPreserveCV(@This(), @TypeOf(self), FieldType) {
+            return @ptrCast(PtrCastPreserveCV(@This(), @TypeOf(self), FieldType), self);
+        }
+
+        pub fn write(self: anytype, val: ValueType) void {
+            self.field().* &= ~self_mask;
+            self.field().* |= @intCast(FieldType, val) << shamt;
+        }
+
+        pub fn read(self: anytype) ValueType {
+            const val: FieldType = self.field().*;
+            return @intCast(ValueType, (val & self_mask) >> shamt);
+        }
+    };
+}
+
+test "bit" {
+    const S = extern union {
+        low: Bit(u32, 0),
+        high: Bit(u32, 1),
+        val: u32,
+    };
+
+    std.testing.expect(@sizeOf(S) == 4);
+    std.testing.expect(@bitSizeOf(S) == 32);
+
+    var s: S = .{ .val = 1 };
+
+    std.testing.expect(s.low.read() == 1);
+    std.testing.expect(s.high.read() == 0);
+
+    s.low.write(0);
+    s.high.write(1);
+
+    std.testing.expect(s.val == 2);
+}
+
+test "boolean" {
+    const S = extern union {
+        low: Boolean(u32, 0),
+        high: Boolean(u32, 1),
+        val: u32,
+    };
+
+    std.testing.expect(@sizeOf(S) == 4);
+    std.testing.expect(@bitSizeOf(S) == 32);
+
+    var s: S = .{ .val = 2 };
+
+    std.testing.expect(s.low.read() == false);
+    std.testing.expect(s.high.read() == true);
+
+    s.low.write(true);
+    s.high.write(false);
+
+    std.testing.expect(s.val == 1);
+}
+
+test "bitfield" {
+    const S = extern union {
+        low: Bitfield(u32, 0, 16),
+        high: Bitfield(u32, 16, 16),
+        val: u32,
+    };
+
+    std.testing.expect(@sizeOf(S) == 4);
+    std.testing.expect(@bitSizeOf(S) == 32);
+
+    var s: S = .{ .val = 0x13376969 };
+
+    std.testing.expect(s.low.read() == 0x6969);
+    std.testing.expect(s.high.read() == 0x1337);
+
+    s.low.write(0x1337);
+    s.high.write(0x6969);
+
+    std.testing.expect(s.val == 0x69691337);
+}

src/arm.zig

@@ -0,0 +1,397 @@
+const std = @import("std");
+
+const Architecture = enum { v4t, v5te };
+const Interpreter = @import("lib.zig").Interpreter;
+const Bus = @import("lib.zig").Bus;
+const Scheduler = @import("lib.zig").Scheduler;
+
+const Bitfield = @import("bitfield").Bitfield;
+const Bit = @import("bitfield").Bit;
+
+const condition_lut = [_]u16{
+    0xF0F0, // EQ - Equal
+    0x0F0F, // NE - Not Equal
+    0xCCCC, // CS - Unsigned higher or same
+    0x3333, // CC - Unsigned lower
+    0xFF00, // MI - Negative
+    0x00FF, // PL - Positive or Zero
+    0xAAAA, // VS - Overflow
+    0x5555, // VC - No Overflow
+    0x0C0C, // HI - unsigned hierh
+    0xF3F3, // LS - unsigned lower or same
+    0xAA55, // GE - greater or equal
+    0x55AA, // LT - less than
+    0x0A05, // GT - greater than
+    0xF5FA, // LE - less than or equal
+    0xFFFF, // AL - always
+    0x0000, // NV - never
+};
+
+pub fn Arm32(comptime arch: Architecture) type {
+    return struct {
+        const Self = @This();
+
+        r: [16]u32 = [_]u32{0x00} ** 16,
+        pipe: Pipeline = Pipeline.init(),
+        sched: Scheduler,
+        bus: Bus,
+        cpsr: PSR,
+        spsr: PSR,
+
+        bank: Bank = Bank.create(),
+
+        const arm = @import("arm/v4t.zig").arm(Self);
+        const thumb = @import("arm/v4t.zig").thumb(Self);
+
+        const Pipeline = struct {
+            stage: [2]?u32,
+            flushed: bool,
+
+            fn init() @This() {
+                return .{
+                    .stage = [_]?u32{null} ** 2,
+                    .flushed = false,
+                };
+            }
+
+            pub fn isFull(self: *const @This()) bool {
+                return self.stage[0] != null and self.stage[1] != null;
+            }
+
+            pub fn step(self: *@This(), cpu: *Self, comptime T: type) ?u32 {
+                comptime std.debug.assert(T == u32 or T == u16);
+
+                const opcode = self.stage[0];
+                self.stage[0] = self.stage[1];
+                self.stage[1] = cpu.fetch(T, cpu.r[15]);
+
+                return opcode;
+            }
+
+            pub fn reload(self: *@This(), cpu: *Self) void {
+                if (cpu.cpsr.t.read()) {
+                    self.stage[0] = cpu.fetch(u16, cpu.r[15]);
+                    self.stage[1] = cpu.fetch(u16, cpu.r[15] + 2);
+                    cpu.r[15] += 4;
+                } else {
+                    self.stage[0] = cpu.fetch(u32, cpu.r[15]);
+                    self.stage[1] = cpu.fetch(u32, cpu.r[15] + 4);
+                    cpu.r[15] += 8;
+                }
+
+                self.flushed = true;
+            }
+        };
+
+        /// Bank of Registers from other CPU Modes
+        pub 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(scheduler: Scheduler, bus: Bus) Self {
+            return Self{
+                .sched = scheduler,
+                .bus = bus,
+                .cpsr = .{ .raw = 0x0000_001F },
+                .spsr = .{ .raw = 0x0000_0000 },
+            };
+        }
+
+        // FIXME: Resetting disables logging (if enabled)
+        pub fn reset(self: *Self) void {
+            self.* = .{
+                .sched = self.sched,
+                .bus = self.bus,
+                .cpsr = .{ .raw = 0x0000_001F },
+                .spsr = .{ .raw = 0x0000_0000 },
+            };
+        }
+
+        pub inline fn hasSPSR(self: *const Self) bool {
+            const mode = Mode.getChecked(self, self.cpsr.mode.read());
+            return switch (mode) {
+                .System, .User => false,
+                else => true,
+            };
+        }
+
+        pub inline fn isPrivileged(self: *const Self) bool {
+            const mode = Mode.getChecked(self, self.cpsr.mode.read());
+            return switch (mode) {
+                .User => false,
+                else => true,
+            };
+        }
+
+        pub fn setCpsr(self: *Self, value: u32) void {
+            if (value & 0x1F != self.cpsr.raw & 0x1F) self.changeModeFromIdx(@truncate(u5, value & 0x1F));
+            self.cpsr.raw = value;
+        }
+
+        fn changeModeFromIdx(self: *Self, next: u5) void {
+            self.changeMode(Mode.getChecked(self, next));
+        }
+
+        pub fn setUserModeRegister(self: *Self, idx: usize, value: u32) void {
+            const current = Mode.getChecked(self, self.cpsr.mode.read());
+
+            switch (idx) {
+                8...12 => {
+                    if (current == .Fiq) {
+                        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(Bank.Kind, idx - 13) catch unreachable;
+                        self.bank.r[Bank.regIdx(.User, kind)] = value;
+                    },
+                },
+                else => self.r[idx] = value, // R0 -> R7  and R15
+            }
+        }
+
+        pub fn getUserModeRegister(self: *Self, idx: usize) u32 {
+            const current = Mode.getChecked(self, self.cpsr.mode.read());
+
+            return switch (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(Bank.Kind, idx - 13) catch unreachable;
+                        break :blk self.bank.r[Bank.regIdx(.User, kind)];
+                    },
+                },
+                else => self.r[idx], // R0 -> R7  and R15
+            };
+        }
+
+        pub fn changeMode(self: *Self, next: Mode) void {
+            const now = Mode.getChecked(self, self.cpsr.mode.read());
+
+            // Bank R8 -> r12
+            for (0..5) |i| {
+                self.bank.fiq[Bank.fiqIdx(i, now)] = self.r[8 + i];
+            }
+
+            // Bank r13, r14, SPSR
+            switch (now) {
+                .User, .System => {
+                    self.bank.r[Bank.regIdx(now, .R13)] = self.r[13];
+                    self.bank.r[Bank.regIdx(now, .R14)] = self.r[14];
+                },
+                else => {
+                    self.bank.r[Bank.regIdx(now, .R13)] = self.r[13];
+                    self.bank.r[Bank.regIdx(now, .R14)] = self.r[14];
+                    self.bank.spsr[Bank.spsrIdx(now)] = self.spsr;
+                },
+            }
+
+            // Grab R8 -> R12
+            for (0..5) |i| {
+                self.r[8 + i] = self.bank.fiq[Bank.fiqIdx(i, next)];
+            }
+
+            // Grab r13, r14, SPSR
+            switch (next) {
+                .User, .System => {
+                    self.r[13] = self.bank.r[Bank.regIdx(next, .R13)];
+                    self.r[14] = self.bank.r[Bank.regIdx(next, .R14)];
+                },
+                else => {
+                    self.r[13] = self.bank.r[Bank.regIdx(next, .R13)];
+                    self.r[14] = self.bank.r[Bank.regIdx(next, .R14)];
+                    self.spsr = self.bank.spsr[Bank.spsrIdx(next)];
+                },
+            }
+
+            self.cpsr.mode.write(@enumToInt(next));
+        }
+
+        pub fn step(self: *Self) void {
+            defer {
+                if (!self.pipe.flushed) self.r[15] += if (self.cpsr.t.read()) 2 else @as(u32, 4);
+                self.pipe.flushed = false;
+            }
+
+            if (self.cpsr.t.read()) {
+                const opcode = @truncate(u16, self.pipe.step(self, u16) orelse return);
+                thumb.lut[thumb.idx(opcode)](self, self.bus, opcode);
+            } else {
+                const opcode = self.pipe.step(self, u32) orelse return;
+
+                if (self.cpsr.check(@truncate(u4, opcode >> 28))) {
+                    arm.lut[arm.idx(opcode)](self, self.bus, opcode);
+                }
+            }
+        }
+
+        inline fn fetch(self: *Self, comptime T: type, address: u32) T {
+            comptime std.debug.assert(T == u32 or T == u16); // Opcode may be 32-bit (ARM) or 16-bit (THUMB)
+
+            // Bus.read will advance the scheduler. There are different timings for CPU fetches,
+            // so we want to undo what Bus.read will apply. We can do this by caching the current tick
+            // This is very dumb.
+            //
+            // FIXME: Please rework this
+            // FIXME: Please Re-enable this
+            // const tick_cache = self.sched.tick;
+            // defer self.sched.tick = tick_cache + Bus.fetch_timings[@boolToInt(T == u32)][@truncate(u4, address >> 24)];
+
+            return self.bus.read(T, address);
+        }
+
+        pub fn panic(self: *const Self, comptime format: []const u8, args: anytype) noreturn {
+            var i: usize = 0;
+            while (i < 16) : (i += 4) {
+                const i_1 = i + 1;
+                const i_2 = i + 2;
+                const i_3 = i + 3;
+                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});
+            self.cpsr.toString();
+
+            std.debug.print("spsr: 0x{X:0>8} ", .{self.spsr.raw});
+            self.spsr.toString();
+
+            std.debug.print("pipeline: {??X:0>8}\n", .{self.pipe.stage});
+
+            if (self.cpsr.t.read()) {
+                const opcode = self.bus.dbgRead(u16, self.r[15] - 4);
+                const id = thumb.idx(opcode);
+                std.debug.print("opcode: ID: 0x{b:0>10} 0x{X:0>4}\n", .{ id, opcode });
+            } else {
+                const opcode = self.bus.dbgRead(u32, self.r[15] - 4);
+                const id = arm.idx(opcode);
+                std.debug.print("opcode: ID: 0x{X:0>3} 0x{X:0>8}\n", .{ id, opcode });
+            }
+
+            std.debug.print("tick: {}\n\n", .{self.sched.now()});
+
+            std.debug.panic(format, args);
+        }
+
+        pub fn interface(self: *Self) Interpreter {
+            return switch (arch) {
+                .v4t => .{ .v4t = self },
+                .v5te => .{ .v5te = self },
+            };
+        }
+    };
+}
+
+pub const Mode = enum(u5) {
+    User = 0b10000,
+    Fiq = 0b10001,
+    Irq = 0b10010,
+    Supervisor = 0b10011,
+    Abort = 0b10111,
+    Undefined = 0b11011,
+    System = 0b11111,
+
+    pub fn toString(self: Mode) []const u8 {
+        return switch (self) {
+            .User => "usr",
+            .Fiq => "fiq",
+            .Irq => "irq",
+            .Supervisor => "svc",
+            .Abort => "abt",
+            .Undefined => "und",
+            .System => "sys",
+        };
+    }
+
+    fn get(bits: u5) ?Mode {
+        return std.meta.intToEnum(Mode, bits) catch null;
+    }
+
+    fn getChecked(cpu: anytype, bits: u5) Mode {
+        return get(bits) orelse cpu.panic("[CPU/CPSR] 0b{b:0>5} is an invalid CPU mode", .{bits});
+    }
+};
+
+pub const PSR = extern union {
+    mode: Bitfield(u32, 0, 5),
+    t: Bit(u32, 5),
+    f: Bit(u32, 6),
+    i: Bit(u32, 7),
+    v: Bit(u32, 28),
+    c: Bit(u32, 29),
+    z: Bit(u32, 30),
+    n: Bit(u32, 31),
+    raw: u32,
+
+    fn toString(self: @This()) 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 (Mode.get(self.mode.read())) |m| std.debug.print("{s}", .{m.toString()}) else std.debug.print("---", .{});
+
+        std.debug.print("]\n", .{});
+    }
+
+    pub inline fn check(self: @This(), cond: u4) bool {
+        const flags = @truncate(u4, self.raw >> 28);
+
+        return condition_lut[cond] & (@as(u16, 1) << flags) != 0;
+    }
+};

src/arm/cpu/arm/block_data_transfer.zig

@@ -0,0 +1,111 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+pub fn blockDataTransfer(comptime InstrFn: type, comptime P: bool, comptime U: bool, comptime S: bool, comptime W: bool, comptime L: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u32) void {
+            const rn = @truncate(u4, opcode >> 16 & 0xF);
+            const rlist = opcode & 0xFFFF;
+            const r15 = rlist >> 15 & 1 == 1;
+
+            var count: u32 = 0;
+            var i: u5 = 0;
+            var first: u4 = 0;
+            var write_to_base = true;
+
+            while (i < 16) : (i += 1) {
+                const r = @truncate(u4, 15 - i);
+                if (rlist >> r & 1 == 1) {
+                    first = r;
+                    count += 1;
+                }
+            }
+
+            var start = cpu.r[rn];
+            if (U) {
+                start += if (P) 4 else 0;
+            } else {
+                start = start - (4 * count) + if (!P) 4 else 0;
+            }
+
+            var end = cpu.r[rn];
+            if (U) {
+                end = end + (4 * count) - if (!P) 4 else 0;
+            } else {
+                end -= if (P) 4 else 0;
+            }
+
+            var new_base = cpu.r[rn];
+            if (U) {
+                new_base += 4 * count;
+            } else {
+                new_base -= 4 * count;
+            }
+
+            var address = start;
+
+            if (rlist == 0) {
+                var und_addr = cpu.r[rn];
+                if (U) {
+                    und_addr += if (P) 4 else 0;
+                } else {
+                    und_addr -= 0x40 - if (!P) 4 else 0;
+                }
+
+                if (L) {
+                    cpu.r[15] = bus.read(u32, und_addr);
+                    cpu.pipe.reload(cpu);
+                } else {
+                    bus.write(u32, und_addr, cpu.r[15] + 4);
+                }
+
+                cpu.r[rn] = if (U) cpu.r[rn] + 0x40 else cpu.r[rn] - 0x40;
+                return;
+            }
+
+            i = first;
+            while (i < 16) : (i += 1) {
+                if (rlist >> i & 1 == 1) {
+                    transfer(cpu, bus, r15, i, address);
+                    address += 4;
+
+                    if (W and !L and write_to_base) {
+                        cpu.r[rn] = new_base;
+                        write_to_base = false;
+                    }
+                }
+            }
+
+            if (W and L and rlist >> rn & 1 == 0) cpu.r[rn] = new_base;
+        }
+
+        fn transfer(cpu: Arm32, bus: Bus, r15_present: bool, i: u5, address: u32) void {
+            if (L) {
+                if (S and !r15_present) {
+                    // Always Transfer User mode Registers
+                    cpu.setUserModeRegister(i, bus.read(u32, address));
+                } else {
+                    const value = bus.read(u32, address);
+
+                    cpu.r[i] = value;
+                    if (i == 0xF) {
+                        cpu.r[i] &= ~@as(u32, 3); // Align r15
+                        cpu.pipe.reload(cpu);
+
+                        if (S) cpu.setCpsr(cpu.spsr.raw);
+                    }
+                }
+            } else {
+                if (S) {
+                    // Always Transfer User mode Registers
+                    // This happens regardless if r15 is in the list
+                    const value = cpu.getUserModeRegister(i);
+                    bus.write(u32, address, value + if (i == 0xF) 4 else @as(u32, 0)); // PC is already 8 ahead to make 12
+                } else {
+                    bus.write(u32, address, cpu.r[i] + if (i == 0xF) 4 else @as(u32, 0));
+                }
+            }
+        }
+    }.inner;
+}

src/arm/cpu/arm/branch.zig

@@ -0,0 +1,31 @@
+const Bus = @import("../../../lib.zig").Bus;
+const sext = @import("zba-util").sext;
+
+pub fn branch(comptime InstrFn: type, comptime L: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u32) void {
+            if (L) cpu.r[14] = cpu.r[15] - 4;
+
+            cpu.r[15] +%= sext(u32, u24, opcode) << 2;
+            cpu.pipe.reload(cpu);
+        }
+    }.inner;
+}
+
+pub fn branchAndExchange(comptime InstrFn: type) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        pub fn inner(cpu: Arm32, _: Bus, opcode: u32) void {
+            const rn = opcode & 0xF;
+
+            const thumb = cpu.r[rn] & 1 == 1;
+            cpu.r[15] = cpu.r[rn] & if (thumb) ~@as(u32, 1) else ~@as(u32, 3);
+
+            cpu.cpsr.t.write(thumb);
+            cpu.pipe.reload(cpu);
+        }
+    }.inner;
+}

src/arm/cpu/arm/data_processing.zig

@@ -0,0 +1,185 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+const exec = @import("../barrel_shifter.zig").exec;
+const ror = @import("../barrel_shifter.zig").ror;
+
+pub fn dataProcessing(comptime InstrFn: type, comptime I: bool, comptime S: bool, comptime kind: u4) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u32) void {
+            const rd = @truncate(u4, opcode >> 12 & 0xF);
+            const rn = opcode >> 16 & 0xF;
+            const old_carry = @boolToInt(cpu.cpsr.c.read());
+
+            // If certain conditions are met, PC is 12 ahead instead of 8
+            // TODO: Why these conditions?
+            if (!I and opcode >> 4 & 1 == 1) cpu.r[15] += 4;
+            const op1 = cpu.r[rn];
+
+            const amount = @truncate(u8, (opcode >> 8 & 0xF) << 1);
+            const op2 = if (I) ror(S, &cpu.cpsr, opcode & 0xFF, amount) else exec(S, cpu, opcode);
+
+            // Undo special condition from above
+            if (!I and opcode >> 4 & 1 == 1) cpu.r[15] -= 4;
+
+            var result: u32 = undefined;
+            var overflow: u1 = undefined;
+
+            // Perform Data Processing Logic
+            switch (kind) {
+                0x0 => result = op1 & op2, // AND
+                0x1 => result = op1 ^ op2, // EOR
+                0x2 => result = op1 -% op2, // SUB
+                0x3 => result = op2 -% op1, // RSB
+                0x4 => result = add(&overflow, op1, op2), // ADD
+                0x5 => result = adc(&overflow, op1, op2, old_carry), // ADC
+                0x6 => result = sbc(op1, op2, old_carry), // SBC
+                0x7 => result = sbc(op2, op1, old_carry), // RSC
+                0x8 => {
+                    // TST
+                    if (rd == 0xF)
+                        return undefinedTestBehaviour(cpu);
+
+                    result = op1 & op2;
+                },
+                0x9 => {
+                    // TEQ
+                    if (rd == 0xF)
+                        return undefinedTestBehaviour(cpu);
+
+                    result = op1 ^ op2;
+                },
+                0xA => {
+                    // CMP
+                    if (rd == 0xF)
+                        return undefinedTestBehaviour(cpu);
+
+                    result = op1 -% op2;
+                },
+                0xB => {
+                    // CMN
+                    if (rd == 0xF)
+                        return undefinedTestBehaviour(cpu);
+
+                    const tmp = @addWithOverflow(op1, op2);
+                    result = tmp[0];
+                    overflow = tmp[1];
+                },
+                0xC => result = op1 | op2, // ORR
+                0xD => result = op2, // MOV
+                0xE => result = op1 & ~op2, // BIC
+                0xF => result = ~op2, // MVN
+            }
+
+            // Write to Destination Register
+            switch (kind) {
+                0x8, 0x9, 0xA, 0xB => {}, // Test Operations
+                else => {
+                    cpu.r[rd] = result;
+                    if (rd == 0xF) {
+                        if (S) cpu.setCpsr(cpu.spsr.raw);
+                        cpu.pipe.reload(cpu);
+                    }
+                },
+            }
+
+            // Write Flags
+            switch (kind) {
+                0x0, 0x1, 0xC, 0xD, 0xE, 0xF => if (S and rd != 0xF) {
+                    // Logic Operation Flags
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+                    // C set by Barrel Shifter, V is unaffected
+
+                },
+                0x2, 0x3 => if (S and rd != 0xF) {
+                    // SUB, RSB Flags
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+
+                    if (kind == 0x2) {
+                        // SUB specific
+                        cpu.cpsr.c.write(op2 <= op1);
+                        cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
+                    } else {
+                        // RSB Specific
+                        cpu.cpsr.c.write(op1 <= op2);
+                        cpu.cpsr.v.write(((op2 ^ result) & (~op1 ^ result)) >> 31 & 1 == 1);
+                    }
+                },
+                0x4, 0x5 => if (S and rd != 0xF) {
+                    // ADD, ADC Flags
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+                    cpu.cpsr.c.write(overflow == 0b1);
+                    cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
+                },
+                0x6, 0x7 => if (S and rd != 0xF) {
+                    // SBC, RSC Flags
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+
+                    if (kind == 0x6) {
+                        // SBC specific
+                        const subtrahend = @as(u64, op2) -% old_carry +% 1;
+                        cpu.cpsr.c.write(subtrahend <= op1);
+                        cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
+                    } else {
+                        // RSC Specific
+                        const subtrahend = @as(u64, op1) -% old_carry +% 1;
+                        cpu.cpsr.c.write(subtrahend <= op2);
+                        cpu.cpsr.v.write(((op2 ^ result) & (~op1 ^ result)) >> 31 & 1 == 1);
+                    }
+                },
+                0x8, 0x9, 0xA, 0xB => {
+                    // Test Operation Flags
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+
+                    if (kind == 0xA) {
+                        // CMP specific
+                        cpu.cpsr.c.write(op2 <= op1);
+                        cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
+                    } else if (kind == 0xB) {
+                        // CMN specific
+                        cpu.cpsr.c.write(overflow == 0b1);
+                        cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
+                    } else {
+                        // TST, TEQ specific
+                        // Barrel Shifter should always calc CPSR C in TST
+                        if (!S) _ = exec(true, cpu, opcode);
+                    }
+                },
+            }
+        }
+
+        fn undefinedTestBehaviour(cpu: Arm32) void {
+            @setCold(true);
+            cpu.setCpsr(cpu.spsr.raw);
+        }
+    }.inner;
+}
+
+pub fn sbc(left: u32, right: u32, old_carry: u1) u32 {
+    // TODO: Make your own version (thanks peach.bot)
+    const subtrahend = @as(u64, right) -% old_carry +% 1;
+    const ret = @truncate(u32, left -% subtrahend);
+
+    return ret;
+}
+
+pub fn add(overflow: *u1, left: u32, right: u32) u32 {
+    const ret = @addWithOverflow(left, right);
+    overflow.* = ret[1];
+
+    return ret[0];
+}
+
+pub fn adc(overflow: *u1, left: u32, right: u32, old_carry: u1) u32 {
+    const tmp = @addWithOverflow(left, right);
+    const ret = @addWithOverflow(tmp[0], old_carry);
+    overflow.* = tmp[1] | ret[1];
+
+    return ret[0];
+}

src/arm/cpu/arm/half_signed_data_transfer.zig

@@ -0,0 +1,53 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+const sext = @import("zba-util").sext;
+const rotr = @import("zba-util").rotr;
+
+pub fn halfAndSignedDataTransfer(comptime InstrFn: type, comptime P: bool, comptime U: bool, comptime I: bool, comptime W: bool, comptime L: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u32) void {
+            const rn = opcode >> 16 & 0xF;
+            const rd = opcode >> 12 & 0xF;
+            const rm = opcode & 0xF;
+            const imm_offset_high = opcode >> 8 & 0xF;
+
+            const base = cpu.r[rn] + if (!L and rn == 0xF) 4 else @as(u32, 0);
+            const offset = if (I) imm_offset_high << 4 | rm else cpu.r[rm];
+
+            const modified_base = if (U) base +% offset else base -% offset;
+            var address = if (P) modified_base else base;
+
+            var result: u32 = undefined;
+            if (L) {
+                switch (@truncate(u2, opcode >> 5)) {
+                    0b01 => {
+                        // LDRH
+                        const value = bus.read(u16, address);
+                        result = rotr(u32, value, 8 * (address & 1));
+                    },
+                    0b10 => {
+                        // LDRSB
+                        result = sext(u32, u8, bus.read(u8, address));
+                    },
+                    0b11 => {
+                        // LDRSH
+                        const value = bus.read(u16, address);
+                        result = if (address & 1 == 1) sext(u32, u8, @truncate(u8, value >> 8)) else sext(u32, u16, value);
+                    },
+                    0b00 => unreachable, // SWP
+                }
+            } else {
+                if (opcode >> 5 & 0x01 == 0x01) {
+                    // STRH
+                    bus.write(u16, address, @truncate(u16, cpu.r[rd]));
+                } else unreachable; // SWP
+            }
+
+            address = modified_base;
+            if (W and P or !P) cpu.r[rn] = address;
+            if (L) cpu.r[rd] = result; // // This emulates the LDR rd == rn behaviour
+        }
+    }.inner;
+}

src/arm/cpu/arm/multiply.zig

@@ -0,0 +1,59 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+pub fn multiply(comptime InstrFn: type, comptime A: bool, comptime S: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u32) void {
+            const rd = opcode >> 16 & 0xF;
+            const rn = opcode >> 12 & 0xF;
+            const rs = opcode >> 8 & 0xF;
+            const rm = opcode & 0xF;
+
+            const temp: u64 = @as(u64, cpu.r[rm]) * @as(u64, cpu.r[rs]) + if (A) cpu.r[rn] else 0;
+            const result = @truncate(u32, temp);
+            cpu.r[rd] = result;
+
+            if (S) {
+                cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                cpu.cpsr.z.write(result == 0);
+                // V is unaffected, C is *actually* undefined in ARMv4
+            }
+        }
+    }.inner;
+}
+
+pub fn multiplyLong(comptime InstrFn: type, comptime U: bool, comptime A: bool, comptime S: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u32) void {
+            const rd_hi = opcode >> 16 & 0xF;
+            const rd_lo = opcode >> 12 & 0xF;
+            const rs = opcode >> 8 & 0xF;
+            const rm = opcode & 0xF;
+
+            if (U) {
+                // Signed (WHY IS IT U THEN?)
+                var result: i64 = @as(i64, @bitCast(i32, cpu.r[rm])) * @as(i64, @bitCast(i32, cpu.r[rs]));
+                if (A) result +%= @bitCast(i64, @as(u64, cpu.r[rd_hi]) << 32 | @as(u64, cpu.r[rd_lo]));
+
+                cpu.r[rd_hi] = @bitCast(u32, @truncate(i32, result >> 32));
+                cpu.r[rd_lo] = @bitCast(u32, @truncate(i32, result));
+            } else {
+                // Unsigned
+                var result: u64 = @as(u64, cpu.r[rm]) * @as(u64, cpu.r[rs]);
+                if (A) result +%= @as(u64, cpu.r[rd_hi]) << 32 | @as(u64, cpu.r[rd_lo]);
+
+                cpu.r[rd_hi] = @truncate(u32, result >> 32);
+                cpu.r[rd_lo] = @truncate(u32, result);
+            }
+
+            if (S) {
+                cpu.cpsr.z.write(cpu.r[rd_hi] == 0 and cpu.r[rd_lo] == 0);
+                cpu.cpsr.n.write(cpu.r[rd_hi] >> 31 & 1 == 1);
+                // C and V are set to meaningless values
+            }
+        }
+    }.inner;
+}

src/arm/cpu/arm/psr_transfer.zig

@@ -0,0 +1,59 @@
+const std = @import("std");
+
+const Bus = @import("../../../lib.zig").Bus;
+const PSR = @import("../../../arm.zig").PSR;
+
+const log = std.log.scoped(.PsrTransfer);
+
+const rotr = @import("zba-util").rotr;
+
+pub fn psrTransfer(comptime InstrFn: type, comptime I: bool, comptime R: bool, comptime kind: u2) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u32) void {
+            switch (kind) {
+                0b00 => {
+                    // MRS
+                    const rd = opcode >> 12 & 0xF;
+
+                    if (R and !cpu.hasSPSR()) log.err("Tried to read SPSR from User/System Mode", .{});
+                    cpu.r[rd] = if (R) cpu.spsr.raw else cpu.cpsr.raw;
+                },
+                0b10 => {
+                    // MSR
+                    const field_mask = @truncate(u4, opcode >> 16 & 0xF);
+                    const rm_idx = opcode & 0xF;
+                    const right = if (I) rotr(u32, opcode & 0xFF, (opcode >> 8 & 0xF) * 2) else cpu.r[rm_idx];
+
+                    if (R and !cpu.hasSPSR()) log.err("Tried to write to SPSR in User/System Mode", .{});
+
+                    if (R) {
+                        // arm.gba seems to expect the SPSR to do somethign in SYS mode,
+                        // so we just assume that despite writing to the SPSR in USR or SYS mode
+                        // being UNPREDICTABLE, it just magically has a working SPSR somehow
+                        cpu.spsr.raw = fieldMask(&cpu.spsr, field_mask, right);
+                    } else {
+                        if (cpu.isPrivileged()) cpu.setCpsr(fieldMask(&cpu.cpsr, field_mask, right));
+                    }
+                },
+                else => cpu.panic("[CPU/PSR Transfer] Bits 21:220 of {X:0>8} are undefined", .{opcode}),
+            }
+        }
+    }.inner;
+}
+
+fn fieldMask(psr: *const PSR, field_mask: u4, right: u32) u32 {
+    // This bitwise ORs bits 3 and 0 of the field mask into a u2
+    // We do this because we only care about bits 7:0 and 31:28 of the CPSR
+    const bits = @truncate(u2, (field_mask >> 2 & 0x2) | (field_mask & 1));
+
+    const mask: u32 = switch (bits) {
+        0b00 => 0x0000_0000,
+        0b01 => 0x0000_00FF,
+        0b10 => 0xF000_0000,
+        0b11 => 0xF000_00FF,
+    };
+
+    return (psr.raw & ~mask) | (right & mask);
+}

src/arm/cpu/arm/single_data_swap.zig

@@ -0,0 +1,29 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+const rotr = @import("zba-util").rotr;
+
+pub fn singleDataSwap(comptime InstrFn: type, comptime B: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u32) void {
+            const rn = opcode >> 16 & 0xF;
+            const rd = opcode >> 12 & 0xF;
+            const rm = opcode & 0xF;
+
+            const address = cpu.r[rn];
+
+            if (B) {
+                // SWPB
+                const value = bus.read(u8, address);
+                bus.write(u8, address, @truncate(u8, cpu.r[rm]));
+                cpu.r[rd] = value;
+            } else {
+                // SWP
+                const value = rotr(u32, bus.read(u32, address), 8 * (address & 0x3));
+                bus.write(u32, address, cpu.r[rm]);
+                cpu.r[rd] = value;
+            }
+        }
+    }.inner;
+}

src/arm/cpu/arm/single_data_transfer.zig

@@ -0,0 +1,55 @@
+const shifter = @import("../barrel_shifter.zig");
+const Bus = @import("../../../lib.zig").Bus;
+
+const rotr = @import("zba-util").rotr;
+
+pub fn singleDataTransfer(comptime InstrFn: type, comptime I: bool, comptime P: bool, comptime U: bool, comptime B: bool, comptime W: bool, comptime L: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u32) void {
+            const rn = opcode >> 16 & 0xF;
+            const rd = opcode >> 12 & 0xF;
+
+            const base = cpu.r[rn];
+            const offset = if (I) shifter.immediate(false, cpu, opcode) else opcode & 0xFFF;
+
+            const modified_base = if (U) base +% offset else base -% offset;
+            var address = if (P) modified_base else base;
+
+            var result: u32 = undefined;
+            if (L) {
+                if (B) {
+                    // LDRB
+                    result = bus.read(u8, address);
+                } else {
+                    // LDR
+                    const value = bus.read(u32, address);
+                    result = rotr(u32, value, 8 * (address & 0x3));
+                }
+            } else {
+                if (B) {
+                    // STRB
+                    const value = cpu.r[rd] + if (rd == 0xF) 4 else @as(u32, 0); // PC is 12 ahead
+                    bus.write(u8, address, @truncate(u8, value));
+                } else {
+                    // STR
+                    const value = cpu.r[rd] + if (rd == 0xF) 4 else @as(u32, 0);
+                    bus.write(u32, address, value);
+                }
+            }
+
+            address = modified_base;
+            if (W and P or !P) {
+                cpu.r[rn] = address;
+                if (rn == 0xF) cpu.pipe.reload(cpu);
+            }
+
+            if (L) {
+                // This emulates the LDR rd == rn behaviour
+                cpu.r[rd] = result;
+                if (rd == 0xF) cpu.pipe.reload(cpu);
+            }
+        }
+    }.inner;
+}

src/arm/cpu/arm/software_interrupt.zig

@@ -0,0 +1,23 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+pub fn armSoftwareInterrupt(comptime InstrFn: type) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, _: u32) void {
+            // Copy Values from Current Mode
+            const ret_addr = cpu.r[15] - 4;
+            const cpsr = cpu.cpsr.raw;
+
+            // Switch Mode
+            cpu.changeMode(.Supervisor);
+            cpu.cpsr.t.write(false); // Force ARM Mode
+            cpu.cpsr.i.write(true); // Disable normal interrupts
+
+            cpu.r[14] = ret_addr; // Resume Execution
+            cpu.spsr.raw = cpsr; // Previous mode CPSR
+            cpu.r[15] = 0x0000_0008;
+            cpu.pipe.reload(cpu);
+        }
+    }.inner;
+}

src/arm/cpu/barrel_shifter.zig

@@ -0,0 +1,146 @@
+const CPSR = @import("../../arm.zig").PSR;
+
+const rotr = @import("zba-util").rotr;
+
+pub fn exec(comptime S: bool, cpu: anytype, opcode: u32) u32 {
+    var result: u32 = undefined;
+    if (opcode >> 4 & 1 == 1) {
+        result = register(S, cpu, opcode);
+    } else {
+        result = immediate(S, cpu, opcode);
+    }
+
+    return result;
+}
+
+fn register(comptime S: bool, cpu: anytype, opcode: u32) u32 {
+    const rs_idx = opcode >> 8 & 0xF;
+    const rm = cpu.r[opcode & 0xF];
+    const rs = @truncate(u8, cpu.r[rs_idx]);
+
+    return switch (@truncate(u2, opcode >> 5)) {
+        0b00 => lsl(S, &cpu.cpsr, rm, rs),
+        0b01 => lsr(S, &cpu.cpsr, rm, rs),
+        0b10 => asr(S, &cpu.cpsr, rm, rs),
+        0b11 => ror(S, &cpu.cpsr, rm, rs),
+    };
+}
+
+pub fn immediate(comptime S: bool, cpu: anytype, opcode: u32) u32 {
+    const amount = @truncate(u8, opcode >> 7 & 0x1F);
+    const rm = cpu.r[opcode & 0xF];
+
+    var result: u32 = undefined;
+    if (amount == 0) {
+        switch (@truncate(u2, opcode >> 5)) {
+            0b00 => {
+                // LSL #0
+                result = rm;
+            },
+            0b01 => {
+                // LSR #0 aka LSR #32
+                if (S) cpu.cpsr.c.write(rm >> 31 & 1 == 1);
+                result = 0x0000_0000;
+            },
+            0b10 => {
+                // ASR #0 aka ASR #32
+                result = @bitCast(u32, @bitCast(i32, rm) >> 31);
+                if (S) cpu.cpsr.c.write(result >> 31 & 1 == 1);
+            },
+            0b11 => {
+                // ROR #0 aka RRX
+                const carry: u32 = @boolToInt(cpu.cpsr.c.read());
+                if (S) cpu.cpsr.c.write(rm & 1 == 1);
+
+                result = (carry << 31) | (rm >> 1);
+            },
+        }
+    } else {
+        switch (@truncate(u2, opcode >> 5)) {
+            0b00 => result = lsl(S, &cpu.cpsr, rm, amount),
+            0b01 => result = lsr(S, &cpu.cpsr, rm, amount),
+            0b10 => result = asr(S, &cpu.cpsr, rm, amount),
+            0b11 => result = ror(S, &cpu.cpsr, rm, amount),
+        }
+    }
+
+    return result;
+}
+
+pub fn lsl(comptime S: bool, cpsr: *CPSR, rm: u32, total_amount: u8) u32 {
+    const amount = @truncate(u5, total_amount);
+    const bit_count: u8 = @typeInfo(u32).Int.bits;
+
+    var result: u32 = 0x0000_0000;
+    if (total_amount < bit_count) {
+        // We can perform a well-defined shift here
+        result = rm << amount;
+
+        if (S and total_amount != 0) {
+            const carry_bit = @truncate(u5, bit_count - amount);
+            cpsr.c.write(rm >> carry_bit & 1 == 1);
+        }
+    } else {
+        if (S) {
+            if (total_amount == bit_count) {
+                // Shifted all bits out, carry bit is bit 0 of rm
+                cpsr.c.write(rm & 1 == 1);
+            } else {
+                cpsr.c.write(false);
+            }
+        }
+    }
+
+    return result;
+}
+
+pub fn lsr(comptime S: bool, cpsr: *CPSR, rm: u32, total_amount: u32) u32 {
+    const amount = @truncate(u5, total_amount);
+    const bit_count: u8 = @typeInfo(u32).Int.bits;
+
+    var result: u32 = 0x0000_0000;
+    if (total_amount < bit_count) {
+        // We can perform a well-defined shift
+        result = rm >> amount;
+        if (S and total_amount != 0) cpsr.c.write(rm >> (amount - 1) & 1 == 1);
+    } else {
+        if (S) {
+            if (total_amount == bit_count) {
+                // LSR #32
+                cpsr.c.write(rm >> 31 & 1 == 1);
+            } else {
+                // All bits have been shifted out, including carry bit
+                cpsr.c.write(false);
+            }
+        }
+    }
+
+    return result;
+}
+
+pub fn asr(comptime S: bool, cpsr: *CPSR, rm: u32, total_amount: u8) u32 {
+    const amount = @truncate(u5, total_amount);
+    const bit_count: u8 = @typeInfo(u32).Int.bits;
+
+    var result: u32 = 0x0000_0000;
+    if (total_amount < bit_count) {
+        result = @bitCast(u32, @bitCast(i32, rm) >> amount);
+        if (S and total_amount != 0) cpsr.c.write(rm >> (amount - 1) & 1 == 1);
+    } else {
+        // ASR #32 and ASR #>32 have the same result
+        result = @bitCast(u32, @bitCast(i32, rm) >> 31);
+        if (S) cpsr.c.write(result >> 31 & 1 == 1);
+    }
+
+    return result;
+}
+
+pub fn ror(comptime S: bool, cpsr: *CPSR, rm: u32, total_amount: u8) u32 {
+    const result = rotr(u32, rm, total_amount);
+
+    if (S and total_amount != 0) {
+        cpsr.c.write(result >> 31 & 1 == 1);
+    }
+
+    return result;
+}

src/arm/cpu/thumb/alu.zig

@@ -0,0 +1,108 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+const adc = @import("../arm/data_processing.zig").adc;
+const sbc = @import("../arm/data_processing.zig").sbc;
+
+const lsl = @import("../barrel_shifter.zig").lsl;
+const lsr = @import("../barrel_shifter.zig").lsr;
+const asr = @import("../barrel_shifter.zig").asr;
+const ror = @import("../barrel_shifter.zig").ror;
+
+pub fn fmt4(comptime InstrFn: type, comptime op: u4) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u16) void {
+            const rs = opcode >> 3 & 0x7;
+            const rd = opcode & 0x7;
+            const carry = @boolToInt(cpu.cpsr.c.read());
+
+            const op1 = cpu.r[rd];
+            const op2 = cpu.r[rs];
+
+            var result: u32 = undefined;
+            var overflow: u1 = undefined;
+
+            switch (op) {
+                0x0 => result = op1 & op2, // AND
+                0x1 => result = op1 ^ op2, // EOR
+                0x2 => result = lsl(true, &cpu.cpsr, op1, @truncate(u8, op2)), // LSL
+                0x3 => result = lsr(true, &cpu.cpsr, op1, @truncate(u8, op2)), // LSR
+                0x4 => result = asr(true, &cpu.cpsr, op1, @truncate(u8, op2)), // ASR
+                0x5 => result = adc(&overflow, op1, op2, carry), // ADC
+                0x6 => result = sbc(op1, op2, carry), // SBC
+                0x7 => result = ror(true, &cpu.cpsr, op1, @truncate(u8, op2)), // ROR
+                0x8 => result = op1 & op2, // TST
+                0x9 => result = 0 -% op2, // NEG
+                0xA => result = op1 -% op2, // CMP
+                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,
+                0xF => result = ~op2,
+            }
+
+            // Write to Destination Register
+            switch (op) {
+                0x8, 0xA, 0xB => {},
+                else => cpu.r[rd] = result,
+            }
+
+            // Write Flags
+            switch (op) {
+                0x0, 0x1, 0x2, 0x3, 0x4, 0x7, 0xC, 0xE, 0xF => {
+                    // Logic Operations
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+                    // C set by Barrel Shifter, V is unaffected
+                },
+                0x8, 0xA => {
+                    // Test Flags
+                    // CMN (0xB) is handled with ADC
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+
+                    if (op == 0xA) {
+                        // CMP specific
+                        cpu.cpsr.c.write(op2 <= op1);
+                        cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
+                    }
+                },
+                0x5, 0xB => {
+                    // ADC, CMN
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+                    cpu.cpsr.c.write(overflow == 0b1);
+                    cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
+                },
+                0x6 => {
+                    // SBC
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+
+                    const subtrahend = @as(u64, op2) -% carry +% 1;
+                    cpu.cpsr.c.write(subtrahend <= op1);
+                    cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
+                },
+                0x9 => {
+                    // NEG
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+                    cpu.cpsr.c.write(op2 <= 0);
+                    cpu.cpsr.v.write(((0 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
+                },
+                0xD => {
+                    // Multiplication
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+                    // V is unaffected, assuming similar behaviour to ARMv4 MUL C is undefined
+                },
+            }
+        }
+    }.inner;
+}

src/arm/cpu/thumb/block_data_transfer.zig

@@ -0,0 +1,102 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+pub fn fmt14(comptime InstrFn: type, comptime L: bool, comptime R: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u16) void {
+            const count = @boolToInt(R) + countRlist(opcode);
+            const start = cpu.r[13] - if (!L) count * 4 else 0;
+
+            var end = cpu.r[13];
+            if (L) {
+                end += count * 4;
+            } else {
+                end -= 4;
+            }
+
+            var address = start;
+
+            var i: u4 = 0;
+            while (i < 8) : (i += 1) {
+                if (opcode >> i & 1 == 1) {
+                    if (L) {
+                        cpu.r[i] = bus.read(u32, address);
+                    } else {
+                        bus.write(u32, address, cpu.r[i]);
+                    }
+
+                    address += 4;
+                }
+            }
+
+            if (R) {
+                if (L) {
+                    const value = bus.read(u32, address);
+                    cpu.r[15] = value & ~@as(u32, 1);
+                    cpu.pipe.reload(cpu);
+                } else {
+                    bus.write(u32, address, cpu.r[14]);
+                }
+                address += 4;
+            }
+
+            cpu.r[13] = if (L) end else start;
+        }
+    }.inner;
+}
+
+pub fn fmt15(comptime InstrFn: type, comptime L: bool, comptime rb: u3) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u16) void {
+            var address = cpu.r[rb];
+            const end_address = cpu.r[rb] + 4 * countRlist(opcode);
+
+            if (opcode & 0xFF == 0) {
+                if (L) {
+                    cpu.r[15] = bus.read(u32, address);
+                    cpu.pipe.reload(cpu);
+                } else {
+                    bus.write(u32, address, cpu.r[15] + 2);
+                }
+
+                cpu.r[rb] += 0x40;
+                return;
+            }
+
+            var i: u4 = 0;
+            var first_write = true;
+
+            while (i < 8) : (i += 1) {
+                if (opcode >> i & 1 == 1) {
+                    if (L) {
+                        cpu.r[i] = bus.read(u32, address);
+                    } else {
+                        bus.write(u32, address, cpu.r[i]);
+                    }
+
+                    if (!L and first_write) {
+                        cpu.r[rb] = end_address;
+                        first_write = false;
+                    }
+
+                    address += 4;
+                }
+            }
+
+            if (L and opcode >> rb & 1 != 1) cpu.r[rb] = address;
+        }
+    }.inner;
+}
+
+inline fn countRlist(opcode: u16) u32 {
+    var count: u32 = 0;
+
+    inline for (0..8) |i| {
+        if (opcode >> (7 - i) & 1 == 1) count += 1;
+    }
+
+    return count;
+}

src/arm/cpu/thumb/branch.zig

@@ -0,0 +1,57 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+const sext = @import("zba-util").sext;
+
+pub fn fmt16(comptime InstrFn: type, comptime cond: u4) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u16) void {
+            // B
+            if (cond == 0xE or cond == 0xF)
+                cpu.panic("[CPU/THUMB.16] Undefined conditional branch with condition {}", .{cond});
+
+            if (!cpu.cpsr.check(cond)) return;
+
+            cpu.r[15] +%= sext(u32, u8, opcode & 0xFF) << 1;
+            cpu.pipe.reload(cpu);
+        }
+    }.inner;
+}
+
+pub fn fmt18(comptime InstrFn: type) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        // B but conditional
+        fn inner(cpu: Arm32, _: Bus, opcode: u16) void {
+            cpu.r[15] +%= sext(u32, u11, opcode & 0x7FF) << 1;
+            cpu.pipe.reload(cpu);
+        }
+    }.inner;
+}
+
+pub fn fmt19(comptime InstrFn: type, comptime is_low: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u16) void {
+            // BL
+            const offset = opcode & 0x7FF;
+
+            if (is_low) {
+                // Instruction 2
+                const next_opcode = cpu.r[15] - 2;
+
+                cpu.r[15] = cpu.r[14] +% (offset << 1);
+                cpu.r[14] = next_opcode | 1;
+
+                cpu.pipe.reload(cpu);
+            } else {
+                // Instruction 1
+                const lr_offset = sext(u32, u11, offset) << 12;
+                cpu.r[14] = (cpu.r[15] +% lr_offset) & ~@as(u32, 1);
+            }
+        }
+    }.inner;
+}

src/arm/cpu/thumb/data_processing.zig

@@ -0,0 +1,209 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+const add = @import("../arm/data_processing.zig").add;
+
+const lsl = @import("../barrel_shifter.zig").lsl;
+const lsr = @import("../barrel_shifter.zig").lsr;
+const asr = @import("../barrel_shifter.zig").asr;
+
+pub fn fmt1(comptime InstrFn: type, comptime op: u2, comptime offset: u5) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u16) void {
+            const rs = opcode >> 3 & 0x7;
+            const rd = opcode & 0x7;
+
+            const result = switch (op) {
+                0b00 => blk: {
+                    // LSL
+                    if (offset == 0) {
+                        break :blk cpu.r[rs];
+                    } else {
+                        break :blk lsl(true, &cpu.cpsr, cpu.r[rs], offset);
+                    }
+                },
+                0b01 => blk: {
+                    // LSR
+                    if (offset == 0) {
+                        cpu.cpsr.c.write(cpu.r[rs] >> 31 & 1 == 1);
+                        break :blk @as(u32, 0);
+                    } else {
+                        break :blk lsr(true, &cpu.cpsr, cpu.r[rs], offset);
+                    }
+                },
+                0b10 => blk: {
+                    // ASR
+                    if (offset == 0) {
+                        cpu.cpsr.c.write(cpu.r[rs] >> 31 & 1 == 1);
+                        break :blk @bitCast(u32, @bitCast(i32, cpu.r[rs]) >> 31);
+                    } else {
+                        break :blk asr(true, &cpu.cpsr, cpu.r[rs], offset);
+                    }
+                },
+                else => cpu.panic("[CPU/THUMB.1] 0b{b:0>2} is not a valid op", .{op}),
+            };
+
+            // Equivalent to an ARM MOVS
+            cpu.r[rd] = result;
+
+            // Write Flags
+            cpu.cpsr.n.write(result >> 31 & 1 == 1);
+            cpu.cpsr.z.write(result == 0);
+        }
+    }.inner;
+}
+
+pub fn fmt5(comptime InstrFn: type, comptime op: u2, comptime h1: u1, comptime h2: u1) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u16) void {
+            const rs = @as(u4, h2) << 3 | (opcode >> 3 & 0x7);
+            const rd = @as(u4, h1) << 3 | (opcode & 0x7);
+
+            const op1 = cpu.r[rd];
+            const op2 = cpu.r[rs];
+
+            var result: u32 = undefined;
+            var overflow: u1 = undefined;
+            switch (op) {
+                0b00 => result = add(&overflow, op1, op2), // ADD
+                0b01 => result = op1 -% op2, // CMP
+                0b10 => result = op2, // MOV
+                0b11 => {},
+            }
+
+            // Write to Destination Register
+            switch (op) {
+                0b01 => {}, // Test Instruction
+                0b11 => {
+                    // BX
+                    const is_thumb = op2 & 1 == 1;
+                    cpu.r[15] = op2 & ~@as(u32, 1);
+
+                    cpu.cpsr.t.write(is_thumb);
+                    cpu.pipe.reload(cpu);
+                },
+                else => {
+                    cpu.r[rd] = result;
+                    if (rd == 0xF) {
+                        cpu.r[15] &= ~@as(u32, 1);
+                        cpu.pipe.reload(cpu);
+                    }
+                },
+            }
+
+            // Write Flags
+            switch (op) {
+                0b01 => {
+                    // CMP
+                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                    cpu.cpsr.z.write(result == 0);
+                    cpu.cpsr.c.write(op2 <= op1);
+                    cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
+                },
+                0b00, 0b10, 0b11 => {}, // MOV and Branch Instruction
+            }
+        }
+    }.inner;
+}
+
+pub fn fmt2(comptime InstrFn: type, comptime I: bool, is_sub: bool, rn: u3) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u16) void {
+            const rs = opcode >> 3 & 0x7;
+            const rd = @truncate(u3, opcode);
+            const op1 = cpu.r[rs];
+            const op2: u32 = if (I) rn else cpu.r[rn];
+
+            if (is_sub) {
+                // SUB
+                const result = op1 -% op2;
+                cpu.r[rd] = result;
+
+                cpu.cpsr.n.write(result >> 31 & 1 == 1);
+                cpu.cpsr.z.write(result == 0);
+                cpu.cpsr.c.write(op2 <= op1);
+                cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
+            } else {
+                // ADD
+                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 == 0b1);
+                cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
+            }
+        }
+    }.inner;
+}
+
+pub fn fmt3(comptime InstrFn: type, comptime op: u2, comptime rd: u3) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u16) void {
+            const op1 = cpu.r[rd];
+            const op2: u32 = opcode & 0xFF; // Offset
+
+            var overflow: u1 = undefined;
+            const result: u32 = switch (op) {
+                0b00 => op2, // MOV
+                0b01 => op1 -% op2, // CMP
+                0b10 => add(&overflow, op1, op2), // ADD
+                0b11 => op1 -% op2, // SUB
+            };
+
+            // Write to Register
+            if (op != 0b01) cpu.r[rd] = result;
+
+            // Write Flags
+            cpu.cpsr.n.write(result >> 31 & 1 == 1);
+            cpu.cpsr.z.write(result == 0);
+
+            switch (op) {
+                0b00 => {}, // MOV | C set by Barrel Shifter, V is unaffected
+                0b01, 0b11 => {
+                    // SUB, CMP
+                    cpu.cpsr.c.write(op2 <= op1);
+                    cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
+                },
+                0b10 => {
+                    // ADD
+                    cpu.cpsr.c.write(overflow == 0b1);
+                    cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
+                },
+            }
+        }
+    }.inner;
+}
+
+pub fn fmt12(comptime InstrFn: type, comptime isSP: bool, comptime rd: u3) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u16) void {
+            // ADD
+            const left = if (isSP) cpu.r[13] else cpu.r[15] & ~@as(u32, 2);
+            const right = (opcode & 0xFF) << 2;
+            cpu.r[rd] = left + right;
+        }
+    }.inner;
+}
+
+pub fn fmt13(comptime InstrFn: type, comptime S: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, opcode: u16) void {
+            // ADD
+            const offset = (opcode & 0x7F) << 2;
+            cpu.r[13] = if (S) cpu.r[13] - offset else cpu.r[13] + offset;
+        }
+    }.inner;
+}

src/arm/cpu/thumb/data_transfer.zig

@@ -0,0 +1,153 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+const rotr = @import("zba-util").rotr;
+const sext = @import("zba-util").sext;
+
+pub fn fmt6(comptime InstrFn: type, comptime rd: u3) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u16) void {
+            // LDR
+            const offset = (opcode & 0xFF) << 2;
+
+            // Bit 1 of the PC intentionally ignored
+            cpu.r[rd] = bus.read(u32, (cpu.r[15] & ~@as(u32, 2)) + offset);
+        }
+    }.inner;
+}
+
+pub fn fmt78(comptime InstrFn: type, comptime op: u2, comptime T: bool) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u16) void {
+            const ro = opcode >> 6 & 0x7;
+            const rb = opcode >> 3 & 0x7;
+            const rd = opcode & 0x7;
+
+            const address = cpu.r[rb] +% cpu.r[ro];
+
+            if (T) {
+                // Format 8
+                switch (op) {
+                    0b00 => {
+                        // STRH
+                        bus.write(u16, address, @truncate(u16, cpu.r[rd]));
+                    },
+                    0b01 => {
+                        // LDSB
+                        cpu.r[rd] = sext(u32, u8, bus.read(u8, address));
+                    },
+                    0b10 => {
+                        // LDRH
+                        const value = bus.read(u16, address);
+                        cpu.r[rd] = rotr(u32, value, 8 * (address & 1));
+                    },
+                    0b11 => {
+                        // LDRSH
+                        const value = bus.read(u16, address);
+                        cpu.r[rd] = if (address & 1 == 1) sext(u32, u8, @truncate(u8, value >> 8)) else sext(u32, u16, value);
+                    },
+                }
+            } else {
+                // Format 7
+                switch (op) {
+                    0b00 => {
+                        // STR
+                        bus.write(u32, address, cpu.r[rd]);
+                    },
+                    0b01 => {
+                        // STRB
+                        bus.write(u8, address, @truncate(u8, cpu.r[rd]));
+                    },
+                    0b10 => {
+                        // LDR
+                        const value = bus.read(u32, address);
+                        cpu.r[rd] = rotr(u32, value, 8 * (address & 0x3));
+                    },
+                    0b11 => {
+                        // LDRB
+                        cpu.r[rd] = bus.read(u8, address);
+                    },
+                }
+            }
+        }
+    }.inner;
+}
+
+pub fn fmt9(comptime InstrFn: type, comptime B: bool, comptime L: bool, comptime offset: u5) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u16) void {
+            const rb = opcode >> 3 & 0x7;
+            const rd = opcode & 0x7;
+
+            if (L) {
+                if (B) {
+                    // LDRB
+                    const address = cpu.r[rb] + offset;
+                    cpu.r[rd] = bus.read(u8, address);
+                } else {
+                    // LDR
+                    const address = cpu.r[rb] + (@as(u32, offset) << 2);
+                    const value = bus.read(u32, address);
+                    cpu.r[rd] = rotr(u32, value, 8 * (address & 0x3));
+                }
+            } else {
+                if (B) {
+                    // STRB
+                    const address = cpu.r[rb] + offset;
+                    bus.write(u8, address, @truncate(u8, cpu.r[rd]));
+                } else {
+                    // STR
+                    const address = cpu.r[rb] + (@as(u32, offset) << 2);
+                    bus.write(u32, address, cpu.r[rd]);
+                }
+            }
+        }
+    }.inner;
+}
+
+pub fn fmt10(comptime InstrFn: type, comptime L: bool, comptime offset: u5) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u16) void {
+            const rb = opcode >> 3 & 0x7;
+            const rd = opcode & 0x7;
+
+            const address = cpu.r[rb] + (@as(u6, offset) << 1);
+
+            if (L) {
+                // LDRH
+                const value = bus.read(u16, address);
+                cpu.r[rd] = rotr(u32, value, 8 * (address & 1));
+            } else {
+                // STRH
+                bus.write(u16, address, @truncate(u16, cpu.r[rd]));
+            }
+        }
+    }.inner;
+}
+
+pub fn fmt11(comptime InstrFn: type, comptime L: bool, comptime rd: u3) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, bus: Bus, opcode: u16) void {
+            const offset = (opcode & 0xFF) << 2;
+            const address = cpu.r[13] + offset;
+
+            if (L) {
+                // LDR
+                const value = bus.read(u32, address);
+                cpu.r[rd] = rotr(u32, value, 8 * (address & 0x3));
+            } else {
+                // STR
+                bus.write(u32, address, cpu.r[rd]);
+            }
+        }
+    }.inner;
+}

src/arm/cpu/thumb/software_interrupt.zig

@@ -0,0 +1,23 @@
+const Bus = @import("../../../lib.zig").Bus;
+
+pub fn fmt17(comptime InstrFn: type) InstrFn {
+    const Arm32 = @typeInfo(@typeInfo(InstrFn).Pointer.child).Fn.params[0].type.?;
+
+    return struct {
+        fn inner(cpu: Arm32, _: Bus, _: u16) void {
+            // Copy Values from Current Mode
+            const ret_addr = cpu.r[15] - 2;
+            const cpsr = cpu.cpsr.raw;
+
+            // Switch Mode
+            cpu.changeMode(.Supervisor);
+            cpu.cpsr.t.write(false); // Force ARM Mode
+            cpu.cpsr.i.write(true); // Disable normal interrupts
+
+            cpu.r[14] = ret_addr; // Resume Execution
+            cpu.spsr.raw = cpsr; // Previous mode CPSR
+            cpu.r[15] = 0x0000_0008;
+            cpu.pipe.reload(cpu);
+        }
+    }.inner;
+}

src/arm/v4t.zig

@@ -0,0 +1,229 @@
+const Bus = @import("../lib.zig").Bus;
+
+pub fn arm(comptime Arm32: type) type {
+    return struct {
+        pub const InstrFn = *const fn (*Arm32, Bus, u32) void;
+        pub const lut: [0x1000]InstrFn = populate();
+
+        const processing = @import("cpu/arm/data_processing.zig").dataProcessing;
+        const psrTransfer = @import("cpu/arm/psr_transfer.zig").psrTransfer;
+        const transfer = @import("cpu/arm/single_data_transfer.zig").singleDataTransfer;
+        const halfSignedTransfer = @import("cpu/arm/half_signed_data_transfer.zig").halfAndSignedDataTransfer;
+        const blockTransfer = @import("cpu/arm/block_data_transfer.zig").blockDataTransfer;
+        const branch = @import("cpu/arm/branch.zig").branch;
+        const branchExchange = @import("cpu/arm/branch.zig").branchAndExchange;
+        const swi = @import("cpu/arm/software_interrupt.zig").armSoftwareInterrupt;
+        const swap = @import("cpu/arm/single_data_swap.zig").singleDataSwap;
+
+        const multiply = @import("cpu/arm/multiply.zig").multiply;
+        const multiplyLong = @import("cpu/arm/multiply.zig").multiplyLong;
+
+        /// Determine index into ARM InstrFn LUT
+        pub fn idx(opcode: u32) u12 {
+            return @truncate(u12, opcode >> 20 & 0xFF) << 4 | @truncate(u12, opcode >> 4 & 0xF);
+        }
+
+        // Undefined ARM Instruction handler
+        fn und(cpu: *Arm32, _: Bus, opcode: u32) void {
+            const id = idx(opcode);
+            cpu.panic("[CPU/Decode] ID: 0x{X:0>3} 0x{X:0>8} is an illegal opcode", .{ id, opcode });
+        }
+
+        fn populate() [0x1000]InstrFn {
+            return comptime comptime_blk: {
+                @setEvalBranchQuota(0xE000);
+                var table = [_]InstrFn{und} ** 0x1000;
+
+                for (&table, 0..) |*handler, i| {
+                    handler.* = switch (@as(u2, i >> 10)) {
+                        0b00 => if (i == 0x121) blk: {
+                            break :blk branchExchange(InstrFn);
+                        } else if (i & 0xFCF == 0x009) blk: {
+                            const A = i >> 5 & 1 == 1;
+                            const S = i >> 4 & 1 == 1;
+                            break :blk multiply(InstrFn, A, S);
+                        } else if (i & 0xFBF == 0x109) blk: {
+                            const B = i >> 6 & 1 == 1;
+                            break :blk swap(InstrFn, B);
+                        } else if (i & 0xF8F == 0x089) blk: {
+                            const U = i >> 6 & 1 == 1;
+                            const A = i >> 5 & 1 == 1;
+                            const S = i >> 4 & 1 == 1;
+                            break :blk multiplyLong(InstrFn, U, A, S);
+                        } else if (i & 0xE49 == 0x009 or i & 0xE49 == 0x049) blk: {
+                            const P = i >> 8 & 1 == 1;
+                            const U = i >> 7 & 1 == 1;
+                            const I = i >> 6 & 1 == 1;
+                            const W = i >> 5 & 1 == 1;
+                            const L = i >> 4 & 1 == 1;
+                            break :blk halfSignedTransfer(InstrFn, P, U, I, W, L);
+                        } else if (i & 0xD90 == 0x100) blk: {
+                            const I = i >> 9 & 1 == 1;
+                            const R = i >> 6 & 1 == 1;
+                            const kind = i >> 4 & 0x3;
+                            break :blk psrTransfer(InstrFn, I, R, kind);
+                        } else blk: {
+                            const I = i >> 9 & 1 == 1;
+                            const S = i >> 4 & 1 == 1;
+                            const instrKind = i >> 5 & 0xF;
+                            break :blk processing(InstrFn, I, S, instrKind);
+                        },
+                        0b01 => if (i >> 9 & 1 == 1 and i & 1 == 1) und else blk: {
+                            const I = i >> 9 & 1 == 1;
+                            const P = i >> 8 & 1 == 1;
+                            const U = i >> 7 & 1 == 1;
+                            const B = i >> 6 & 1 == 1;
+                            const W = i >> 5 & 1 == 1;
+                            const L = i >> 4 & 1 == 1;
+                            break :blk transfer(InstrFn, I, P, U, B, W, L);
+                        },
+                        else => switch (@as(u2, i >> 9 & 0x3)) {
+                            // MSB is guaranteed to be 1
+                            0b00 => blk: {
+                                const P = i >> 8 & 1 == 1;
+                                const U = i >> 7 & 1 == 1;
+                                const S = i >> 6 & 1 == 1;
+                                const W = i >> 5 & 1 == 1;
+                                const L = i >> 4 & 1 == 1;
+                                break :blk blockTransfer(InstrFn, P, U, S, W, L);
+                            },
+                            0b01 => blk: {
+                                const L = i >> 8 & 1 == 1;
+                                break :blk branch(InstrFn, L);
+                            },
+                            0b10 => und, // COP Data Transfer
+                            0b11 => if (i >> 8 & 1 == 1) swi(InstrFn) else und, // COP Data Operation + Register Transfer
+                        },
+                    };
+                }
+
+                break :comptime_blk table;
+            };
+        }
+    };
+}
+
+pub fn thumb(comptime Arm32: type) type {
+    return struct {
+        pub const InstrFn = *const fn (*Arm32, Bus, u16) void;
+        pub const lut: [0x400]InstrFn = populate();
+
+        const processing = @import("cpu/thumb/data_processing.zig");
+        const alu = @import("cpu/thumb/alu.zig").fmt4;
+        const transfer = @import("cpu/thumb/data_transfer.zig");
+        const block_transfer = @import("cpu/thumb/block_data_transfer.zig");
+        const swi = @import("cpu/thumb/software_interrupt.zig").fmt17;
+        const branch = @import("cpu/thumb/branch.zig");
+
+        /// Determine index into THUMB InstrFn LUT
+        pub fn idx(opcode: u16) u10 {
+            return @truncate(u10, opcode >> 6);
+        }
+
+        /// Undefined THUMB Instruction Handler
+        fn und(cpu: *Arm32, _: Bus, opcode: u16) void {
+            const id = idx(opcode);
+            cpu.panic("[CPU/Decode] ID: 0b{b:0>10} 0x{X:0>2} is an illegal opcode", .{ id, opcode });
+        }
+
+        fn populate() [0x400]InstrFn {
+            return comptime comptime_blk: {
+                @setEvalBranchQuota(5025); // This is exact
+                var table = [_]InstrFn{und} ** 0x400;
+
+                for (&table, 0..) |*handler, i| {
+                    handler.* = 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;
+                            const rn = i & 0x7;
+                            break :blk processing.fmt2(InstrFn, I, is_sub, rn);
+                        } else blk: {
+                            const op = i >> 5 & 0x3;
+                            const offset = i & 0x1F;
+                            break :blk processing.fmt1(InstrFn, op, offset);
+                        },
+                        0b001 => blk: {
+                            const op = i >> 5 & 0x3;
+                            const rd = i >> 2 & 0x7;
+                            break :blk processing.fmt3(InstrFn, op, rd);
+                        },
+                        0b010 => switch (@as(u2, i >> 5 & 0x3)) {
+                            0b00 => if (i >> 4 & 1 == 1) blk: {
+                                const op = i >> 2 & 0x3;
+                                const h1 = i >> 1 & 1;
+                                const h2 = i & 1;
+                                break :blk processing.fmt5(InstrFn, op, h1, h2);
+                            } else blk: {
+                                const op = i & 0xF;
+                                break :blk alu(InstrFn, op);
+                            },
+                            0b01 => blk: {
+                                const rd = i >> 2 & 0x7;
+                                break :blk transfer.fmt6(InstrFn, rd);
+                            },
+                            else => blk: {
+                                const op = i >> 4 & 0x3;
+                                const T = i >> 3 & 1 == 1;
+                                break :blk transfer.fmt78(InstrFn, op, T);
+                            },
+                        },
+                        0b011 => blk: {
+                            const B = i >> 6 & 1 == 1;
+                            const L = i >> 5 & 1 == 1;
+                            const offset = i & 0x1F;
+                            break :blk transfer.fmt9(InstrFn, B, L, offset);
+                        },
+                        else => switch (@as(u3, i >> 6 & 0x7)) {
+                            // MSB is guaranteed to be 1
+                            0b000 => blk: {
+                                const L = i >> 5 & 1 == 1;
+                                const offset = i & 0x1F;
+                                break :blk transfer.fmt10(InstrFn, L, offset);
+                            },
+                            0b001 => blk: {
+                                const L = i >> 5 & 1 == 1;
+                                const rd = i >> 2 & 0x7;
+                                break :blk transfer.fmt11(InstrFn, L, rd);
+                            },
+                            0b010 => blk: {
+                                const isSP = i >> 5 & 1 == 1;
+                                const rd = i >> 2 & 0x7;
+                                break :blk processing.fmt12(InstrFn, isSP, rd);
+                            },
+                            0b011 => if (i >> 4 & 1 == 1) blk: {
+                                const L = i >> 5 & 1 == 1;
+                                const R = i >> 2 & 1 == 1;
+                                break :blk block_transfer.fmt14(InstrFn, L, R);
+                            } else blk: {
+                                const S = i >> 1 & 1 == 1;
+                                break :blk processing.fmt13(InstrFn, S);
+                            },
+                            0b100 => blk: {
+                                const L = i >> 5 & 1 == 1;
+                                const rb = i >> 2 & 0x7;
+
+                                break :blk block_transfer.fmt15(InstrFn, L, rb);
+                            },
+                            0b101 => if (i >> 2 & 0xF == 0b1111) blk: {
+                                break :blk swi(InstrFn);
+                            } else blk: {
+                                const cond = i >> 2 & 0xF;
+                                break :blk branch.fmt16(InstrFn, cond);
+                            },
+                            0b110 => branch.fmt18(
+                                InstrFn,
+                            ),
+                            0b111 => blk: {
+                                const is_low = i >> 5 & 1 == 1;
+                                break :blk branch.fmt19(InstrFn, is_low);
+                            },
+                        },
+                    };
+                }
+
+                break :comptime_blk table;
+            };
+        }
+    };
+}

src/lib.zig

@@ -1,10 +1,231 @@
 const std = @import("std");
 const testing = std.testing;
 
-export fn add(a: i32, b: i32) i32 {
-    return a + b;
+pub const arm = @import("arm.zig");
+
+const Arm32 = @import("arm.zig").Arm32;
+pub const Arm7tdmi = Arm32(.v4t);
+pub const Arm946es = Arm32(.v5te);
+
+pub const Interpreter = union(enum) {
+    const Self = @This();
+
+    v4t: *Arm7tdmi,
+    v5te: *Arm946es,
+
+    pub fn reset(self: Self) void {
+        switch (self) {
+            inline else => |s| s.reset(),
+        }
+    }
+
+    pub fn step(self: Self) void {
+        switch (self) {
+            inline else => |s| s.step(),
+        }
+    }
+
+    pub fn panic(self: Self, comptime format: []const u8, comptime args: anytype) noreturn {
+        switch (self) {
+            inline else => |s| s.panic(format, args),
+        }
+    }
+};
+
+pub const Bus = struct {
+    ptr: *anyopaque,
+    vtable: *const Vtable,
+
+    const Vtable = struct {
+        read8: *const fn (ptr: *anyopaque, address: u32) u8,
+        read16: *const fn (ptr: *anyopaque, address: u32) u16,
+        read32: *const fn (ptr: *anyopaque, address: u32) u32,
+
+        write8: *const fn (ptr: *anyopaque, address: u32, value: u8) void,
+        write16: *const fn (ptr: *anyopaque, address: u32, value: u16) void,
+        write32: *const fn (ptr: *anyopaque, address: u32, value: u32) void,
+    };
+
+    pub fn init(obj: anytype) @This() {
+        const P = @TypeOf(obj);
+        const info = @typeInfo(P);
+
+        std.debug.assert(info == .Pointer); // `anytype` is a Pointer
+        std.debug.assert(info.Pointer.size == .One); // Single-Item Pointer
+        std.debug.assert(@typeInfo(info.Pointer.child) == .Struct); // Pointer Child is a `struct`
+
+        const alignment = info.Pointer.alignment;
+
+        const impl = struct {
+            fn read8(ptr: *anyopaque, address: u32) u8 {
+                const self = @ptrCast(P, @alignCast(alignment, ptr));
+                return self.read(u8, address);
+            }
+
+            fn read16(ptr: *anyopaque, address: u32) u16 {
+                const self = @ptrCast(P, @alignCast(alignment, ptr));
+                return self.read(u16, address);
+            }
+
+            fn read32(ptr: *anyopaque, address: u32) u32 {
+                const self = @ptrCast(P, @alignCast(alignment, ptr));
+                return self.read(u32, address);
+            }
+
+            fn write8(ptr: *anyopaque, address: u32, value: u8) void {
+                const self = @ptrCast(P, @alignCast(alignment, ptr));
+                return self.write(u8, address, value);
+            }
+
+            fn write16(ptr: *anyopaque, address: u32, value: u16) void {
+                const self = @ptrCast(P, @alignCast(alignment, ptr));
+                return self.write(u16, address, value);
+            }
+
+            fn write32(ptr: *anyopaque, address: u32, value: u32) void {
+                const self = @ptrCast(P, @alignCast(alignment, ptr));
+                return self.write(u32, address, value);
+            }
+        };
+
+        return .{
+            .ptr = obj,
+            .vtable = &.{
+                .read8 = impl.read8,
+                .read16 = impl.read16,
+                .read32 = impl.read32,
+
+                .write8 = impl.write8,
+                .write16 = impl.write16,
+                .write32 = impl.write32,
+            },
+        };
+    }
+
+    pub fn read(self: @This(), comptime T: type, address: u32) T {
+        return switch (T) {
+            u32 => self.vtable.read32(self.ptr, address),
+            u16 => self.vtable.read16(self.ptr, address),
+            u8 => self.vtable.read8(self.ptr, address),
+            else => @compileError("TODO: Fill this in"),
+        };
+    }
+
+    pub fn write(self: @This(), comptime T: type, address: u32, value: T) void {
+        switch (T) {
+            u32 => self.vtable.write32(self.ptr, address, value),
+            u16 => self.vtable.write16(self.ptr, address, value),
+            u8 => self.vtable.write8(self.ptr, address, value),
+            else => @compileError("TODO: Fill this in"),
+        }
+    }
+
+    pub fn dbgRead(self: @This(), comptime T: type, address: u32) T {
+        _ = address;
+        _ = self;
+        @panic("TODO: Implement Debug Reads via Bus Interface");
+    }
+
+    pub fn dbgWrite(self: @This(), comptime T: type, address: u32, value: T) void {
+        _ = self;
+        _ = value;
+        _ = address;
+        @panic("TODO: Implement Debug Writes via Bus Interface");
+    }
+};
+
+pub const Scheduler = struct {
+    ptr: *anyopaque,
+
+    // VTable
+    nowFn: *const fn (ptr: *anyopaque) u64,
+
+    pub fn init(obj: anytype) @This() {
+        const P = @TypeOf(obj);
+        const info = @typeInfo(P);
+
+        std.debug.assert(info == .Pointer); // `anytype` is a Pointer
+        std.debug.assert(info.Pointer.size == .One); // Single-Item Pointer
+        std.debug.assert(@typeInfo(info.Pointer.child) == .Struct); // Pointer Child is a `struct`
+
+        const alignment = info.Pointer.alignment;
+
+        const impl = struct {
+            fn now(ptr: *anyopaque) u64 {
+                const self = @ptrCast(P, @alignCast(alignment, ptr));
+                return self.now();
+            }
+        };
+
+        return .{ .ptr = obj, .nowFn = impl.now };
+    }
+
+    pub fn now(self: @This()) u64 {
+        return self.nowFn(self.ptr);
+    }
+};
+
+// ---
+// TESTING
+// ---
+
+const ExampleBus = struct {
+    _: u32 = 0, // Note: need this field so that the ptr align of *lib.ExampleBus != 0
+
+    pub fn read(self: *@This(), comptime T: type, address: u32) T {
+        _ = self;
+        _ = address;
+        return 0;
+    }
+
+    pub fn write(self: *@This(), comptime T: type, address: u32, value: T) void {
+        _ = self;
+        _ = value;
+        _ = address;
+    }
+};
+
+const ExampleScheduler = struct {
+    tick: u64 = 0,
+
+    pub fn now(self: *const @This()) u64 {
+        return self.tick;
+    }
+};
+
+test "create ARMv4T interface" {
+    var bus_impl = ExampleBus{};
+    var scheduler_impl = ExampleScheduler{};
+
+    const bus_interface = Bus.init(&bus_impl);
+    const scheduler_interface = Scheduler.init(&scheduler_impl);
+
+    var arm7tdmi = Arm7tdmi{
+        .sched = scheduler_interface,
+        .bus = bus_interface,
+        .cpsr = .{ .raw = 0x0000_001F },
+        .spsr = .{ .raw = 0x0000_0000 },
+    };
+
+    var icpu = arm7tdmi.interface();
+
+    icpu.reset();
+    icpu.step();
 }
 
-test "basic add functionality" {
-    try testing.expect(add(3, 7) == 10);
+test "create ARMv5TE interface" {
+    var bus_impl = ExampleBus{};
+    var scheduler_impl = ExampleScheduler{};
+
+    const bus_interface = Bus.init(&bus_impl);
+    const scheduler_interface = Scheduler.init(&scheduler_impl);
+
+    var arm946es = Arm946es{
+        .sched = scheduler_interface,
+        .bus = bus_interface,
+        .cpsr = .{ .raw = 0x0000_001F },
+        .spsr = .{ .raw = 0x0000_0000 },
+    };
+
+    _ = arm946es.interface();
 }