i should implement DSP DMA...

d611a21e5 imma stop using size_t

git-subtree-dir: external/ircolib
git-subtree-split: d611a21e50fcfdfb5f34a7f79c4c690c50d85c5f

CMakeLists.txt

@@ -28,6 +28,12 @@ add_executable(weee main.cpp core/mem.cpp core/loaders/elf.cpp
     core/loaders/dol.cpp
     core/broadway.cpp
     core/broadway/instructions.cpp
-    core/broadway/mmio/vi.cpp)
+    core/broadway/mmio/vi.cpp
+    core/broadway/mmio/pi.cpp
+    core/broadway/mmio/mi.cpp
+    core/broadway/mmio/dsp.cpp
+    core/broadway/mmio/ai.cpp
+    core/broadway/mmio/exi.cpp
+    core/broadway/mmio/si.cpp)
 target_link_libraries(weee PUBLIC SDL3::SDL3 capstone)
 target_include_directories(weee PUBLIC core)

core/broadway.cpp

@@ -16,9 +16,10 @@ broadway::broadway() {
 void broadway::set_pc(ircolib::u32 value) { pc = value; }
 
 void broadway::run(mem &mem) {
-    for (int i = 0; i < 12150000; i++) {
-        // std::println("pc: 0x{:08X}", pc);
-        execute(fetch(mem), mem);
+    std::println("pc: 0x{:08X}", pc);
+    for (int i = 0; i < 1000000; i++) {
+        ircolib::u32 instr = fetch(mem);
+        execute(instr, mem);
     }
 }
 
@@ -45,7 +46,10 @@ void broadway::decode_special3(ircolib::u32 instr, mem &mem) {
         mtfsf(instr);
         break;
     default:
-        ircolib::panic("broadway unknown special3 {} (0x{:04X}) (pc 0x{:08X})", secondary, secondary, pc - 4);
+        std::println("broadway unknown special3 {} (0x{:04X}) (pc 0x{:08X})", secondary, secondary, pc - 4);
+        std::println("disassembly:");
+        print_disasm(instr);
+        ircolib::panic("LR: 0x{:08X}", lr);
     }
 }
 
@@ -55,6 +59,21 @@ void broadway::decode_special2(ircolib::u32 instr, mem &mem) {
     case 0x000:
         cmp(instr);
         break;
+    case 0x008:
+        subfc(instr);
+        break;
+    case 0x00A:
+        addc(instr);
+        break;
+    case 0x013:
+        mfcr(instr);
+        break;
+    case 0x017:
+        lwzx(instr, mem);
+        break;
+    case 0x01C:
+        and(instr);
+        break;
     case 0x020:
         cmpl(instr);
         break;
@@ -64,9 +83,36 @@ void broadway::decode_special2(ircolib::u32 instr, mem &mem) {
     case 0x053:
         mfmsr(instr);
         break;
+    case 0x088:
+        subfe(instr);
+        break;
+    case 0x08A:
+        adde(instr);
+        break;
+    case 0x090:
+        mtcrf(instr);
+        break;
+    case 0x092:
+        mtmsr(instr);
+        break;
+    case 0x097:
+        stwx(instr, mem);
+        break;
+    case 0x0CA:
+        addze(instr);
+        break;
     case 0x0D2:
         ircolib::warn("broadway TODO mtsr (pc 0x{:08X})", pc - 4);
         break;
+    case 0x0EB:
+        mullw(instr);
+        break;
+    case 0x117:
+        lhzx(instr, mem);
+        break;
+    case 0x173:
+        mftb(instr);
+        break;
     case 0x1BC:
         or (instr);
         break;
@@ -80,10 +126,19 @@ void broadway::decode_special2(ircolib::u32 instr, mem &mem) {
     case 0x10A:
         add(instr);
         break;
+    case 0x1CB:
+        divwu(instr);
+        break;
     case 0x256: // sync
         break;
+    case 0x318:
+        sraw(instr);
+        break;
     default:
-        ircolib::panic("broadway unknown special2 {} (0x{:04X}) (pc 0x{:08X})", secondary, secondary, pc - 4);
+        std::println("broadway unknown special2 {} (0x{:04X}) (pc 0x{:08X})", secondary, secondary, pc - 4);
+        std::println("disassembly:");
+        print_disasm(instr);
+        ircolib::panic("LR: 0x{:08X}", lr);
     }
 }
 
@@ -98,19 +153,35 @@ void broadway::decode_special1(ircolib::u32 instr, mem &mem) {
     case 0x96: // isync
         break;
     default:
-        ircolib::panic("broadway unknown special1 {} (0x{:04X}) (pc 0x{:08X})", utils::secondary(instr),
-                       utils::secondary(instr), pc - 4);
+        std::println("broadway unknown special1 {} (0x{:04X}) (pc 0x{:08X})", utils::secondary(instr),
+                     utils::secondary(instr), pc - 4);
+        std::println("disassembly:");
+        print_disasm(instr);
+        ircolib::panic("LR: 0x{:08X}", lr);
     }
 }
 
 void broadway::execute(ircolib::u32 instr, mem &mem) {
-    switch (utils::primary(instr)) {
+    const auto primary = utils::primary(instr);
+    switch (primary) {
+    case 7:
+        mulli(instr);
+        break;
+    case 8:
+        subfic(instr);
+        break;
     case 10:
         cmpli(instr);
         break;
     case 11:
         cmpi(instr);
         break;
+    case 12:
+        addic(instr);
+        break;
+    case 13:
+        addicr(instr);
+        break;
     case 14:
         addi(instr);
         break;
@@ -126,6 +197,9 @@ void broadway::execute(ircolib::u32 instr, mem &mem) {
     case 19:
         decode_special1(instr, mem);
         break;
+    case 20:
+        rlwimi(instr);
+        break;
     case 21:
         rlwinm(instr);
         break;
@@ -135,9 +209,15 @@ void broadway::execute(ircolib::u32 instr, mem &mem) {
     case 25:
         oris(instr);
         break;
+    case 26:
+        xori(instr);
+        break;
     case 28:
         andi(instr);
         break;
+    case 29:
+        andis(instr);
+        break;
     case 31:
         decode_special2(instr, mem);
         break;
@@ -147,18 +227,30 @@ void broadway::execute(ircolib::u32 instr, mem &mem) {
     case 33:
         lwzu(instr, mem);
         break;
+    case 34:
+        lbz(instr, mem);
+        break;
     case 36:
         stw(instr, mem);
         break;
     case 37:
         stwu(instr, mem);
         break;
+    case 38:
+        stb(instr, mem);
+        break;
     case 39:
         stbu(instr, mem);
         break;
+    case 40:
+        lhz(instr, mem);
+        break;
     case 44:
         sth(instr, mem);
         break;
+    case 45:
+        sthu(instr, mem);
+        break;
     case 50:
         lfd(instr, mem);
         break;
@@ -166,10 +258,10 @@ void broadway::execute(ircolib::u32 instr, mem &mem) {
         decode_special3(instr, mem);
         break;
     default:
-        std::println("broadway::execute unimplemented instruction 0x{:08X} / 0b{:032b}", instr, instr);
+        std::println("broadway::execute unimplemented instruction 0x{:08X} / 0b{:032b} ({})", instr, instr, primary);
         std::println("disassembly:");
         print_disasm(instr);
-        ircolib::panic("");
+        ircolib::panic("LR: 0x{:08X}", lr);
     }
 }
 
@@ -179,11 +271,11 @@ void broadway::print_disasm(ircolib::u32 instr) {
 
     cs_insn *insn;
     auto instr_buff = ircolib::integral_to_slice(std::byteswap(instr));
-    size_t count = cs_disasm(capstone, instr_buff.data(), instr_buff.size(), pc - 4, 1, &insn);
+    ircolib::u32 count = cs_disasm(capstone, instr_buff.data(), instr_buff.size(), pc - 4, 1, &insn);
     if (count <= 0)
         return;
 
-    size_t j;
+    ircolib::u32 j;
     for (j = 0; j < count; j++) {
         std::println("\t0x{:x}:\t{}\t\t{}", insn[j].address, insn[j].mnemonic, insn[j].op_str);
     }

core/broadway.hpp

@@ -17,7 +17,7 @@ struct broadway {
     void execute(ircolib::u32, mem &);
 
     bool disasm_available = true;
-    ircolib::u32 pc = 0, lr = 0, ctr = 0, cr = 0, srr0 = 0, fpscr = 0, msr = 0;
+    ircolib::u32 pc = 0, lr = 0, ctr = 0, cr = 0, srr0 = 0, fpscr = 0, msr = 0, tbl = 0, tbu = 0;
     union {
         struct {
             unsigned bytecount : 7;
@@ -38,8 +38,8 @@ struct broadway {
     bool get_cr_bit(ircolib::u8 index, ircolib::u8 bit) { return (cr >> index * 4) & (1 << (4 - bit)); }
 
     // bat registers indexes
-    static constexpr std::size_t BAT_LOWER_OFFSET = 0;
-    static constexpr std::size_t BAT_UPPER_OFFSET = 8;
+    static constexpr ircolib::u32 BAT_LOWER_OFFSET = 0;
+    static constexpr ircolib::u32 BAT_UPPER_OFFSET = 8;
 
     std::array<ircolib::u32, 16> ibat, dbat;
     std::array<ircolib::u32, 32> gpr{};
@@ -63,19 +63,34 @@ struct broadway {
     bool test_cond_and_ctr(ircolib::u32);
 
     void andi(ircolib::u32);
+    void andis(ircolib::u32);
+    void and(ircolib::u32);
     void add(ircolib::u32);
+    void addc(ircolib::u32);
+    void adde(ircolib::u32);
+    void addze(ircolib::u32);
     void addis(ircolib::u32);
     void addi(ircolib::u32);
+    void addic(ircolib::u32);
+    void addicr(ircolib::u32);
     void ori(ircolib::u32);
     void oris(ircolib::u32);
     void bx(ircolib::u32);
     void bcx(ircolib::u32);
     void mftspr(bool, ircolib::u32);
+    void mtcrf(ircolib::u32);
     void stw(ircolib::u32, mem &);
+    void stb(ircolib::u32, mem &);
     void stwu(ircolib::u32, mem &);
+    void sthu(ircolib::u32, mem &);
+    void stwx(ircolib::u32, mem &);
     void stbu(ircolib::u32, mem &);
     void sth(ircolib::u32, mem &);
+    void lbz(ircolib::u32, mem &);
     void lwz(ircolib::u32, mem &);
+    void lwzx(ircolib::u32, mem &);
+    void lhz(ircolib::u32, mem &);
+    void lhzx(ircolib::u32, mem &);
     void lfd(ircolib::u32, mem &);
     void bclrx(ircolib::u32);
     void cmpi(ircolib::u32);
@@ -83,15 +98,27 @@ struct broadway {
     void cmp(ircolib::u32);
     void cmpl(ircolib::u32);
     void rlwinm(ircolib::u32);
+    void rlwimi(ircolib::u32);
     void lwzu(ircolib::u32, mem &);
     void rfi(ircolib::u32);
+    void mfcr(ircolib::u32);
     void mtfsf(ircolib::u32);
     void mtfsb1(ircolib::u32);
     void mtfsb0(ircolib::u32);
     void mfmsr(ircolib::u32);
+    void mtmsr(ircolib::u32);
+    void mullw(ircolib::u32);
+    void mulli(ircolib::u32);
     void nand(ircolib::u32);
     void subf(ircolib::u32);
+    void subfc(ircolib::u32);
+    void subfic(ircolib::u32);
+    void subfe(ircolib::u32);
     void or (ircolib::u32);
+    void xori(ircolib::u32);
+    void divwu(ircolib::u32);
+    void mftb(ircolib::u32);
+    void sraw(ircolib::u32);
 
     inline void cr0_update(bool condition, ircolib::s32 result) {
         if (condition) {

core/broadway/instructions.cpp

@@ -3,10 +3,38 @@
 #include <mem.hpp>
 
 namespace weee::core {
-void broadway::add(ircolib::u32 instr) { gpr[utils::RD(instr)] = gpr[utils::RA(instr)] + gpr[utils::RB(instr)]; }
+void broadway::add(ircolib::u32 instr) {
+    gpr[utils::RD(instr)] = gpr[utils::RA(instr)] + gpr[utils::RB(instr)];
+    cr0_update(instr & 1, gpr[utils::RD(instr)]);
+}
+
+void broadway::addc(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool carry = __builtin_add_overflow(gpr[utils::RA(instr)], gpr[utils::RB(instr)], &sum);
+    cr0_update(instr & 1, sum);
+    xer.ca = carry;
+    gpr[utils::RD(instr)] = sum;
+}
+
+void broadway::adde(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool c0 = __builtin_add_overflow(gpr[utils::RA(instr)], gpr[utils::RB(instr)], &sum);
+    bool c1 = __builtin_add_overflow(sum, xer.ca, &sum);
+    cr0_update(instr & 1, sum);
+    xer.ca = c0 | c1;
+    gpr[utils::RD(instr)] = sum;
+}
+
+void broadway::addze(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool c1 = __builtin_add_overflow(gpr[utils::RA(instr)], xer.ca, &sum);
+    cr0_update(instr & 1, sum);
+    xer.ca = c1;
+    gpr[utils::RD(instr)] = sum;
+}
 
 void broadway::addi(ircolib::u32 instr) {
-    if (utils::RA(instr) == 0) { // lis
+    if (utils::RA(instr) == 0) { // li
         gpr[utils::RD(instr)] = ircolib::s32(utils::SIMM(instr));
         return;
     }
@@ -14,6 +42,21 @@ void broadway::addi(ircolib::u32 instr) {
     gpr[utils::RD(instr)] = gpr[utils::RA(instr)] + (ircolib::s32(utils::SIMM(instr)));
 }
 
+void broadway::addic(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool carry = __builtin_add_overflow(gpr[utils::RA(instr)], ircolib::s32(utils::SIMM(instr)), &sum);
+    gpr[utils::RD(instr)] = sum;
+    xer.ca = carry;
+}
+
+void broadway::addicr(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool carry = __builtin_add_overflow(gpr[utils::RA(instr)], ircolib::s32(utils::SIMM(instr)), &sum);
+    cr0_update(true, sum);
+    gpr[utils::RD(instr)] = sum;
+    xer.ca = carry;
+}
+
 void broadway::addis(ircolib::u32 instr) {
     if (utils::RA(instr) == 0) { // lis
         gpr[utils::RD(instr)] = ircolib::s32(utils::SIMM(instr)) << 16;
@@ -67,7 +110,7 @@ void broadway::bcx(ircolib::u32 instr) {
 }
 
 void broadway::mftspr(bool dir, ircolib::u32 instr) {
-    const size_t spr_field = (instr >> 11) & 0x3FF;
+    const ircolib::u32 spr_field = (instr >> 11) & 0x3FF;
 
     auto move_to_or_from_spr = [&](ircolib::u32 &spr) {
         if (dir) { // mtspr
@@ -145,12 +188,30 @@ void broadway::stwu(ircolib::u32 instr, mem &mem) {
 
     const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
     auto _ = mem.write32(EA, gpr[utils::RS(instr)])
-             .and_then([&] { return std::expected<void, std::string>(); })
+             .and_then([&] {
+                 gpr[utils::RA(instr)] = EA;
+                 return std::expected<void, std::string>();
+             })
              .or_else([&](std::string e) {
                  ircolib::panic("stwu broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
                  return std::expected<void, std::string>();
              });
-    gpr[utils::RA(instr)] = EA;
+}
+
+void broadway::sthu(ircolib::u32 instr, mem &mem) {
+    if (utils::RA(instr) == 0)
+        ircolib::panic("broadway::sthu with ra == 0");
+
+    const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
+    auto _ = mem.write16(EA, gpr[utils::RS(instr)])
+             .and_then([&] {
+                 gpr[utils::RA(instr)] = EA;
+                 return std::expected<void, std::string>();
+             })
+             .or_else([&](std::string e) {
+                 ircolib::panic("sthu broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
+                 return std::expected<void, std::string>();
+             });
 }
 
 void broadway::stbu(ircolib::u32 instr, mem &mem) {
@@ -159,12 +220,14 @@ void broadway::stbu(ircolib::u32 instr, mem &mem) {
 
     const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
     auto _ = mem.write8(EA, gpr[utils::RS(instr)])
-             .and_then([&] { return std::expected<void, std::string>(); })
+             .and_then([&] {
+                 gpr[utils::RA(instr)] = EA;
+                 return std::expected<void, std::string>();
+             })
              .or_else([&](std::string e) {
                  ircolib::panic("stbu broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
                  return std::expected<void, std::string>();
              });
-    gpr[utils::RA(instr)] = EA;
 }
 
 void broadway::stw(ircolib::u32 instr, mem &mem) {
@@ -181,13 +244,26 @@ void broadway::stw(ircolib::u32 instr, mem &mem) {
              });
 }
 
+void broadway::stb(ircolib::u32 instr, mem &mem) {
+    ircolib::s32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    const ircolib::u32 EA = b + utils::SIMM(instr);
+    auto _ = mem.write8(EA, gpr[utils::RS(instr)])
+             .and_then([&] { return std::expected<void, std::string>(); })
+             .or_else([&](std::string e) {
+                 ircolib::panic("stw broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
+                 return std::expected<void, std::string>();
+             });
+}
+
 void broadway::sth(ircolib::u32 instr, mem &mem) {
     ircolib::u32 b = gpr[utils::RA(instr)];
     if (utils::RA(instr) == 0)
         b = 0;
 
-    const ircolib::s32 d = utils::SIMM(instr);
-    const ircolib::u32 EA = b + d;
+    const ircolib::u32 EA = b + utils::SIMM(instr);
 
     auto _ = mem.write16(EA, ircolib::u16(gpr[utils::RS(instr)]))
              .and_then([&] { return std::expected<void, std::string>(); })
@@ -197,6 +273,20 @@ void broadway::sth(ircolib::u32 instr, mem &mem) {
              });
 }
 
+void broadway::stwx(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    const ircolib::u32 EA = b + gpr[utils::RB(instr)];
+    auto _ = mem.write32(EA, gpr[utils::RS(instr)])
+             .and_then([&] { return std::expected<void, std::string>(); })
+             .or_else([&](std::string e) {
+                 ircolib::panic("stwx broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
+                 return std::expected<void, std::string>();
+             });
+}
+
 void broadway::lwz(ircolib::u32 instr, mem &mem) {
     ircolib::u32 b = gpr[utils::RA(instr)];
     if (utils::RA(instr) == 0)
@@ -207,7 +297,71 @@ void broadway::lwz(ircolib::u32 instr, mem &mem) {
     gpr[utils::RD(instr)] = mem.read32(ea)
                             .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
                             .or_else([&](std::string e) {
-                                ircolib::panic("broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                ircolib::panic("lwz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                return std::expected<ircolib::u32, std::string>();
+                            })
+                            .value();
+}
+
+void broadway::lwzx(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    ircolib::u32 ea = ircolib::s32(b) + gpr[utils::RB(instr)];
+
+    gpr[utils::RD(instr)] = mem.read32(ea)
+                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                            .or_else([&](std::string e) {
+                                ircolib::panic("lwz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                return std::expected<ircolib::u32, std::string>();
+                            })
+                            .value();
+}
+
+void broadway::lhz(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);
+
+    gpr[utils::RD(instr)] = mem.read16(ea)
+                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                            .or_else([&](std::string e) {
+                                ircolib::panic("lhz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                return std::expected<ircolib::u32, std::string>();
+                            })
+                            .value();
+}
+
+void broadway::lhzx(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    ircolib::u32 ea = ircolib::s32(b) + gpr[utils::RB(instr)];
+
+    gpr[utils::RD(instr)] = mem.read16(ea)
+                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                            .or_else([&](std::string e) {
+                                ircolib::panic("lhzx broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                return std::expected<ircolib::u32, std::string>();
+                            })
+                            .value();
+}
+
+void broadway::lbz(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);
+
+    gpr[utils::RD(instr)] = mem.read8(ea)
+                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                            .or_else([&](std::string e) {
+                                ircolib::panic("lbz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
                                 return std::expected<ircolib::u32, std::string>();
                             })
                             .value();
@@ -219,16 +373,15 @@ void broadway::lfd(ircolib::u32 instr, mem &mem) {
         b = 0;
 
     ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);
-    double val;
-    ircolib::u64 read = mem.read64(ea)
-                        .and_then([&](ircolib::u64 val) { return std::expected<ircolib::u64, std::string>(val); })
-                        .or_else([&](std::string e) {
-                            ircolib::panic("broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
-                            return std::expected<ircolib::u64, std::string>();
-                        })
-                        .value();
-    memcpy(&val, &read, 8);
-    fgrs[utils::RD(instr)].ps0 = val;
+
+    fgrs[utils::RD(instr)].ps0 =
+    mem.read64(ea)
+    .and_then([&](ircolib::u64 val) { return std::expected<ircolib::u64, std::string>(val); })
+    .or_else([&](std::string e) {
+        ircolib::panic("lfd broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+        return std::expected<ircolib::u64, std::string>();
+    })
+    .value();
 }
 
 void broadway::bclrx(ircolib::u32 instr) {
@@ -305,9 +458,32 @@ void broadway::rlwinm(ircolib::u32 instr) {
     ircolib::u32 r = std::rotl(gpr[utils::RS(instr)], sh);
     const ircolib::u8 mb = (instr >> 6) & 0x1f;
     const ircolib::u8 me = (instr >> 1) & 0x1f;
+    const ircolib::u32 start = 0xffffffff >> mb;
+    const ircolib::u32 end = 0x7fffffff >> me;
+    ircolib::u32 mask = start ^ end;
+    if (mb > me)
+        mask = ~mask;
 
-    r &= ~((0xFFFF'FFFF >> mb) << me);
+    r &= mask;
     gpr[utils::RA(instr)] = r;
+    cr0_update(instr & 1, r);
+}
+
+void broadway::rlwimi(ircolib::u32 instr) {
+    const ircolib::u8 sh = (instr >> 11) & 0x1f;
+    ircolib::u32 r = std::rotl(gpr[utils::RS(instr)], sh);
+    const ircolib::u8 mb = (instr >> 6) & 0x1f;
+    const ircolib::u8 me = (instr >> 1) & 0x1f;
+    const ircolib::u32 start = 0xffffffff >> mb;
+    const ircolib::u32 end = 0x7fffffff >> me;
+    ircolib::u32 mask = start ^ end;
+    if (mb > me)
+        mask = ~mask;
+
+    r &= mask;
+    r |= (gpr[utils::RA(instr)] & ~mask);
+    gpr[utils::RA(instr)] = r;
+    cr0_update(instr & 1, r);
 }
 
 void broadway::lwzu(ircolib::u32 instr, mem &mem) {
@@ -316,16 +492,21 @@ void broadway::lwzu(ircolib::u32 instr, mem &mem) {
 
     const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
     gpr[utils::RD(instr)] = mem.read32(EA)
-                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                            .and_then([&](ircolib::u32 val) {
+                                gpr[utils::RA(instr)] = EA;
+                                return std::expected<ircolib::u32, std::string>(val);
+                            })
                             .or_else([&](std::string e) {
-                                ircolib::panic("broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                ircolib::panic("lwzu broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
                                 return std::expected<ircolib::u32, std::string>();
                             })
                             .value();
-    gpr[utils::RA(instr)] = EA;
 }
 
-void broadway::rfi(ircolib::u32 instr) { pc = srr0; }
+void broadway::rfi(ircolib::u32 instr) {
+    pc = srr0;
+    ircolib::clear_bit(msr, 13);
+}
 
 void broadway::andi(ircolib::u32 instr) {
     const ircolib::s32 result = gpr[utils::RS(instr)] & utils::UIMM(instr);
@@ -333,6 +514,18 @@ void broadway::andi(ircolib::u32 instr) {
     cr0_update(true, result);
 }
 
+void broadway::andis(ircolib::u32 instr) {
+    const ircolib::s32 result = gpr[utils::RS(instr)] & (ircolib::u32(utils::UIMM(instr)) << 16);
+    gpr[utils::RA(instr)] = result;
+    cr0_update(true, result);
+}
+
+void broadway::and(ircolib::u32 instr) {
+    const ircolib::s32 result = gpr[utils::RS(instr)] & gpr[utils::RB(instr)];
+    gpr[utils::RA(instr)] = result;
+    cr0_update(instr & 1, result);
+}
+
 void broadway::mtfsf(ircolib::u32 instr) {
     const ircolib::u8 fm = (instr >> 17) & 0xff;
     ircolib::u8 mask = 0;
@@ -363,6 +556,7 @@ void broadway::mtfsb1(ircolib::u32 instr) {
 }
 
 void broadway::mfmsr(ircolib::u32 instr) { gpr[utils::RS(instr)] = msr; }
+void broadway::mtmsr(ircolib::u32 instr) { msr = gpr[utils::RS(instr)]; }
 
 void broadway::nand(ircolib::u32 instr) {
     gpr[utils::RA(instr)] = ~(gpr[utils::RS(instr)] & gpr[utils::RB(instr)]);
@@ -370,12 +564,97 @@ void broadway::nand(ircolib::u32 instr) {
 }
 
 void broadway::subf(ircolib::u32 instr) {
-    gpr[utils::RD(instr)] = ~(gpr[utils::RA(instr)] + gpr[utils::RB(instr)] + 1);
+    gpr[utils::RD(instr)] = ~gpr[utils::RA(instr)] + gpr[utils::RB(instr)];
     cr0_update(instr & 1, gpr[utils::RD(instr)]);
 }
 
+void broadway::subfc(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool c0 = __builtin_add_overflow(~gpr[utils::RA(instr)], 1, &sum);
+    bool c1 = __builtin_add_overflow(sum, gpr[utils::RB(instr)], &sum);
+    cr0_update(instr & 1, sum);
+    xer.ca = !c0 | c1;
+    gpr[utils::RD(instr)] = sum;
+}
+
+void broadway::subfic(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool c0 = __builtin_add_overflow(~gpr[utils::RA(instr)], 1, &sum);
+    bool c1 = __builtin_add_overflow(sum, utils::SIMM(instr), &sum);
+    xer.ca = !c0 | c1;
+    gpr[utils::RD(instr)] = sum;
+}
+
+void broadway::subfe(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool c0 = __builtin_add_overflow(~gpr[utils::RA(instr)], gpr[utils::RB(instr)], &sum);
+    bool c1 = __builtin_add_overflow(sum, xer.ca, &sum);
+    cr0_update(instr & 1, sum);
+    xer.ca = c0 | c1;
+    gpr[utils::RD(instr)] = sum;
+}
+
 void broadway:: or (ircolib::u32 instr) {
-    gpr[utils::RA(instr)] = gpr[utils::RS(instr)] & gpr[utils::RB(instr)];
+    gpr[utils::RA(instr)] = gpr[utils::RS(instr)] | gpr[utils::RB(instr)];
     cr0_update(instr & 1, gpr[utils::RA(instr)]);
 }
+
+void broadway::xori(ircolib::u32 instr) { gpr[utils::RA(instr)] = gpr[utils::RS(instr)] ^ utils::UIMM(instr); }
+
+void broadway::mullw(ircolib::u32 instr) {
+    gpr[utils::RD(instr)] = ircolib::u64(gpr[utils::RA(instr)]) * ircolib::u64(gpr[utils::RB(instr)]);
+}
+
+void broadway::mulli(ircolib::u32 instr) {
+    gpr[utils::RD(instr)] = ircolib::u64(gpr[utils::RA(instr)]) * ircolib::u64(utils::SIMM(instr));
+}
+
+void broadway::mfcr(ircolib::u32 instr) { gpr[utils::RD(instr)] = cr; }
+
+void broadway::mtcrf(ircolib::u32 instr) {
+    ircolib::u32 mask = 0;
+    const ircolib::u8 crm = (instr >> 13) & 0xff;
+    for (int i = 0; i < 7; i++) {
+        if (ircolib::is_bit_set(crm, i)) {
+            set_cr(gpr[utils::RS(instr)] & (0xffff << i * 4), i);
+        }
+    }
+}
+
+void broadway::divwu(ircolib::u32 instr) {
+    ircolib::u32 dividend = gpr[utils::RA(instr)];
+    ircolib::u32 divisor = gpr[utils::RB(instr)];
+    if (divisor == 0) {
+        if ((instr >> 11) & 1)
+            xer.ov = true;
+
+        return;
+    }
+
+    gpr[utils::RD(instr)] = dividend / divisor;
+    cr0_update(instr & 1, gpr[utils::RD(instr)]);
+}
+
+void broadway::mftb(ircolib::u32 instr) {
+    const ircolib::u32 tbr = (instr >> 11) & 0x3FF;
+
+    if (tbr != 392 && tbr != 424)
+        ircolib::panic("broadway::mftb with tbr != 268 && != 269 ({})", tbr);
+
+    if (tbr == 392)
+        gpr[utils::RD(instr)] = tbl;
+
+    if (tbr == 424)
+        gpr[utils::RD(instr)] = tbu;
+}
+
+void broadway::sraw(ircolib::u32 instr) {
+    ircolib::u8 shift = std::min(gpr[utils::RB(instr)] & 0x3f, ircolib::u32(31));
+    ircolib::s32 rs = gpr[utils::RS(instr)];
+    ircolib::s32 result = rs >> shift;
+    ircolib::u32 mask = (1 << shift) - 1;
+    cr0_update(instr & 1, result);
+    xer.ca = (rs < 0) & ((ircolib::u32(rs) & mask) != 0);
+    gpr[utils::RA(instr)] = result;
+}
 } // namespace weee::core

core/broadway/mmio/ai.cpp

@@ -0,0 +1,31 @@
+#include <broadway/mmio/ai.hpp>
+#include <mem.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+audio_interface::audio_interface(mem &mem) {
+    mem.register_read32_handler(0x0c006c00, 0x0c006c1f, [&](ircolib::u32 addr) { return read32(addr); });
+    mem.register_write32_handler(0x0c006c00, 0x0c006c1f,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
+}
+
+ircolib::u32 audio_interface::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0:
+        return ctrl.raw;
+    default:
+        ircolib::panic("audio_interface::read32 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+
+void audio_interface::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0:
+        ctrl.raw = value;
+        break;
+    default:
+        ircolib::panic("audio_interface::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/ai.hpp

@@ -0,0 +1,26 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+struct audio_interface {
+    audio_interface(mem &);
+
+    ircolib::u32 read32(ircolib::u32);
+    void write32(ircolib::u32, ircolib::u32);
+
+    union {
+        struct {
+            unsigned pstat : 1;
+            unsigned afr : 1;
+            unsigned aiintmsk : 1;
+            unsigned aiint : 1;
+            unsigned aiintvld : 1;
+            unsigned screset : 1;
+            unsigned dsp_sr : 1;
+            unsigned : 25;
+        };
+        ircolib::u32 raw;
+    } ctrl;
+};
+} // namespace weee::core

core/broadway/mmio/dsp.cpp

@@ -0,0 +1,152 @@
+#include <broadway/mmio/dsp.hpp>
+#include <mem.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+dsp::dsp(mem &mem) {
+    mem.register_read16_handler(0x0c005000, 0x0c0051ff, [&](ircolib::u32 addr) { return read16(addr); });
+    mem.register_write16_handler(0x0c005000, 0x0c0051ff,
+                                 [&](ircolib::u32 addr, ircolib::u16 value) { return write16(addr, value); });
+
+    mem.register_read32_handler(0x0c005000, 0x0c0051ff, [&](ircolib::u32 addr) { return read32(addr); });
+    mem.register_write32_handler(0x0c005000, 0x0c0051ff,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
+}
+
+ircolib::u32 dsp::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x20:
+        return ar_dma_mmaddr.whole;
+    case 0x24:
+        return ar_dma_araddr.whole;
+    case 0x28:
+        return ar_dma_cnt.whole;
+    case 0x30:
+        return dma_start_addr.whole;
+    default:
+        ircolib::panic("dsp::read32 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+
+void dsp::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0x20:
+        ar_dma_mmaddr.whole = value;
+        break;
+    case 0x24:
+        ar_dma_araddr.whole = value;
+        break;
+    case 0x28:
+        ar_dma_cnt.whole = value;
+        break;
+    case 0x30:
+        dma_start_addr.whole = value;
+        break;
+    default:
+        ircolib::panic("dsp::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
+    }
+}
+
+ircolib::u16 dsp::read16(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x00:
+        return dsp_mail_hi;
+    case 0x02:
+        return dsp_mail_lo;
+    case 0x04:
+        return cpu_mail_hi;
+    case 0x06:
+        return cpu_mail_lo;
+    case 0x0a:
+        return csr.raw;
+    case 0x12:
+        return ar_size;
+    case 0x20:
+        return ar_dma_mmaddr.hi;
+    case 0x22:
+        return ar_dma_mmaddr.lo;
+    case 0x24:
+        return ar_dma_araddr.hi;
+    case 0x26:
+        return ar_dma_araddr.lo;
+    case 0x28:
+        return ar_dma_cnt.hi;
+    case 0x2a:
+        return ar_dma_cnt.lo;
+    case 0x30:
+        return dma_start_addr.hi;
+    case 0x32:
+        return dma_start_addr.lo;
+    default:
+        ircolib::panic("dsp::read16 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+
+void dsp::write16(ircolib::u32 addr, ircolib::u16 value) {
+    switch (addr) {
+    case 0x00:
+        dsp_mail_hi = value;
+        break;
+    case 0x02:
+        dsp_mail_lo = value;
+        break;
+    case 0x0a:
+        {
+            Csr ccsr = {.raw = value};
+            Csr ocsr = csr;
+            csr = ccsr;
+            if (csr.res || (ocsr.boot_mode != ccsr.boot_mode && ccsr.boot_mode)) {
+                cpu_mail_hi = 0;
+                cpu_mail_lo = 0;
+                dsp_mail_hi = 0;
+                dsp_mail_lo = 0;
+            }
+
+            if (csr.piint)
+                csr.piint = false;
+
+            if (csr.aidint)
+                csr.aidint = false;
+
+            if (csr.arint)
+                csr.arint = false;
+
+            if (csr.dspint)
+                csr.dspint = false;
+        }
+        break;
+    case 0x12:
+        ar_size = value;
+        break;
+    case 0x20:
+        ar_dma_mmaddr.hi = value;
+        break;
+    case 0x22:
+        ar_dma_mmaddr.lo = value;
+        break;
+    case 0x24:
+        ar_dma_araddr.hi = value;
+        break;
+    case 0x26:
+        ar_dma_araddr.lo = value;
+        break;
+    case 0x28:
+        ar_dma_cnt.hi = value;
+        break;
+    case 0x2a:
+        ar_dma_cnt.lo = value;
+        csr.arint = true;
+        break;
+    case 0x30:
+        dma_start_addr.hi = value;
+        break;
+    case 0x32:
+        dma_start_addr.lo = value;
+        break;
+    default:
+        ircolib::panic("dsp::write16 from unimplemented addr 0x{:08X} with value 0x{:04X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/dsp.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+struct dsp {
+    dsp(mem &);
+    ircolib::u16 read16(ircolib::u32);
+    void write16(ircolib::u32, ircolib::u16);
+    ircolib::u32 read32(ircolib::u32);
+    void write32(ircolib::u32, ircolib::u32);
+
+    union Csr {
+        struct {
+            unsigned res : 1;
+            unsigned piint : 1;
+            unsigned halt : 1;
+            unsigned aidint : 1;
+            unsigned aidint_mask : 1;
+            unsigned arint : 1;
+            unsigned arint_mask : 1;
+            unsigned dspint : 1;
+            unsigned dspint_mask : 1;
+            unsigned int_status : 1;
+            unsigned : 1;
+            unsigned boot_mode : 1;
+            unsigned : 4;
+        };
+        ircolib::u16 raw;
+    } csr;
+
+    union {
+        struct {
+            ircolib::u32 lo;
+            ircolib::u32 hi;
+        };
+        ircolib::u64 whole;
+    } ar_dma_mmaddr, ar_dma_araddr, ar_dma_cnt, dma_start_addr;
+
+    ircolib::u16 ar_size;
+    ircolib::u16 dsp_mail_hi = 0, dsp_mail_lo = 0, cpu_mail_hi = 0, cpu_mail_lo = 0;
+};
+} // namespace weee::core

core/broadway/mmio/exi.cpp

@@ -0,0 +1,41 @@
+#include <broadway/mmio/exi.hpp>
+#include <mem.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+exi::exi(mem &mem) {
+    mem.register_read32_handler(0x0c006800, 0x0c00683f, [&](ircolib::u32 addr) { return read32(addr); });
+    mem.register_write32_handler(0x0c006800, 0x0c00683f,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
+}
+
+ircolib::u32 exi::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0:
+        return param0.raw;
+    case 0x14:
+        return param1.raw;
+    case 0x28:
+        return param2.raw;
+    default:
+        ircolib::panic("exi::read32 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+
+void exi::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0:
+        param0.raw = value;
+        break;
+    case 0x14:
+        param1.raw = value;
+        break;
+    case 0x28:
+        param2.raw = value;
+        break;
+    default:
+        ircolib::panic("exi::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/exi.hpp

@@ -0,0 +1,30 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+struct exi {
+    exi(mem &);
+
+    ircolib::u32 read32(ircolib::u32);
+    void write32(ircolib::u32, ircolib::u32);
+
+    union {
+        struct {
+            unsigned ext_int_mask : 1;
+            unsigned ext_int : 1;
+            unsigned tc_int_mask : 1;
+            unsigned tc_int : 1;
+            unsigned clk : 3;
+            unsigned cs : 3;
+            unsigned ext_int_mask2 : 1;
+            unsigned ext_int2 : 1;
+            unsigned ext : 1;
+            unsigned romdis : 1;
+            unsigned : 18;
+        };
+
+        ircolib::u32 raw;
+    } param0, param1, param2;
+};
+} // namespace weee::core

core/broadway/mmio/mi.cpp

@@ -0,0 +1,20 @@
+#include <mem.hpp>
+#include <broadway/mmio/mi.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+memory_interface::memory_interface(mem &mem) {
+    mem.register_write16_handler(0x0c004000, 0x0c00407f,
+                                 [&](ircolib::u32 addr, ircolib::u16 value) { write16(addr, value); });
+}
+
+void memory_interface::write16(ircolib::u32 addr, ircolib::u16 value) {
+    switch (addr) {
+    case 0x1C:
+        int_mask.raw = value;
+        break;
+    default:
+        ircolib::panic("memory_interface::write16 to unimplemented addr 0x{:08X} with value 0x{:04X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/mi.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+
+struct memory_interface {
+    union {
+        struct {
+            unsigned mem0 : 1;
+            unsigned mem1 : 1;
+            unsigned mem2 : 1;
+            unsigned mem3 : 1;
+            unsigned all : 1;
+            unsigned : 27;
+        };
+        ircolib::u32 raw;
+    } int_mask;
+
+    memory_interface(mem &);
+    void write16(ircolib::u32, ircolib::u16);
+};
+} // namespace weee::core

core/broadway/mmio/pi.cpp

@@ -0,0 +1,31 @@
+#include <mem.hpp>
+#include <broadway/mmio/pi.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+processor_interface::processor_interface(mem &mem) {
+    mem.register_write32_handler(0x0c003000, 0x0c0030ff,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
+    mem.register_read32_handler(0x0c003000, 0x0c0030ff, [&](ircolib::u32 addr) { return read32(addr); });
+}
+
+void processor_interface::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0x04:
+        intmr.raw = value;
+        break;
+    default:
+        ircolib::panic("processor_interface::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
+    }
+}
+
+ircolib::u32 processor_interface::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x2c:
+        return 2;
+    default:
+        ircolib::panic("processor_interface::read32 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+} // namespace weee::core

core/broadway/mmio/pi.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+
+struct processor_interface {
+    union {
+        struct {
+            unsigned error : 1;
+            unsigned rsw : 1;
+            unsigned di : 1;
+            unsigned si : 1;
+            unsigned exi : 1;
+            unsigned ai : 1;
+            unsigned dsp : 1;
+            unsigned mem : 1;
+            unsigned vi : 1;
+            unsigned pe_token : 1;
+            unsigned pe_finish : 1;
+            unsigned cp : 1;
+            unsigned debug : 1;
+            unsigned hsp : 1;
+            unsigned : 18;
+        };
+        ircolib::u32 raw;
+    } intmr;
+
+    processor_interface(mem &);
+    void write32(ircolib::u32, ircolib::u32);
+    ircolib::u32 read32(ircolib::u32);
+};
+} // namespace weee::core

core/broadway/mmio/si.cpp

@@ -0,0 +1,46 @@
+#include <broadway/mmio/si.hpp>
+#include <mem.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+serial_interface::serial_interface(mem &mem) {
+    mem.register_read32_handler(0x0c006400, 0x0c0064ff, [&](ircolib::u32 addr) { return read32(addr); });
+    mem.register_write32_handler(0x0c006400, 0x0c0064ff,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
+}
+
+ircolib::u32 serial_interface::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x30:
+        return sipoll.raw;
+    case 0x34:
+        return sicomcsr.raw;
+    case 0x38:
+        return sisr.raw;
+    case 0x3C:
+        return clock_lk.raw;
+    default:
+        ircolib::panic("serial_interface::read32 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+
+void serial_interface::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0x30:
+        sipoll.raw = value;
+        break;
+    case 0x34:
+        sicomcsr.raw = value;
+        break;
+    case 0x38:
+        sisr.raw = value;
+        break;
+    case 0x3C:
+        clock_lk.raw = value;
+        break;
+    default:
+        ircolib::panic("serial_interface::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/si.hpp

@@ -0,0 +1,75 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+struct serial_interface {
+    serial_interface(mem &);
+
+    ircolib::u32 read32(ircolib::u32);
+    void write32(ircolib::u32, ircolib::u32);
+
+    union {
+        struct {
+            unsigned vbcpy : 4;
+            unsigned en : 4;
+            unsigned y : 8;
+            unsigned x : 8;
+            unsigned : 8;
+        };
+
+        ircolib::u32 raw;
+    } sipoll;
+
+    union {
+        struct {
+            unsigned tstart : 1;
+            unsigned channel : 2;
+            unsigned cben : 1;
+            unsigned cmden : 1;
+            unsigned inlength : 7;
+            unsigned : 1;
+            unsigned outlength : 7;
+            unsigned : 1;
+            unsigned chen : 1;
+            unsigned chnum : 2;
+            unsigned rdstintmsk : 1;
+            unsigned rdstint : 1;
+            unsigned comerr : 1;
+            unsigned tcintmsk : 1;
+            unsigned tcint : 1;
+        };
+        ircolib::u32 raw;
+    } sicomcsr;
+
+    union {
+        struct {
+            unsigned : 31;
+            unsigned lock : 1;
+        };
+
+        ircolib::u32 raw;
+    } clock_lk;
+
+    union {
+        struct {
+            unsigned joy3 : 6;
+            unsigned : 2;
+            unsigned joy2 : 6;
+            unsigned : 2;
+            unsigned joy1 : 6;
+            unsigned : 2;
+            unsigned unrun : 1;
+            unsigned ovrun0 : 1;
+            unsigned coll0 : 1;
+            unsigned norep0 : 1;
+            unsigned wrst0 : 1;
+            unsigned rdst0 : 1;
+            unsigned : 1;
+            unsigned wr : 1;
+        };
+
+        ircolib::u32 raw;
+    } sisr;
+};
+} // namespace weee::core

core/broadway/mmio/vi.cpp

@@ -4,12 +4,67 @@
 
 namespace weee::core {
 video_interface::video_interface(mem &mem) {
+    mem.register_read16_handler(0x0c002000, 0x0c0020ff, [&](ircolib::u32 addr) { return read16(addr); });
+    mem.register_read32_handler(0x0c002000, 0x0c0020ff, [&](ircolib::u32 addr) { return read32(addr); });
     mem.register_write16_handler(0x0c002000, 0x0c0020ff,
                                  [&](ircolib::u32 addr, ircolib::u16 value) { write16(addr, value); });
     mem.register_write32_handler(0x0c002000, 0x0c0020ff,
                                  [&](ircolib::u32 addr, ircolib::u32 value) { write32(addr, value); });
 }
 
+ircolib::u16 video_interface::read16(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x00:
+        return vtr.raw;
+    case 0x02:
+        return dcr.raw;
+    case 0x4a:
+        return hsr.raw;
+    case 0x6c:
+        return viclk & 1;
+    case 0x70:
+        return 0x0280;
+    default:
+        ircolib::panic("video_interface::read16 from unimplemented addr 0x{:04X}", addr);
+        return 0;
+    }
+}
+
+ircolib::u32 video_interface::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x02:
+        return dcr.raw;
+    case 0x04:
+        return htr0.raw;
+    case 0x08:
+        return htr1.raw;
+    case 0x0c:
+        return vto.raw;
+    case 0x10:
+        return vte.raw;
+    case 0x14:
+        return bbei.raw;
+    case 0x18:
+        return bboi.raw;
+    case 0x1c:
+        return tfbl.raw & 0x1ffffe00;
+    case 0x24:
+        return bfbl.raw & 0x10fffe00;
+    case 0x4c:
+    case 0x50:
+    case 0x54:
+        return fct0[addr - 0x4c].raw;
+    case 0x58:
+    case 0x5c:
+    case 0x60:
+    case 0x64:
+        return fct1[addr - 0x58].raw;
+    default:
+        ircolib::panic("video_interface::read32 from unimplemented addr 0x{:04X}", addr);
+        return 0;
+    }
+}
+
 void video_interface::write16(ircolib::u32 addr, ircolib::u16 value) {
     switch (addr) {
     case 0x00:

core/broadway/mmio/vi.hpp

@@ -8,6 +8,9 @@ struct video_interface {
     video_interface(mem &);
     void write16(ircolib::u32, ircolib::u16);
     void write32(ircolib::u32, ircolib::u32);
+    ircolib::u16 read16(ircolib::u32);
+    ircolib::u32 read32(ircolib::u32);
+
     ircolib::u32 xfb_top_addr() {
         auto addr = tfbl.fbb;
         if (tfbl.page) {
@@ -96,7 +99,7 @@ struct video_interface {
             unsigned fbb : 24;
         };
         ircolib::u32 raw;
-    } tfbl, bfbl;
+    } tfbl{}, bfbl{};
 
     union FCT012 {
         struct {

core/loaders/dol.cpp

@@ -20,7 +20,7 @@ bool load_dol(const std::string &path, mem &mem, broadway &broadway) {
         ircolib::u32 bss_address, bss_size, entry_point;
     } hdr;
 
-    for (size_t bin_index = 0; bin_index < 0xD8; bin_index += 4) {
+    for (ircolib::u32 bin_index = 0; bin_index < 0xD8; bin_index += 4) {
         if (ircolib::is_inside_range(bin_index, 0, 0x1b)) // text file offsets
             hdr.text[bin_index / 4].offset = std::byteswap(ircolib::read_access<ircolib::u32>(bin, bin_index));
 

core/loaders/elf.cpp

@@ -10,7 +10,7 @@ bool load_elf(const std::string &path, mem &mem, broadway &broadway) {
     if (!reader.load(path))
         return false;
 
-    size_t sanity_bss_check_count = 0;
+    ircolib::u32 sanity_bss_check_count = 0;
 
     for (const auto &segment : reader.segments) {
         const auto segment_type = segment->get_type();

core/mem.cpp

@@ -1,12 +1,14 @@
 #include <cstring>
 #include <mem.hpp>
 #include <ircolib/log.hpp>
-#include "ircolib/mem_access.hpp"
+#include <ircolib/mem_access.hpp>
 
 namespace weee::core {
-mem::mem() : vi(*this) {
+mem::mem() : vi(*this), pi(*this), mi(*this), dsp(*this), ai(*this), exi(*this), si(*this) {
     mem1.resize(24_mib);
     std::fill(mem1.begin(), mem1.end(), 0);
+    ipl.resize(1_mib);
+    std::fill(ipl.begin(), ipl.end(), 0);
 
     register_read8_handler(0x00000000, 0x017fffff, [&](ircolib::u32 addr) { return mem1[addr]; });
 
@@ -29,9 +31,34 @@ mem::mem() : vi(*this) {
         ircolib::write_access<ircolib::u32>(mem1, addr, value);
     });
 
-    register_write64_handler(0x00000000, 0x017fffff, [&](ircolib::u32 addr, ircolib::u32 value) {
+    register_write64_handler(0x00000000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u32 value) {
         ircolib::write_access<ircolib::u64>(mem1, addr, value);
     });
+
+    register_read8_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr) { return ipl[addr]; });
+
+    register_read16_handler(0x0ff00000, 0x0fffffff,
+                            [&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u16>(ipl, addr); });
+
+    register_read32_handler(0x0ff00000, 0x0fffffff,
+                            [&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u32>(ipl, addr); });
+
+    register_read64_handler(0x0ff00000, 0x0fffffff,
+                            [&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u64>(ipl, addr); });
+
+    register_write8_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u8 value) { ipl[addr] = value; });
+
+    register_write16_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u16 value) {
+        ircolib::write_access<ircolib::u16>(ipl, addr, value);
+    });
+
+    register_write32_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u32 value) {
+        ircolib::write_access<ircolib::u32>(ipl, addr, value);
+    });
+
+    register_write64_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u32 value) {
+        ircolib::write_access<ircolib::u64>(ipl, addr, value);
+    });
 }
 
 void mem::copy(std::vector<ircolib::u8> &src, const ircolib::u32 offset) {

core/mem.hpp

@@ -3,6 +3,12 @@
 #include <vector>
 #include <ircolib/types.hpp>
 #include <broadway/mmio/vi.hpp>
+#include <broadway/mmio/pi.hpp>
+#include <broadway/mmio/mi.hpp>
+#include <broadway/mmio/dsp.hpp>
+#include <broadway/mmio/ai.hpp>
+#include <broadway/mmio/exi.hpp>
+#include <broadway/mmio/si.hpp>
 #include <functional>
 #include <expected>
 
@@ -69,6 +75,7 @@ struct mem {
     void set(const ircolib::u8 val, const ircolib::u32 size, const ircolib::u32 offset);
 
     std::vector<ircolib::u8> mem1;
+    std::vector<ircolib::u8> ipl{};
 
     private:
     std::vector<read_handler<ircolib::u8>> read8_handlers{};
@@ -82,5 +89,11 @@ struct mem {
 
     public:
     video_interface vi;
+    processor_interface pi;
+    memory_interface mi;
+    dsp dsp;
+    exi exi;
+    audio_interface ai;
+    serial_interface si;
 };
 } // namespace weee::core

external/ircolib/.clang-format

@@ -0,0 +1,56 @@
+---
+Language: Cpp
+BasedOnStyle: LLVM
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignOperands: false
+AlignTrailingComments: false
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: false
+  AfterNamespace: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeCatch: true
+  BeforeElse: false
+  BeforeLambdaBody: false
+  BeforeWhile: true
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+BreakConstructorInitializers: AfterColon
+BreakConstructorInitializersBeforeComma: false
+ColumnLimit: 120
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+IndentAccessModifiers: false
+AccessModifierOffset: 0
+ContinuationIndentWidth: 0
+IncludeCategories:
+  - Regex: '^<.*'
+    Priority: 1
+  - Regex: '^".*'
+    Priority: 2
+  - Regex: '.*'
+    Priority: 3
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IndentCaseBlocks: true
+InsertNewlineAtEOF: true
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+SortIncludes: Never
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: Inner
+SpaceInEmptyParentheses: false
+SpacesInAngles: false
+SpacesInConditionalStatement: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+TabWidth: 4
+IndentWidth: 4
+...

external/ircolib/file.hpp

@@ -1,12 +1,11 @@
 #pragma once
-#include <ircolib/types.hpp>
+#include "types.hpp"
 #include <fstream>
 #include <vector>
 #include <filesystem>
 
-namespace fs = std::filesystem;
-
 namespace ircolib {
+namespace fs = std::filesystem;
 static inline std::vector<u8> read_file_binary(const std::string &path) {
     std::ifstream file(path, std::ios::binary);
     return {std::istreambuf_iterator{file}, {}};
@@ -17,19 +16,19 @@ static inline void write_file_binary(const std::vector<u8> &data, const std::str
     std::copy(data.begin(), data.end(), std::ostreambuf_iterator{file});
 }
 
-static inline void write_file_binary(const u8 *data, const size_t size, const std::string &path) {
+static inline void write_file_binary(const u8 *data, const u32 size, const std::string &path) {
     FILE *out = fopen(path.c_str(), "wb");
     fwrite(data, size, 1, out);
     fclose(out);
 }
 
-template <size_t Size>
+template <u32 Size>
 static inline void write_file_binary(const std::array<u8, Size> &data, const std::string &path) {
     std::ofstream file(path, std::ios::binary);
     std::copy(data.begin(), data.end(), std::ostreambuf_iterator{file});
 }
 
-static inline size_t next_pow2(size_t num) {
+static inline u32 next_pow2(u32 num) {
     // Taken from "Bit Twiddling Hacks" by Sean Anderson:
     // https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
     --num;

external/ircolib/floats.hpp

@@ -1,9 +1,9 @@
 #pragma once
 #include <cmath>
-#include <ircolib/types.hpp>
+#include "types.hpp"
 
 namespace ircolib {
-static inline auto round_ceil(float f) {
+static inline auto roundCeil(float f) {
 #ifdef SIMD_SUPPORT
     __m128 t = _mm_set_ss(f);
     t = _mm_round_ss(t, t, _MM_FROUND_TO_POS_INF);
@@ -13,7 +13,7 @@ static inline auto round_ceil(float f) {
 #endif
 }
 
-static inline auto round_ceil(double f) {
+static inline auto roundCeil(double f) {
 #ifdef SIMD_SUPPORT
     __m128d t = _mm_set_sd(f);
     t = _mm_round_sd(t, t, _MM_FROUND_TO_POS_INF);
@@ -23,7 +23,7 @@ static inline auto round_ceil(double f) {
 #endif
 }
 
-static inline auto round_nearest(float f) {
+static inline auto roundNearest(float f) {
 #ifdef SIMD_SUPPORT
     __m128 t = _mm_set_ss(f);
     t = _mm_round_ss(t, t, _MM_FROUND_TO_NEAREST_INT);
@@ -33,7 +33,7 @@ static inline auto round_nearest(float f) {
 #endif
 }
 
-static inline auto round_nearest(double f) {
+static inline auto roundNearest(double f) {
 #ifdef SIMD_SUPPORT
     __m128d t = _mm_set_sd(f);
     t = _mm_round_sd(t, t, _MM_FROUND_TO_NEAREST_INT);
@@ -43,7 +43,7 @@ static inline auto round_nearest(double f) {
 #endif
 }
 
-static inline auto round_current(float f) {
+static inline auto roundCurrent(float f) {
 #ifdef SIMD_SUPPORT
     auto t = _mm_set_ss(f);
     t = _mm_round_ss(t, t, _MM_FROUND_CUR_DIRECTION);
@@ -53,7 +53,7 @@ static inline auto round_current(float f) {
 #endif
 }
 
-static inline auto round_current(double f) {
+static inline auto roundCurrent(double f) {
 #ifdef SIMD_SUPPORT
     auto t = _mm_set_sd(f);
     t = _mm_round_sd(t, t, _MM_FROUND_CUR_DIRECTION);
@@ -64,7 +64,7 @@ static inline auto round_current(double f) {
 }
 
 
-static inline auto round_floor(float f) {
+static inline auto roundFloor(float f) {
 #ifdef SIMD_SUPPORT
     __m128 t = _mm_set_ss(f);
     t = _mm_round_ss(t, t, _MM_FROUND_TO_NEG_INF);
@@ -74,7 +74,7 @@ static inline auto round_floor(float f) {
 #endif
 }
 
-static inline auto round_floor(double f) {
+static inline auto roundFloor(double f) {
 #ifdef SIMD_SUPPORT
     __m128d t = _mm_set_sd(f);
     t = _mm_round_sd(t, t, _MM_FROUND_TO_NEG_INF);
@@ -84,7 +84,7 @@ static inline auto round_floor(double f) {
 #endif
 }
 
-static inline auto round_trunc(float f) {
+static inline auto roundTrunc(float f) {
 #ifdef SIMD_SUPPORT
     __m128 t = _mm_set_ss(f);
     t = _mm_round_ss(t, t, _MM_FROUND_TO_ZERO);
@@ -94,7 +94,7 @@ static inline auto round_trunc(float f) {
 #endif
 }
 
-static inline auto round_trunc(double f) {
+static inline auto roundTrunc(double f) {
 #ifdef SIMD_SUPPORT
     __m128d t = _mm_set_sd(f);
     t = _mm_round_sd(t, t, _MM_FROUND_TO_ZERO);

external/ircolib/mem_access.hpp

@@ -1,5 +1,6 @@
 #pragma once
-#include <ircolib/types.hpp>
+#include "types.hpp"
+#include <cstddef>
 #include <cstring>
 #include <functional>
 #include <bit>
@@ -34,14 +35,14 @@ template <typename T>
 static constexpr inline T read_access(const u8 *data, const u32 index);
 template <typename T>
 static constexpr inline T read_access(const std::vector<u8> &data, const u32 index);
-template <typename T, size_t Size>
+template <typename T, u32 Size>
 static constexpr inline T read_access(const std::array<u8, Size> &data, const u32 index);
 
 template <typename T>
 static constexpr inline void write_access(u8 *data, const u32 index, const T val);
 template <typename T>
 static constexpr inline void write_access(std::vector<u8> &data, const u32 index, const T val);
-template <typename T, size_t Size>
+template <typename T, u32 Size>
 static constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const T val);
 
 template <>
@@ -69,19 +70,19 @@ static constexpr inline T read_access(const std::vector<u8> &data, const u32 ind
     return *reinterpret_cast<const T *>(&data[index]);
 }
 
-template <size_t Size>
+template <u32 Size>
 constexpr inline u64 read_access(const std::array<u8, Size> &data, const u32 index) {
     u32 hi = *reinterpret_cast<const u32 *>(&data[index + 0]);
     u32 lo = *reinterpret_cast<const u32 *>(&data[index + 4]);
     return static_cast<u64>(hi) << 32 | static_cast<u64>(lo);
 }
 
-template <typename T, size_t Size>
+template <typename T, u32 Size>
 static constexpr inline T read_access(const std::array<u8, Size> &data, const u32 index) {
     return *reinterpret_cast<const T *>(&data[index]);
 }
 
-template <size_t Size>
+template <u32 Size>
 constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const u64 val) {
     const u32 hi = val >> 32;
     const u32 lo = val;
@@ -90,7 +91,7 @@ constexpr inline void write_access(std::array<u8, Size> &data, const u32 index,
     *reinterpret_cast<u32 *>(&data[index + 4]) = lo;
 }
 
-template <typename T, size_t Size>
+template <typename T, u32 Size>
 static constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const T val) {
     *reinterpret_cast<T *>(&data[index]) = val;
 }
@@ -125,34 +126,34 @@ static constexpr inline void write_access(u8 *data, const u32 index, const T val
 
 template <typename T>
 static constexpr inline void swap_buffer(std::vector<u8> &data) {
-    for (size_t i = 0; i < data.size(); i += sizeof(T)) {
+    for (u32 i = 0; i < data.size(); i += sizeof(T)) {
         const T original = *reinterpret_cast<T *>(&data[i]);
         *reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
     }
 }
 
-template <typename T, size_t Size>
+template <typename T, u32 Size>
 static constexpr inline void swap_buffer(std::array<u8, Size> &data) {
-    for (size_t i = 0; i < data.size(); i += sizeof(T)) {
+    for (u32 i = 0; i < data.size(); i += sizeof(T)) {
         const T original = *reinterpret_cast<T *>(&data[i]);
         *reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
     }
 }
 
 template <typename T>
-static constexpr inline void swap_buffer(u8 *data, size_t size) {
-    for (size_t i = 0; i < size; i += sizeof(T)) {
+static constexpr inline void swap_buffer(u8 *data, u32 size) {
+    for (u32 i = 0; i < size; i += sizeof(T)) {
         const T original = *reinterpret_cast<T *>(&data[i]);
         *reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
     }
 }
 
 #ifdef _WIN32
-inline void *aligned_alloc(const size_t alignment, const size_t size) { return _aligned_malloc(size, alignment); }
+inline void *aligned_alloc(const u32 alignment, const u32 size) { return _aligned_malloc(size, alignment); }
 
 inline void aligned_free(void *ptr) { _aligned_free(ptr); }
 #else
-inline void *aligned_alloc(const size_t alignment, const size_t size) { return std::aligned_alloc(alignment, size); }
+inline void *aligned_alloc(const u32 alignment, const u32 size) { return std::aligned_alloc(alignment, size); }
 
 inline void aligned_free(void *ptr) { std::free(ptr); }
 #endif

external/ircolib/types.hpp

@@ -11,25 +11,30 @@ using s16 = int16_t;
 using s32 = int32_t;
 using s64 = int64_t;
 
-template <typename T, std::size_t bit>
+template <typename T, u32 bit>
 static constexpr bool is_bit_set(const T &val) {
     return val & (1 << bit);
 }
 
-template <typename T, std::size_t bit>
+template <typename T, u32 bit>
 static constexpr void set_bit(T &val) {
     val |= 1 << bit;
 }
 
 template <typename T>
-inline bool is_bit_set(const T &val, const std::size_t &bit) {
+inline bool is_bit_set(const T &val, const u32 &bit) {
     return val & (1 << bit);
 }
 
 template <typename T>
-inline void set_bit(T &val, const std::size_t &bit) {
+inline void set_bit(T &val, const u32 &bit) {
     val |= 1 << bit;
 }
+
+template <typename T>
+inline void clear_bit(T &val, const u32 &bit) {
+    val &= ~(1 << bit);
+}
 } // namespace ircolib
 
 constexpr ircolib::u32 operator""_kib(const unsigned long long v) { return v * 1024; }

main.cpp

@@ -1,14 +1,12 @@
 #include <cflags.hpp>
 #include <ircolib/mem_access.hpp>
+#include <ircolib/file.hpp>
 #include <loaders/elf.hpp>
 #include <loaders/dol.hpp>
 #include <ircolib/log.hpp>
 #include <mem.hpp>
 #include <broadway.hpp>
 #include <SDL3/SDL.h>
-#include <filesystem>
-
-namespace fs = std::filesystem;
 
 int main(int argc, char **argv) {
     weee::core::mem mem;
@@ -20,7 +18,7 @@ int main(int argc, char **argv) {
     flags.add_string_callback(
     '\0', "elf",
     [&](const std::string &v) {
-        binName = fs::path(v).filename().string();
+        binName = ircolib::fs::path(v).filename().string();
         if (!weee::core::load_elf(v, mem, broadway))
             ircolib::panic("Could not load '{}'", v);
     },
@@ -29,7 +27,7 @@ int main(int argc, char **argv) {
     flags.add_string_callback(
     '\0', "dol",
     [&](const std::string &v) {
-        binName = fs::path(v).filename().string();
+        binName = ircolib::fs::path(v).filename().string();
         if (!weee::core::load_dol(v, mem, broadway))
             ircolib::panic("Could not load '{}'", v);
     },
@@ -69,7 +67,7 @@ int main(int argc, char **argv) {
                 open = false;
         }
 
-        SDL_ConvertPixels(640, 240, SDL_PIXELFORMAT_UYVY, &mem.mem1[vi.xfb_top_addr()], 640 * 4, SDL_PIXELFORMAT_BGR24,
+        SDL_ConvertPixels(640, 240, SDL_PIXELFORMAT_UYVY, &mem.mem1[0], 640 * 4, SDL_PIXELFORMAT_BGR24,
                           rgbTexture.data(), 640 * 3);
 
         SDL_RenderClear(renderer);