Skip to content

PS2 games in the browser: static recompilation to WebAssembly with a native runtime

C++

iop: an R3000 interpreter with a reimplemented IOP kernel

Samir Nuri10ac4f5fa91f
diff --git a/runtime/src/iop/cpu.cpp b/runtime/src/iop/cpu.cpp
new file mode 100644
index 0000000..a1aa2d5
--- /dev/null
+++ b/runtime/src/iop/cpu.cpp
@@ -0,0 +1,172 @@
+#include "iop.hpp"
+#include "kernel.hpp"
+
+#include <cstdio>
+
+namespace ps2::iop {
+
+alignas(64) std::uint8_t g_ram[kRamSize + 16];
+Cpu g_cpu;
+
+namespace {
+
+inline std::int32_t simm(std::uint32_t w) { return static_cast<std::int16_t>(w & 0xFFFFu); }
+
+void bad(Cpu &c, std::uint32_t pc, std::uint32_t w) {
+ std::fprintf(stderr, "[iop] unknown instruction %08X at 0x%08X (ra 0x%08X)\n", w, pc, c.r[31]);
+ kernel::fault("unknown instruction");
+}
+
+}
+
+std::uint32_t fetch(std::uint32_t pc) {
+ const std::uint32_t p = phys(pc);
+ if (p < 0x00800000u) return ram32(p);
+ return kernel::fetch_special(pc);
+}
+
+void execute(Cpu &c, std::int64_t &budget) {
+ while (budget-- > 0) {
+ const std::uint32_t pc = c.pc;
+ const std::uint32_t w = fetch(pc);
+ c.pc = c.npc;
+ c.npc += 4;
+ const std::uint32_t rs = (w >> 21) & 31u, rt = (w >> 16) & 31u, rd = (w >> 11) & 31u, sa = (w >> 6) & 31u;
+ std::uint32_t *r = c.r;
+ switch (w >> 26) {
+ case 0x00:
+ switch (w & 63u) {
+ case 0x00: r[rd] = r[rt] << sa; break;
+ case 0x02: r[rd] = r[rt] >> sa; break;
+ case 0x03: r[rd] = static_cast<std::uint32_t>(static_cast<std::int32_t>(r[rt]) >> sa); break;
+ case 0x04: r[rd] = r[rt] << (r[rs] & 31u); break;
+ case 0x06: r[rd] = r[rt] >> (r[rs] & 31u); break;
+ case 0x07: r[rd] = static_cast<std::uint32_t>(static_cast<std::int32_t>(r[rt]) >> (r[rs] & 31u)); break;
+ case 0x08: c.npc = r[rs]; break;
+ case 0x09: { const std::uint32_t t = r[rs]; r[rd] = pc + 8; c.npc = t; break; }
+ case 0x0C:
+ kernel::syscall(c, pc);
+ break;
+ case 0x0D:
+ std::fprintf(stderr, "[iop] break at 0x%08X\n", pc);
+ break;
+ case 0x0F: break;
+ case 0x10: r[rd] = c.hi; break;
+ case 0x11: c.hi = r[rs]; break;
+ case 0x12: r[rd] = c.lo; break;
+ case 0x13: c.lo = r[rs]; break;
+ case 0x18: {
+ const std::int64_t p = static_cast<std::int64_t>(static_cast<std::int32_t>(r[rs])) * static_cast<std::int32_t>(r[rt]);
+ c.lo = static_cast<std::uint32_t>(p);
+ c.hi = static_cast<std::uint32_t>(static_cast<std::uint64_t>(p) >> 32);
+ break;
+ }
+ case 0x19: {
+ const std::uint64_t p = static_cast<std::uint64_t>(r[rs]) * r[rt];
+ c.lo = static_cast<std::uint32_t>(p);
+ c.hi = static_cast<std::uint32_t>(p >> 32);
+ break;
+ }
+ case 0x1A: {
+ const auto n = static_cast<std::int32_t>(r[rs]), d = static_cast<std::int32_t>(r[rt]);
+ if (d == 0) { c.lo = n < 0 ? 1u : 0xFFFFFFFFu; c.hi = static_cast<std::uint32_t>(n); }
+ else if (n == INT32_MIN && d == -1) { c.lo = static_cast<std::uint32_t>(INT32_MIN); c.hi = 0; }
+ else { c.lo = static_cast<std::uint32_t>(n / d); c.hi = static_cast<std::uint32_t>(n % d); }
+ break;
+ }
+ case 0x1B:
+ if (r[rt] == 0) { c.lo = 0xFFFFFFFFu; c.hi = r[rs]; }
+ else { c.lo = r[rs] / r[rt]; c.hi = r[rs] % r[rt]; }
+ break;
+ case 0x20: case 0x21: r[rd] = r[rs] + r[rt]; break;
+ case 0x22: case 0x23: r[rd] = r[rs] - r[rt]; break;
+ case 0x24: r[rd] = r[rs] & r[rt]; break;
+ case 0x25: r[rd] = r[rs] | r[rt]; break;
+ case 0x26: r[rd] = r[rs] ^ r[rt]; break;
+ case 0x27: r[rd] = ~(r[rs] | r[rt]); break;
+ case 0x2A: r[rd] = static_cast<std::int32_t>(r[rs]) < static_cast<std::int32_t>(r[rt]); break;
+ case 0x2B: r[rd] = r[rs] < r[rt]; break;
+ default: bad(c, pc, w); return;
+ }
+ break;
+ case 0x01: {
+ const bool link = (rt & 0x1Eu) == 0x10u;
+ const bool taken = (rt & 1u) ? static_cast<std::int32_t>(r[rs]) >= 0 : static_cast<std::int32_t>(r[rs]) < 0;
+ if (link) r[31] = pc + 8;
+ if (taken) c.npc = pc + 4 + (static_cast<std::uint32_t>(simm(w)) << 2);
+ break;
+ }
+ case 0x02: c.npc = (pc & 0xF0000000u) | ((w & 0x03FFFFFFu) << 2); break;
+ case 0x03: r[31] = pc + 8; c.npc = (pc & 0xF0000000u) | ((w & 0x03FFFFFFu) << 2); break;
+ case 0x04: if (r[rs] == r[rt]) c.npc = pc + 4 + (static_cast<std::uint32_t>(simm(w)) << 2); break;
+ case 0x05: if (r[rs] != r[rt]) c.npc = pc + 4 + (static_cast<std::uint32_t>(simm(w)) << 2); break;
+ case 0x06: if (static_cast<std::int32_t>(r[rs]) <= 0) c.npc = pc + 4 + (static_cast<std::uint32_t>(simm(w)) << 2); break;
+ case 0x07: if (static_cast<std::int32_t>(r[rs]) > 0) c.npc = pc + 4 + (static_cast<std::uint32_t>(simm(w)) << 2); break;
+ case 0x08: case 0x09: r[rt] = r[rs] + static_cast<std::uint32_t>(simm(w)); break;
+ case 0x0A: r[rt] = static_cast<std::int32_t>(r[rs]) < simm(w); break;
+ case 0x0B: r[rt] = r[rs] < static_cast<std::uint32_t>(simm(w)); break;
+ case 0x0C: r[rt] = r[rs] & (w & 0xFFFFu); break;
+ case 0x0D: r[rt] = r[rs] | (w & 0xFFFFu); break;
+ case 0x0E: r[rt] = r[rs] ^ (w & 0xFFFFu); break;
+ case 0x0F: r[rt] = w << 16; break;
+ case 0x10:
+ if (rs == 0) r[rt] = rd == 12 ? c.status : rd == 13 ? c.cause : rd == 14 ? c.epc : rd == 15 ? 0x1Fu : 0u;
+ else if (rs == 4) {
+ if (rd == 12) kernel::set_status(c, r[rt]);
+ else if (rd == 13) c.cause = r[rt];
+ else if (rd == 14) c.epc = r[rt];
+ } else if ((w & 63u) == 0x10) {
+ c.status = (c.status & ~0xFu) | ((c.status >> 2) & 0xFu);
+ }
+ break;
+ case 0x20: r[rt] = static_cast<std::uint32_t>(static_cast<std::int8_t>(read8(r[rs] + static_cast<std::uint32_t>(simm(w))))); break;
+ case 0x21: r[rt] = static_cast<std::uint32_t>(static_cast<std::int16_t>(read16(r[rs] + static_cast<std::uint32_t>(simm(w))))); break;
+ case 0x22: {
+ const std::uint32_t a = r[rs] + static_cast<std::uint32_t>(simm(w)), shift = (3u - (a & 3u)) * 8u;
+ const std::uint32_t mem = read32(a & ~3u);
+ r[rt] = (mem << shift) | (shift ? (r[rt] & ((1u << shift) - 1u)) : 0u);
+ break;
+ }
+ case 0x23: r[rt] = read32(r[rs] + static_cast<std::uint32_t>(simm(w))); break;
+ case 0x24: r[rt] = read8(r[rs] + static_cast<std::uint32_t>(simm(w))); break;
+ case 0x25: r[rt] = read16(r[rs] + static_cast<std::uint32_t>(simm(w))); break;
+ case 0x26: {
+ const std::uint32_t a = r[rs] + static_cast<std::uint32_t>(simm(w)), shift = (a & 3u) * 8u;
+ const std::uint32_t mem = read32(a & ~3u);
+ r[rt] = (mem >> shift) | (shift ? (r[rt] & ~(0xFFFFFFFFu >> shift)) : 0u);
+ break;
+ }
+ case 0x28: write8(r[rs] + static_cast<std::uint32_t>(simm(w)), static_cast<std::uint8_t>(r[rt])); break;
+ case 0x29: write16(r[rs] + static_cast<std::uint32_t>(simm(w)), static_cast<std::uint16_t>(r[rt])); break;
+ case 0x2A: {
+ const std::uint32_t a = r[rs] + static_cast<std::uint32_t>(simm(w)), shift = (3u - (a & 3u)) * 8u;
+ const std::uint32_t mem = read32(a & ~3u);
+ write32(a & ~3u, (r[rt] >> shift) | (shift ? (mem & ~(0xFFFFFFFFu >> shift)) : 0u));
+ break;
+ }
+ case 0x2B: write32(r[rs] + static_cast<std::uint32_t>(simm(w)), r[rt]); break;
+ case 0x2E: {
+ const std::uint32_t a = r[rs] + static_cast<std::uint32_t>(simm(w)), shift = (a & 3u) * 8u;
+ const std::uint32_t mem = read32(a & ~3u);
+ write32(a & ~3u, (r[rt] << shift) | (shift ? (mem & ((1u << shift) - 1u)) : 0u));
+ break;
+ }
+ case 0x2F: break;
+ case kHleOpcode:
+ c.pc = r[31];
+ c.npc = c.pc + 4;
+ r[0] = 0;
+ call_hle(c, w & 0x03FFFFFFu);
+ r[0] = 0;
+ if (kernel::switch_pending()) return;
+ continue;
+ default:
+ bad(c, pc, w);
+ return;
+ }
+ r[0] = 0;
+ if (kernel::switch_pending()) return;
+ }
+}
+
+}
diff --git a/runtime/src/iop/hw.cpp b/runtime/src/iop/hw.cpp
new file mode 100644
index 0000000..62db7c9
--- /dev/null
+++ b/runtime/src/iop/hw.cpp
@@ -0,0 +1,233 @@
+#include "hw.hpp"
+
+#include "iop.hpp"
+#include "kernel.hpp"
+#include "spu2.hpp"
+
+#include <cstdio>
+#include <map>
+#include <set>
+
+namespace ps2::iop {
+
+namespace {
+
+alignas(16) std::uint8_t g_scratchpad[1024];
+
+bool is_ram(std::uint32_t p) { return p < 0x00800000u; }
+bool is_scratchpad(std::uint32_t p) { return (p & ~0x3FFu) == 0x1F800000u; }
+
+}
+
+std::uint8_t read8(std::uint32_t a) {
+ const std::uint32_t p = phys(a);
+ if (is_ram(p)) return g_ram[p & (kRamSize - 1)];
+ if (is_scratchpad(p)) return g_scratchpad[p & 0x3FFu];
+ return static_cast<std::uint8_t>(hw::read(p, 1));
+}
+
+std::uint16_t read16(std::uint32_t a) {
+ const std::uint32_t p = phys(a);
+ std::uint16_t v;
+ if (is_ram(p)) { std::memcpy(&v, g_ram + (p & (kRamSize - 1)), 2); return v; }
+ if (is_scratchpad(p)) { std::memcpy(&v, g_scratchpad + (p & 0x3FEu), 2); return v; }
+ return static_cast<std::uint16_t>(hw::read(p, 2));
+}
+
+std::uint32_t read32(std::uint32_t a) {
+ const std::uint32_t p = phys(a);
+ std::uint32_t v;
+ if (is_ram(p)) { std::memcpy(&v, g_ram + (p & (kRamSize - 1)), 4); return v; }
+ if (is_scratchpad(p)) { std::memcpy(&v, g_scratchpad + (p & 0x3FCu), 4); return v; }
+ return hw::read(p, 4);
+}
+
+void write8(std::uint32_t a, std::uint8_t v) {
+ const std::uint32_t p = phys(a);
+ if (is_ram(p)) { g_ram[p & (kRamSize - 1)] = v; return; }
+ if (is_scratchpad(p)) { g_scratchpad[p & 0x3FFu] = v; return; }
+ hw::write(p, v, 1);
+}
+
+void write16(std::uint32_t a, std::uint16_t v) {
+ const std::uint32_t p = phys(a);
+ if (is_ram(p)) { std::memcpy(g_ram + (p & (kRamSize - 1)), &v, 2); return; }
+ if (is_scratchpad(p)) { std::memcpy(g_scratchpad + (p & 0x3FEu), &v, 2); return; }
+ hw::write(p, v, 2);
+}
+
+void write32(std::uint32_t a, std::uint32_t v) {
+ const std::uint32_t p = phys(a);
+ if (is_ram(p)) { std::memcpy(g_ram + (p & (kRamSize - 1)), &v, 4); return; }
+ if (is_scratchpad(p)) { std::memcpy(g_scratchpad + (p & 0x3FCu), &v, 4); return; }
+ hw::write(p, v, 4);
+}
+
+namespace hw {
+
+namespace {
+
+constexpr std::uint32_t kIStat = 0x1F801070u, kIMask = 0x1F801074u, kICtrl = 0x1F801078u;
+constexpr std::uint32_t kDicr = 0x1F8010F4u, kDicr2 = 0x1F801574u;
+
+std::uint32_t g_istat = 0, g_imask = 0, g_ictrl = 1;
+std::uint32_t g_dicr = 0, g_dicr2 = 0;
+std::map<std::uint32_t, std::uint32_t> g_regs;
+std::set<std::uint32_t> g_reported;
+
+struct Dma {
+ std::uint32_t madr, bcr, chcr, tadr;
+};
+Dma g_dma[14];
+
+int dma_channel(std::uint32_t a, std::uint32_t &reg) {
+ if (a >= 0x1F801080u && a < 0x1F8010F0u) {
+ reg = (a & 0xFu) >> 2;
+ return static_cast<int>((a - 0x1F801080u) >> 4);
+ }
+ if (a >= 0x1F801500u && a < 0x1F801570u) {
+ reg = (a & 0xFu) >> 2;
+ return 7 + static_cast<int>((a - 0x1F801500u) >> 4);
+ }
+ return -1;
+}
+
+void report(const char *what, std::uint32_t a, std::uint32_t v) {
+ if (g_reported.insert(a).second)
+ std::fprintf(stderr, "[iop-io] %s 0x%08X = 0x%X (pc 0x%08X)\n", what, a, v, g_cpu.pc);
+}
+
+void start_dma(unsigned ch) {
+ Dma &d = g_dma[ch];
+ const std::uint32_t words = (d.bcr & 0xFFFFu) * ((d.bcr >> 16) ? (d.bcr >> 16) : 1u);
+ if (ch == 4 || ch == 7) {
+ spu2::dma(ch == 4 ? 0 : 1, d.madr, words, (d.chcr & 1u) != 0);
+ kernel::schedule(kernel::now() + 64u + words / 4u, [ch]() { dma_done(ch); });
+ return;
+ }
+ std::fprintf(stderr, "[iop-dma] channel %u start madr 0x%08X bcr 0x%08X chcr 0x%08X (not emulated)\n", ch, d.madr, d.bcr, d.chcr);
+ dma_done(ch);
+}
+
+}
+
+void reset() {
+ g_istat = g_imask = g_dicr = g_dicr2 = 0;
+ g_ictrl = 1;
+ g_regs.clear();
+ std::memset(g_dma, 0, sizeof g_dma);
+ std::memset(g_scratchpad, 0, sizeof g_scratchpad);
+ spu2::reset();
+}
+
+void raise_interrupt(unsigned line) {
+ if (line < 32) g_istat |= 1u << line;
+}
+
+void set_interrupt_mask(unsigned line, bool enabled) {
+ if (line < 32) {
+ if (enabled) g_imask |= 1u << line;
+ else g_imask &= ~(1u << line);
+ } else if (line < 39) {
+ const std::uint32_t bit = 1u << (16 + line - 32);
+ if (enabled) g_dicr |= bit;
+ else g_dicr &= ~bit;
+ } else if (line < 46) {
+ const std::uint32_t bit = 1u << (16 + line - 39);
+ if (enabled) g_dicr2 |= bit;
+ else g_dicr2 &= ~bit;
+ }
+}
+
+int next_pending_interrupt() {
+ if (!g_ictrl) return -1;
+ const std::uint32_t pending = g_istat & g_imask;
+ if (pending & 8u) {
+ const std::uint32_t flags = (g_dicr >> 24) & (g_dicr >> 16) & 0x7Fu;
+ if (flags) return 32 + __builtin_ctz(flags);
+ const std::uint32_t flags2 = (g_dicr2 >> 24) & (g_dicr2 >> 16) & 0x3Fu;
+ if (flags2) return 39 + __builtin_ctz(flags2);
+ g_istat &= ~8u;
+ }
+ const std::uint32_t rest = g_istat & g_imask & ~8u;
+ return rest ? __builtin_ctz(rest) : -1;
+}
+
+void acknowledge_interrupt(unsigned line) {
+ if (line < 32) {
+ g_istat &= ~(1u << line);
+ return;
+ }
+ if (line < 39) g_dicr &= ~(1u << (24 + line - 32));
+ else g_dicr2 &= ~(1u << (24 + line - 39));
+ if (!(((g_dicr >> 24) & 0x7Fu) | ((g_dicr2 >> 24) & 0x3Fu))) g_istat &= ~8u;
+}
+
+void dma_done(unsigned ch) {
+ g_dma[ch].chcr &= ~0x01000000u;
+ if (ch < 7) g_dicr |= 1u << (24 + ch);
+ else g_dicr2 |= 1u << (24 + ch - 7);
+ g_istat |= 8u;
+}
+
+std::uint32_t read(std::uint32_t a, unsigned size) {
+ if (a >= 0x1F900000u && a < 0x1F900800u) return spu2::read(a, size);
+ if (a == kIStat) return g_istat;
+ if (a == kIMask) return g_imask;
+ if (a == kICtrl) {
+ const std::uint32_t v = g_ictrl;
+ g_ictrl = 0;
+ return v;
+ }
+ if (a == kDicr) return g_dicr;
+ if (a == kDicr2) return g_dicr2;
+ std::uint32_t reg = 0;
+ const int ch = dma_channel(a, reg);
+ if (ch >= 0) {
+ const Dma &d = g_dma[ch];
+ return reg == 0 ? d.madr : reg == 1 ? d.bcr : reg == 2 ? d.chcr : d.tadr;
+ }
+ if ((a >= 0x1F801100u && a < 0x1F801130u) || (a >= 0x1F801480u && a < 0x1F8014B0u)) {
+ if ((a & 0xFu) == 0) return static_cast<std::uint32_t>(kernel::now());
+ }
+ const auto it = g_regs.find(a);
+ const std::uint32_t v = it == g_regs.end() ? 0 : it->second;
+ report("read", a, v);
+ return v;
+}
+
+void write(std::uint32_t a, std::uint32_t v, unsigned size) {
+ if (a >= 0x1F900000u && a < 0x1F900800u) { spu2::write(a, v, size); return; }
+ if (a == kIStat) { g_istat &= v; return; }
+ if (a == kIMask) { g_imask = v; return; }
+ if (a == kICtrl) { g_ictrl = v & 1u; return; }
+ if (a == kDicr) {
+ g_dicr = (g_dicr & 0x7F000000u & ~(v & 0x7F000000u)) | (v & 0x00FFFFFFu);
+ return;
+ }
+ if (a == kDicr2) {
+ g_dicr2 = (g_dicr2 & 0x7F000000u & ~(v & 0x7F000000u)) | (v & 0x00FFFFFFu);
+ return;
+ }
+ std::uint32_t reg = 0;
+ const int ch = dma_channel(a, reg);
+ if (ch >= 0) {
+ Dma &d = g_dma[ch];
+ if (reg == 0) d.madr = v;
+ else if (reg == 1) d.bcr = v;
+ else if (reg == 3) d.tadr = v;
+ else {
+ d.chcr = v;
+ if (v & 0x01000000u) start_dma(static_cast<unsigned>(ch));
+ }
+ return;
+ }
+ report("write", a, v);
+ g_regs[a] = v;
+}
+
+std::uint16_t *spu2_ram() { return spu2::ram(); }
+
+}
+
+}
diff --git a/runtime/src/iop/hw.hpp b/runtime/src/iop/hw.hpp
new file mode 100644
index 0000000..7ae0c9e
--- /dev/null
+++ b/runtime/src/iop/hw.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <cstdint>
+
+namespace ps2::iop::hw {
+
+void reset();
+void raise_interrupt(unsigned line);
+void set_interrupt_mask(unsigned line, bool enabled);
+int next_pending_interrupt();
+void acknowledge_interrupt(unsigned line);
+void dma_done(unsigned channel);
+
+std::uint32_t read(std::uint32_t a, unsigned size);
+void write(std::uint32_t a, std::uint32_t v, unsigned size);
+
+std::uint16_t *spu2_ram();
+
+}
diff --git a/runtime/src/iop/iop.hpp b/runtime/src/iop/iop.hpp
new file mode 100644
index 0000000..72f50d4
--- /dev/null
+++ b/runtime/src/iop/iop.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace ps2::iop {
+
+inline constexpr std::uint32_t kRamSize = 2u << 20;
+inline constexpr std::uint32_t kClockDivider = 8;
+inline constexpr std::uint32_t kHleOpcode = 0x3Fu;
+
+extern std::uint8_t g_ram[];
+
+struct Cpu {
+ std::uint32_t r[32];
+ std::uint32_t hi, lo;
+ std::uint32_t pc, npc;
+ std::uint32_t status, cause, epc;
+};
+
+extern Cpu g_cpu;
+
+inline std::uint32_t phys(std::uint32_t a) { return a & 0x1FFFFFFFu; }
+
+inline std::uint8_t *ram_ptr(std::uint32_t a) { return g_ram + (phys(a) & (kRamSize - 1)); }
+
+inline std::uint32_t ram32(std::uint32_t a) {
+ std::uint32_t v;
+ std::memcpy(&v, ram_ptr(a), 4);
+ return v;
+}
+
+inline void set_ram32(std::uint32_t a, std::uint32_t v) { std::memcpy(ram_ptr(a), &v, 4); }
+
+inline std::string ram_string(std::uint32_t a, std::size_t limit = 256) {
+ std::string s;
+ for (std::size_t i = 0; i < limit; ++i) {
+ const char ch = static_cast<char>(*ram_ptr(a + static_cast<std::uint32_t>(i)));
+ if (!ch) break;
+ s += ch;
+ }
+ return s;
+}
+
+std::uint8_t read8(std::uint32_t a);
+std::uint16_t read16(std::uint32_t a);
+std::uint32_t read32(std::uint32_t a);
+void write8(std::uint32_t a, std::uint8_t v);
+void write16(std::uint32_t a, std::uint16_t v);
+void write32(std::uint32_t a, std::uint32_t v);
+
+using HleFunction = std::function<void(Cpu &)>;
+std::uint32_t register_hle(const std::string &library, std::uint32_t index, HleFunction function);
+void call_hle(Cpu &c, std::uint32_t id);
+
+void reset();
+void run(std::uint64_t ee_cycles);
+std::uint64_t cycles();
+void raise_interrupt(unsigned line);
+void vblank(bool start);
+bool idle();
+void dump();
+
+std::int32_t load_module(const std::string &path, const std::string &args, std::function<void(int, int)> done = {});
+std::int32_t load_module_buffer(const std::vector<std::uint8_t> &data, const std::string &path, const std::string &args,
+ std::function<void(int, int)> done = {});
+void set_trace(bool modules, bool hle);
+
+}
diff --git a/runtime/src/iop/kernel.cpp b/runtime/src/iop/kernel.cpp
new file mode 100644
index 0000000..efa2e44
--- /dev/null
+++ b/runtime/src/iop/kernel.cpp
@@ -0,0 +1,659 @@
+#include "kernel.hpp"
+
+#include "hw.hpp"
+
+#include <algorithm>
+#include <cstdio>
+#include <deque>
+#include <map>
+#include <memory>
+#include <queue>
+#include <set>
+
+namespace ps2::iop {
+
+void execute(Cpu &c, std::int64_t &budget);
+
+namespace kernel {
+
+bool g_trace_hle = false;
+bool g_trace_modules = false;
+
+namespace {
+
+constexpr std::uint32_t kKernelBase = 0x00001000u;
+constexpr std::uint32_t kUserBase = 0x00020000u;
+constexpr std::uint32_t kInterruptStack = 0x0001F000u;
+constexpr int kDefaultModulePriority = 8;
+constexpr std::int64_t kSlice = 512;
+
+struct HleEntry {
+ std::string library;
+ std::uint32_t index;
+ HleFunction function;
+};
+
+struct Event {
+ std::uint64_t at;
+ std::uint64_t seq;
+ std::function<void()> action;
+ bool operator>(const Event &o) const { return at != o.at ? at > o.at : seq > o.seq; }
+};
+
+struct Interrupt {
+ std::uint32_t handler{};
+ std::uint32_t arg{};
+ std::uint32_t mode{};
+};
+
+std::vector<HleEntry> g_hle;
+std::map<std::pair<std::string, std::uint32_t>, std::uint32_t> g_hle_ids;
+std::map<std::string, std::uint32_t> g_hle_versions;
+std::map<std::string, std::uint32_t> g_libraries;
+std::map<std::string, HleModuleStart> g_hle_modules;
+std::map<int, Module> g_modules;
+int g_next_module = 1;
+
+std::map<int, Thread> g_threads;
+int g_current = 0;
+int g_next_thread = 1;
+std::uint64_t g_order = 0;
+bool g_switch = false;
+
+std::map<std::uint32_t, std::uint32_t> g_used;
+std::uint32_t g_kernel_top = kKernelBase;
+
+std::priority_queue<Event, std::vector<Event>, std::greater<Event>> g_events;
+std::uint64_t g_event_seq = 0;
+std::uint64_t g_now = 0;
+std::uint64_t g_target = 0;
+std::uint64_t g_ee_remainder = 0;
+
+std::map<unsigned, Interrupt> g_interrupts;
+bool g_suspended = false;
+int g_nesting = 0;
+bool g_nested_done = false;
+std::uint32_t g_return_stub = 0;
+std::uint32_t g_exit_stub = 0;
+std::set<std::pair<std::string, std::uint32_t>> g_missing_reported;
+
+Thread *best_ready() {
+ Thread *best = nullptr;
+ for (auto &[id, t] : g_threads) {
+ if (t.status != kReady && t.status != kRun) continue;
+ if (!best || t.priority < best->priority || (t.priority == best->priority && t.order < best->order)) best = &t;
+ }
+ return best;
+}
+
+void do_switch() {
+ g_switch = false;
+ Thread *cur = current();
+ Thread *next = best_ready();
+ if (next == cur && cur && cur->status == kRun) return;
+ if (cur && cur->status != kDormant) {
+ cur->context = g_cpu;
+ if (cur->status == kRun) cur->status = kReady;
+ }
+ if (next) {
+ next->status = kRun;
+ g_current = next->id;
+ g_cpu = next->context;
+ } else {
+ g_current = 0;
+ }
+}
+
+std::uint32_t hle_id_for(const std::string &library, std::uint32_t index) {
+ auto it = g_hle_ids.find({library, index});
+ if (it != g_hle_ids.end()) return it->second;
+ return register_hle(library, index, [library, index](Cpu &c) {
+ if (g_missing_reported.insert({library, index}).second)
+ std::fprintf(stderr, "[iop] missing %s #%u called from 0x%08X\n", library.c_str(), index, c.r[31]);
+ c.r[2] = 0;
+ });
+}
+
+void link_imports(std::uint32_t base, std::uint32_t size) {
+ for (std::uint32_t a = base; a + 20 <= base + size; a += 4) {
+ if (ram32(a) != 0x41E00000u) continue;
+ char raw[9] = {};
+ std::memcpy(raw, ram_ptr(a + 12), 8);
+ const std::string library(raw);
+ const auto guest = g_libraries.find(library);
+ for (std::uint32_t stub = a + 20; stub + 8 <= base + size; stub += 8) {
+ const std::uint32_t w0 = ram32(stub), w1 = ram32(stub + 4);
+ if (w0 != 0x03E00008u || (w1 & 0xFFFF0000u) != 0x24000000u) break;
+ const std::uint32_t index = w1 & 0xFFFFu;
+ if (guest != g_libraries.end()) {
+ const std::uint32_t target = ram32(guest->second + 20 + index * 4);
+ set_ram32(stub, 0x08000000u | ((target >> 2) & 0x03FFFFFFu));
+ set_ram32(stub + 4, 0);
+ } else {
+ if (!g_hle_versions.count(library) && g_trace_modules)
+ std::fprintf(stderr, "[iop] import from unknown library %s #%u\n", library.c_str(), index);
+ set_ram32(stub, (kHleOpcode << 26) | hle_id_for(library, index));
+ }
+ }
+ }
+}
+
+struct Elf {
+ const std::vector<std::uint8_t> &data;
+ std::uint32_t u32(std::size_t o) const { std::uint32_t v; std::memcpy(&v, data.data() + o, 4); return v; }
+ std::uint16_t u16(std::size_t o) const { std::uint16_t v; std::memcpy(&v, data.data() + o, 2); return v; }
+};
+
+void relocate(const Elf &elf, std::uint32_t base, std::uint32_t size, bool v2) {
+ const std::uint32_t shoff = elf.u32(32);
+ const std::uint16_t shentsize = elf.u16(46), shnum = elf.u16(48);
+ auto word = [&](std::int64_t offset) -> std::uint8_t * {
+ static std::uint32_t dummy;
+ if (offset < 0 || offset + 4 > size) return reinterpret_cast<std::uint8_t *>(&dummy);
+ return ram_ptr(base + static_cast<std::uint32_t>(offset));
+ };
+ auto get = [&](std::int64_t o) { std::uint32_t v; std::memcpy(&v, word(o), 4); return v; };
+ auto put = [&](std::int64_t o, std::uint32_t v) { std::memcpy(word(o), &v, 4); };
+ for (std::uint32_t i = 0; i < shnum; ++i) {
+ const std::size_t sh = shoff + i * shentsize;
+ if (elf.u32(sh + 4) != 9) continue;
+ const std::uint32_t off = elf.u32(sh + 16), count = elf.u32(sh + 20) / 8;
+ std::int64_t hi_at = -1;
+ std::uint32_t hi_word = 0;
+ for (std::uint32_t k = 0; k < count; ++k) {
+ const auto at = static_cast<std::int64_t>(static_cast<std::int32_t>(elf.u32(off + k * 8)));
+ const std::uint32_t type = elf.u32(off + k * 8 + 4) & 0xFFu;
+ std::uint32_t insn = get(at);
+ switch (type) {
+ case 2: put(at, insn + base); break;
+ case 4: put(at, (insn & ~0x03FFFFFFu) | (((insn & 0x03FFFFFFu) + (base >> 2)) & 0x03FFFFFFu)); break;
+ case 5:
+ if (v2 && k + 1 < count) {
+ const auto next = static_cast<std::int64_t>(static_cast<std::int32_t>(elf.u32(off + (k + 1) * 8)));
+ std::uint32_t value = static_cast<std::uint32_t>(static_cast<std::int16_t>(get(next))) + (insn << 16) + base;
+ if (value & 0x8000u) value += 0x10000u;
+ put(at, (insn & ~0xFFFFu) | (value >> 16));
+ } else {
+ hi_at = at;
+ hi_word = insn;
+ }
+ break;
+ case 6:
+ if (v2) {
+ put(at, (insn & ~0xFFFFu) | ((static_cast<std::uint32_t>(static_cast<std::int16_t>(insn)) + base) & 0xFFFFu));
+ } else if (hi_at >= 0) {
+ std::uint32_t value = static_cast<std::uint32_t>(static_cast<std::int16_t>(insn)) + (hi_word << 16) + base;
+ put(at, (insn & ~0xFFFFu) | (value & 0xFFFFu));
+ if (value & 0x8000u) value += 0x10000u;
+ put(hi_at, (hi_word & ~0xFFFFu) | (value >> 16));
+ hi_at = -1;
+ } else {
+ put(at, (insn & ~0xFFFFu) | ((static_cast<std::uint32_t>(static_cast<std::int16_t>(insn)) + base) & 0xFFFFu));
+ }
+ break;
+ default:
+ if (g_trace_modules) std::fprintf(stderr, "[iop] relocation type %u ignored\n", type);
+ break;
+ }
+ }
+ }
+}
+
+std::string module_name_of(const std::string &path) {
+ std::string name = path;
+ const auto slash = name.find_last_of("/\\:");
+ if (slash != std::string::npos) name = name.substr(slash + 1);
+ const auto semi = name.find(';');
+ if (semi != std::string::npos) name = name.substr(0, semi);
+ const auto dot = name.find('.');
+ if (dot != std::string::npos) name = name.substr(0, dot);
+ for (char &ch : name) ch = static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
+ return name;
+}
+
+}
+
+void fault(const char *reason) {
+ std::fprintf(stderr, "[iop] fault: %s (pc 0x%08X thread %d)\n", reason, g_cpu.pc, g_current);
+ if (Thread *t = current()) {
+ t->status = kDormant;
+ g_current = 0;
+ }
+ g_switch = true;
+}
+
+std::uint32_t fetch_special(std::uint32_t pc) {
+ std::fprintf(stderr, "[iop] fetch from 0x%08X\n", pc);
+ fault("fetch outside RAM");
+ return 0;
+}
+
+void syscall(Cpu &c, std::uint32_t pc) {
+ std::fprintf(stderr, "[iop] syscall at 0x%08X (v0 0x%X)\n", pc, c.r[2]);
+}
+
+void set_status(Cpu &c, std::uint32_t value) { c.status = value; }
+
+bool switch_pending() { return g_switch || (g_nesting && g_nested_done); }
+
+std::uint64_t now() { return g_now; }
+std::uint64_t usec_to_cycles(std::uint64_t usec) { return usec * 36864u / 1000u; }
+
+void schedule(std::uint64_t at, std::function<void()> action) {
+ g_events.push(Event{at, ++g_event_seq, std::move(action)});
+}
+
+Thread *current() {
+ auto it = g_threads.find(g_current);
+ return it == g_threads.end() ? nullptr : &it->second;
+}
+
+Thread *thread(int id) {
+ if (id == 0) return current();
+ auto it = g_threads.find(id);
+ return it == g_threads.end() ? nullptr : &it->second;
+}
+
+int create_thread(std::uint32_t entry, std::uint32_t stack_size, int priority, std::uint32_t gp, std::uint32_t attr, std::uint32_t option) {
+ Thread t;
+ t.id = g_next_thread++;
+ t.entry = entry;
+ t.stack_size = (stack_size + 0xFFu) & ~0xFFu;
+ t.stack = alloc(t.stack_size, 1);
+ t.priority = t.init_priority = priority;
+ t.gp = gp;
+ t.attr = attr;
+ t.option = option;
+ g_threads[t.id] = t;
+ if (g_trace_modules) std::fprintf(stderr, "[iop] thread %d entry 0x%08X prio %d\n", t.id, entry, priority);
+ return t.id;
+}
+
+void start_thread(int id, std::uint32_t a0, std::uint32_t a1) {
+ Thread *t = thread(id);
+ if (!t) return;
+ std::memset(&t->context, 0, sizeof t->context);
+ t->context.pc = t->entry;
+ t->context.npc = t->entry + 4;
+ t->context.r[4] = a0;
+ t->context.r[5] = a1;
+ t->context.r[28] = t->gp;
+ t->context.r[29] = t->stack + t->stack_size - 0x10u;
+ t->context.r[31] = g_exit_stub;
+ t->context.status = 0x401u;
+ t->priority = t->init_priority;
+ t->wakeups = 0;
+ t->wait = kWaitNone;
+ ready(*t);
+}
+
+void ready(Thread &t) {
+ t.status = kReady;
+ t.order = ++g_order;
+ g_switch = true;
+}
+
+void block(Cpu &c, WaitKind kind, int id) {
+ Thread *t = current();
+ if (!t || g_nesting) {
+ std::fprintf(stderr, "[iop] blocking call outside a thread (kind %d)\n", kind);
+ return;
+ }
+ t->status = kWait;
+ t->wait = kind;
+ t->wait_id = id;
+ t->context = c;
+ g_switch = true;
+}
+
+void wake(Thread &t, std::uint32_t result) {
+ if (t.status != kWait && t.status != kWaitSuspend) return;
+ t.wait = kWaitNone;
+ t.context.r[2] = result;
+ if (t.status == kWaitSuspend) t.status = kSuspend;
+ else ready(t);
+}
+
+void reschedule() { g_switch = true; }
+
+bool in_interrupt() { return g_nesting > 0; }
+
+std::uint32_t call_guest(std::uint32_t address, std::uint32_t a0, std::uint32_t a1, std::uint32_t a2, std::uint32_t a3) {
+ const Cpu saved = g_cpu;
+ const bool saved_done = g_nested_done;
+ ++g_nesting;
+ g_nested_done = false;
+ g_cpu.r[4] = a0;
+ g_cpu.r[5] = a1;
+ g_cpu.r[6] = a2;
+ g_cpu.r[7] = a3;
+ g_cpu.r[29] = kInterruptStack - static_cast<std::uint32_t>(g_nesting - 1) * 0x1000u;
+ g_cpu.r[31] = g_return_stub;
+ g_cpu.pc = address;
+ g_cpu.npc = address + 4;
+ std::int64_t guard = 50'000'000;
+ while (!g_nested_done && guard > 0) {
+ std::int64_t budget = kSlice;
+ execute(g_cpu, budget);
+ guard -= kSlice - budget;
+ if (g_switch && !g_nested_done) g_switch = false;
+ }
+ if (guard <= 0) std::fprintf(stderr, "[iop] guest call to 0x%08X did not return\n", address);
+ const std::uint32_t result = g_cpu.r[2];
+ g_cpu = saved;
+ g_nested_done = saved_done;
+ --g_nesting;
+ return result;
+}
+
+std::uint32_t alloc(std::uint32_t size, int mode, std::uint32_t at) {
+ size = (size + 0xFFu) & ~0xFFu;
+ if (!size) size = 0x100u;
+ auto fits = [&](std::uint32_t start) {
+ if (start < kUserBase || start + size > kRamSize) return false;
+ auto it = g_used.lower_bound(start);
+ if (it != g_used.end() && it->first < start + size) return false;
+ if (it != g_used.begin()) {
+ auto prev = std::prev(it);
+ if (prev->first + prev->second > start) return false;
+ }
+ return true;
+ };
+ std::uint32_t chosen = 0;
+ if (mode == 2) {
+ if (fits(at & ~0xFFu)) chosen = at & ~0xFFu;
+ } else if (mode == 1) {
+ std::uint32_t top = kRamSize;
+ for (auto it = g_used.rbegin(); ; ++it) {
+ const std::uint32_t bottom = it == g_used.rend() ? kUserBase : it->first + it->second;
+ if (top >= bottom + size && top - size >= kUserBase) { chosen = top - size; break; }
+ if (it == g_used.rend()) break;
+ top = it->first;
+ }
+ } else {
+ std::uint32_t start = kUserBase;
+ for (const auto &[a, s] : g_used) {
+ if (a >= start + size) break;
+ start = std::max(start, a + s);
+ }
+ if (start + size <= kRamSize) chosen = start;
+ }
+ if (!chosen) {
+ std::fprintf(stderr, "[iop] out of memory allocating 0x%X\n", size);
+ return 0;
+ }
+ g_used[chosen] = size;
+ return chosen;
+}
+
+void free(std::uint32_t address) { g_used.erase(phys(address)); }
+
+std::uint32_t free_total() {
+ std::uint32_t used = 0;
+ for (const auto &[a, s] : g_used) used += s;
+ return kRamSize - kUserBase - used;
+}
+
+std::uint32_t free_max() {
+ std::uint32_t best = 0, start = kUserBase;
+ for (const auto &[a, s] : g_used) {
+ if (a > start) best = std::max(best, a - start);
+ start = std::max(start, a + s);
+ }
+ return std::max(best, kRamSize - start);
+}
+
+std::uint32_t kernel_alloc(std::uint32_t size) {
+ const std::uint32_t at = g_kernel_top;
+ g_kernel_top += (size + 15u) & ~15u;
+ if (g_kernel_top > kInterruptStack - 0x4000u) std::fprintf(stderr, "[iop] kernel area exhausted\n");
+ std::memset(ram_ptr(at), 0, size);
+ return at;
+}
+
+std::uint32_t hle_stub(const HleFunction &function) {
+ const std::uint32_t id = register_hle("kernel", static_cast<std::uint32_t>(g_hle.size()) + 0x1000u, function);
+ const std::uint32_t at = kernel_alloc(8);
+ set_ram32(at, (kHleOpcode << 26) | id);
+ return at;
+}
+
+void register_library(const std::string &name, std::uint32_t table) {
+ g_libraries[name] = table;
+ if (g_trace_modules) std::fprintf(stderr, "[iop] library %s at 0x%08X\n", name.c_str(), table);
+}
+
+void register_hle_library(const std::string &name, std::uint32_t version) { g_hle_versions[name] = version; }
+
+bool library_exists(const std::string &name) { return g_libraries.count(name) || g_hle_versions.count(name); }
+
+const std::map<int, Module> &modules() { return g_modules; }
+
+void register_hle_module(const std::string &name, HleModuleStart start) { g_hle_modules[name] = std::move(start); }
+
+void register_interrupt(unsigned line, std::uint32_t handler, std::uint32_t arg, std::uint32_t mode) {
+ g_interrupts[line] = Interrupt{handler, arg, mode};
+}
+
+void release_interrupt(unsigned line) { g_interrupts.erase(line); }
+
+void enable_interrupt(unsigned line, bool enabled) { hw::set_interrupt_mask(line, enabled); }
+
+void interrupt_state(bool suspended) { g_suspended = suspended; }
+bool interrupts_suspended() { return g_suspended; }
+
+void deliver_interrupts() {
+ if (g_suspended || g_nesting) return;
+ for (unsigned guard = 0; guard < 64; ++guard) {
+ const int line = hw::next_pending_interrupt();
+ if (line < 0) return;
+ hw::acknowledge_interrupt(static_cast<unsigned>(line));
+ auto it = g_interrupts.find(static_cast<unsigned>(line));
+ if (it == g_interrupts.end() || !it->second.handler) continue;
+ const Interrupt handler = it->second;
+ const std::uint32_t result = call_guest(handler.handler, handler.arg);
+ if (result == 0 && line < 32) hw::set_interrupt_mask(static_cast<unsigned>(line), false);
+ }
+}
+
+void trace_hle(const char *library, const char *function, const Cpu &c) {
+ if (!g_trace_hle) return;
+ std::fprintf(stderr, "[iop-hle] %s:%s(%08X, %08X, %08X, %08X) ra 0x%08X thread %d\n", library, function,
+ c.r[4], c.r[5], c.r[6], c.r[7], c.r[31], g_current);
+}
+
+void boot() {
+ g_hle.clear();
+ g_hle_ids.clear();
+ g_hle_versions.clear();
+ g_libraries.clear();
+ g_hle_modules.clear();
+ g_modules.clear();
+ g_threads.clear();
+ g_used.clear();
+ while (!g_events.empty()) g_events.pop();
+ g_current = 0;
+ g_next_thread = g_next_module = 1;
+ g_kernel_top = kKernelBase;
+ g_now = g_target = 0;
+ g_switch = g_suspended = false;
+ g_nesting = 0;
+ g_interrupts.clear();
+ std::memset(&g_cpu, 0, sizeof g_cpu);
+ g_return_stub = hle_stub([](Cpu &) { g_nested_done = true; });
+ g_exit_stub = hle_stub([](Cpu &c) {
+ Thread *t = current();
+ if (!t) return;
+ t->context = c;
+ t->status = kDormant;
+ auto on_exit = std::move(t->on_exit);
+ t->on_exit = nullptr;
+ if (on_exit) on_exit();
+ g_switch = true;
+ });
+ install_libraries();
+ install_io();
+ install_cdvd();
+ install_sif();
+}
+
+}
+
+std::uint32_t register_hle(const std::string &library, std::uint32_t index, HleFunction function) {
+ auto key = std::make_pair(library, index);
+ auto it = kernel::g_hle_ids.find(key);
+ if (it != kernel::g_hle_ids.end()) {
+ kernel::g_hle[it->second].function = std::move(function);
+ return it->second;
+ }
+ const auto id = static_cast<std::uint32_t>(kernel::g_hle.size());
+ kernel::g_hle.push_back({library, index, std::move(function)});
+ kernel::g_hle_ids[key] = id;
+ return id;
+}
+
+void call_hle(Cpu &c, std::uint32_t id) {
+ if (id >= kernel::g_hle.size()) {
+ kernel::fault("bad HLE id");
+ return;
+ }
+ kernel::g_hle[id].function(c);
+}
+
+void reset() {
+ hw::reset();
+ kernel::boot();
+}
+
+std::uint64_t cycles() { return kernel::g_now; }
+
+void run(std::uint64_t ee_cycles) {
+ using namespace kernel;
+ g_ee_remainder += ee_cycles;
+ g_target += g_ee_remainder / kClockDivider;
+ g_ee_remainder %= kClockDivider;
+ while (g_now < g_target) {
+ while (!g_events.empty() && g_events.top().at <= g_now) {
+ auto action = g_events.top().action;
+ g_events.pop();
+ action();
+ }
+ deliver_interrupts();
+ if (g_switch) do_switch();
+ if (!current()) {
+ const std::uint64_t next = g_events.empty() ? g_target : std::min(g_target, g_events.top().at);
+ g_now = std::max(g_now, next);
+ continue;
+ }
+ std::int64_t budget = static_cast<std::int64_t>(std::min<std::uint64_t>(kSlice, g_target - g_now));
+ if (!g_events.empty() && g_events.top().at > g_now)
+ budget = std::min<std::int64_t>(budget, static_cast<std::int64_t>(g_events.top().at - g_now));
+ if (budget <= 0) budget = 1;
+ const std::int64_t given = budget;
+ execute(g_cpu, budget);
+ g_now += static_cast<std::uint64_t>(std::max<std::int64_t>(1, given - std::max<std::int64_t>(0, budget)));
+ }
+}
+
+bool idle() { return !kernel::current() && kernel::g_events.empty(); }
+
+void dump() {
+ using namespace kernel;
+ for (const auto &[id, m] : g_modules) std::fprintf(stderr, "[iop] module %d %s at 0x%08X\n", id, m.name.c_str(), m.base);
+ for (const auto &[id, t] : g_threads)
+ std::fprintf(stderr, "[iop] thread %d status %d prio %d wait %d/%d pc 0x%08X\n", id, t.status, t.priority, t.wait, t.wait_id,
+ id == g_current ? g_cpu.pc : t.context.pc);
+}
+
+void raise_interrupt(unsigned line) { hw::raise_interrupt(line); }
+
+std::int32_t load_module_buffer(const std::vector<std::uint8_t> &data, const std::string &path, const std::string &args,
+ std::function<void(int, int)> done) {
+ using namespace kernel;
+ const std::string name = module_name_of(path);
+ auto hle = g_hle_modules.find(name);
+ if (hle != g_hle_modules.end()) {
+ if (g_trace_modules) std::fprintf(stderr, "[iop] %s handled natively\n", name.c_str());
+ const int id = g_next_module++;
+ g_modules[id] = Module{id, name, 0, 0, 0, 0};
+ if (hle->second) hle->second();
+ if (done) done(id, 0);
+ return id;
+ }
+ if (data.size() < 52 || std::memcmp(data.data(), "\x7f" "ELF", 4) != 0) {
+ std::fprintf(stderr, "[iop] %s is not an ELF module\n", path.c_str());
+ return -1;
+ }
+ const Elf elf{data};
+ const std::uint16_t type = elf.u16(16);
+ const std::uint32_t phoff = elf.u32(28);
+ const std::uint16_t phnum = elf.u16(44), phentsize = elf.u16(42);
+ std::uint32_t iopmod = 0, load_off = 0, load_size = 0, mem_size = 0;
+ for (std::uint32_t i = 0; i < phnum; ++i) {
+ const std::size_t ph = phoff + i * phentsize;
+ const std::uint32_t ptype = elf.u32(ph);
+ if (ptype == 0x70000080u) iopmod = elf.u32(ph + 4);
+ if (ptype == 1 && !load_size) {
+ load_off = elf.u32(ph + 4);
+ load_size = elf.u32(ph + 16);
+ mem_size = elf.u32(ph + 20);
+ }
+ }
+ if (!iopmod || !load_size) {
+ std::fprintf(stderr, "[iop] %s has no iopmod/load segment (type 0x%X)\n", path.c_str(), type);
+ return -1;
+ }
+ const std::uint32_t entry = elf.u32(iopmod + 4), gp = elf.u32(iopmod + 8);
+ const std::uint32_t total = std::max(mem_size, elf.u32(iopmod + 12) + elf.u32(iopmod + 16) + elf.u32(iopmod + 20));
+ const std::uint32_t base = alloc(total + 0x40u);
+ if (!base) return -1;
+ std::memset(ram_ptr(base), 0, total);
+ std::memcpy(ram_ptr(base), data.data() + load_off, load_size);
+ relocate(elf, base, total, type == 0xFF81u);
+ link_imports(base, total);
+
+ const int id = g_next_module++;
+ g_modules[id] = Module{id, name, base, total, base + entry, base + gp};
+ if (g_trace_modules) std::fprintf(stderr, "[iop] module %d %s at 0x%08X size 0x%X entry 0x%08X\n", id, name.c_str(), base, total, base + entry);
+
+ std::vector<std::string> argv{path};
+ std::size_t start = 0;
+ while (start < args.size()) {
+ const auto end = args.find('\0', start);
+ argv.push_back(args.substr(start, end == std::string::npos ? std::string::npos : end - start));
+ if (end == std::string::npos) break;
+ start = end + 1;
+ }
+ std::uint32_t argv_size = 4u * static_cast<std::uint32_t>(argv.size() + 1);
+ for (const auto &s : argv) argv_size += static_cast<std::uint32_t>(s.size() + 1);
+ const std::uint32_t argv_at = alloc(argv_size);
+ std::uint32_t text = argv_at + 4u * static_cast<std::uint32_t>(argv.size() + 1);
+ for (std::size_t i = 0; i < argv.size(); ++i) {
+ set_ram32(argv_at + 4u * static_cast<std::uint32_t>(i), text);
+ std::memcpy(ram_ptr(text), argv[i].c_str(), argv[i].size() + 1);
+ text += static_cast<std::uint32_t>(argv[i].size() + 1);
+ }
+ set_ram32(argv_at + 4u * static_cast<std::uint32_t>(argv.size()), 0);
+
+ const int tid = create_thread(base + entry, 0x4000u, kDefaultModulePriority, base + gp, 0x02000000u, 0);
+ Thread *t = thread(tid);
+ t->on_exit = [id, tid, argv_at, done]() {
+ const std::uint32_t result = thread(tid)->context.r[2];
+ if (done) done(id, static_cast<int>(result));
+ free(argv_at);
+ if (g_trace_modules) std::fprintf(stderr, "[iop] module %d started, result %d\n", id, static_cast<std::int32_t>(result));
+ if ((result & 3u) == 1u) {
+ const Module &m = g_modules[id];
+ free(m.base);
+ }
+ };
+ start_thread(tid, static_cast<std::uint32_t>(argv.size()), argv_at);
+ return id;
+}
+
+void set_trace(bool modules_on, bool hle_on) {
+ kernel::g_trace_modules = modules_on;
+ kernel::g_trace_hle = hle_on;
+}
+
+}
diff --git a/runtime/src/iop/kernel.hpp b/runtime/src/iop/kernel.hpp
new file mode 100644
index 0000000..b0d8798
--- /dev/null
+++ b/runtime/src/iop/kernel.hpp
@@ -0,0 +1,93 @@
+#pragma once
+
+#include "iop.hpp"
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace ps2::iop::kernel {
+
+enum Status { kRun = 1, kReady = 2, kWait = 4, kSuspend = 8, kWaitSuspend = 12, kDormant = 16 };
+enum WaitKind { kWaitNone, kWaitSleep, kWaitDelay, kWaitSema, kWaitEvent, kWaitMbx, kWaitFpl, kWaitVblank, kWaitRpc, kWaitHle };
+
+struct Thread {
+ int id{};
+ int status{kDormant};
+ int priority{};
+ int init_priority{};
+ std::uint32_t entry{}, stack{}, stack_size{}, gp{}, attr{}, option{};
+ int wakeups{};
+ WaitKind wait{kWaitNone};
+ int wait_id{};
+ std::uint64_t order{};
+ Cpu context{};
+ std::uint32_t rpc_queue{};
+ std::uint32_t rpc_server{};
+ std::uint32_t event_bits{}, event_mode{}, event_result{};
+ std::uint32_t message_out{};
+ std::function<void()> on_exit;
+};
+
+void fault(const char *reason);
+std::uint32_t fetch_special(std::uint32_t pc);
+void syscall(Cpu &c, std::uint32_t pc);
+void set_status(Cpu &c, std::uint32_t value);
+bool switch_pending();
+
+std::uint64_t now();
+std::uint64_t usec_to_cycles(std::uint64_t usec);
+void schedule(std::uint64_t at, std::function<void()> action);
+
+Thread *current();
+Thread *thread(int id);
+int create_thread(std::uint32_t entry, std::uint32_t stack_size, int priority, std::uint32_t gp, std::uint32_t attr, std::uint32_t option);
+void start_thread(int id, std::uint32_t a0, std::uint32_t a1 = 0);
+void ready(Thread &t);
+void block(Cpu &c, WaitKind kind, int id);
+void wake(Thread &t, std::uint32_t result);
+void reschedule();
+bool in_interrupt();
+std::uint32_t call_guest(std::uint32_t address, std::uint32_t a0 = 0, std::uint32_t a1 = 0, std::uint32_t a2 = 0, std::uint32_t a3 = 0);
+
+std::uint32_t alloc(std::uint32_t size, int mode = 0, std::uint32_t at = 0);
+void free(std::uint32_t address);
+std::uint32_t free_total();
+std::uint32_t free_max();
+std::uint32_t kernel_alloc(std::uint32_t size);
+std::uint32_t hle_stub(const HleFunction &function);
+
+void register_library(const std::string &name, std::uint32_t table);
+void register_hle_library(const std::string &name, std::uint32_t version);
+bool library_exists(const std::string &name);
+
+struct Module {
+ int id;
+ std::string name;
+ std::uint32_t base, size, entry, gp;
+};
+const std::map<int, Module> &modules();
+using HleModuleStart = std::function<void()>;
+void register_hle_module(const std::string &name, HleModuleStart start);
+
+void register_interrupt(unsigned line, std::uint32_t handler, std::uint32_t arg, std::uint32_t mode);
+void release_interrupt(unsigned line);
+void enable_interrupt(unsigned line, bool enabled);
+void interrupt_state(bool suspended);
+bool interrupts_suspended();
+void deliver_interrupts();
+
+void install_libraries();
+void vblank_edge(bool start);
+void install_sif();
+void install_cdvdfsv();
+void install_cdvd();
+void install_io();
+
+void trace_hle(const char *library, const char *function, const Cpu &c);
+extern bool g_trace_hle;
+extern bool g_trace_modules;
+
+}
diff --git a/runtime/src/iop/libs.cpp b/runtime/src/iop/libs.cpp
new file mode 100644
index 0000000..940ba4a
--- /dev/null
+++ b/runtime/src/iop/libs.cpp
@@ -0,0 +1,956 @@
+#include "kernel.hpp"
+
+#include "hw.hpp"
+
+#include <algorithm>
+#include <cstdio>
+#include <deque>
+#include <map>
+#include <vector>
+
+namespace ps2::iop::kernel {
+
+namespace {
+
+constexpr int kErrorUnknownThread = -407;
+constexpr int kErrorUnknownSema = -408;
+constexpr int kErrorUnknownEvent = -409;
+constexpr int kErrorUnknownMbx = -410;
+constexpr int kErrorUnknownFpl = -412;
+constexpr int kErrorSemaZero = -419;
+constexpr int kErrorEventCondition = -421;
+constexpr int kErrorMbxNone = -424;
+constexpr int kErrorNoMemory = -400;
+constexpr int kErrorUnknownModule = -202;
+
+std::uint32_t arg(const Cpu &c, int i) { return i < 4 ? c.r[4 + i] : read32(c.r[29] + 16u + static_cast<std::uint32_t>(i - 4) * 4u); }
+
+void def(const char *library, std::uint32_t index, const char *name, std::function<void(Cpu &)> body) {
+ register_hle(library, index, [library, name, body = std::move(body)](Cpu &c) {
+ trace_hle(library, name, c);
+ body(c);
+ });
+}
+
+std::string format(Cpu &c, std::uint32_t fmt_address, int first) {
+ const std::string fmt = ram_string(fmt_address, 1024);
+ std::string out;
+ int next = first;
+ for (std::size_t i = 0; i < fmt.size(); ++i) {
+ if (fmt[i] != '%') { out += fmt[i]; continue; }
+ std::string spec = "%";
+ ++i;
+ while (i < fmt.size() && std::strchr("-+ #0", fmt[i])) spec += fmt[i++];
+ while (i < fmt.size() && (std::isdigit(static_cast<unsigned char>(fmt[i])) || fmt[i] == '.')) spec += fmt[i++];
+ while (i < fmt.size() && (fmt[i] == 'l' || fmt[i] == 'h')) ++i;
+ if (i >= fmt.size()) break;
+ const char conv = fmt[i];
+ char buf[512];
+ switch (conv) {
+ case 'd': case 'i': std::snprintf(buf, sizeof buf, (spec + "d").c_str(), static_cast<int>(arg(c, next++))); break;
+ case 'u': std::snprintf(buf, sizeof buf, (spec + "u").c_str(), arg(c, next++)); break;
+ case 'x': case 'X': case 'o': std::snprintf(buf, sizeof buf, (spec + conv).c_str(), arg(c, next++)); break;
+ case 'p': std::snprintf(buf, sizeof buf, "%08x", arg(c, next++)); break;
+ case 'c': std::snprintf(buf, sizeof buf, (spec + "c").c_str(), static_cast<int>(arg(c, next++))); break;
+ case 's': std::snprintf(buf, sizeof buf, (spec + "s").c_str(), ram_string(arg(c, next++)).c_str()); break;
+ case '%': std::snprintf(buf, sizeof buf, "%%"); break;
+ default: std::snprintf(buf, sizeof buf, "%s%c", spec.c_str(), conv); break;
+ }
+ out += buf;
+ }
+ return out;
+}
+
+void print(const std::string &text) {
+ static std::string line;
+ for (char ch : text) {
+ if (ch == '\n') {
+ std::fprintf(stderr, "[iop-tty] %s\n", line.c_str());
+ line.clear();
+ } else if (ch != '\r') {
+ line += ch;
+ }
+ }
+}
+
+struct Sema {
+ int count, max;
+ std::uint32_t attr, option;
+ std::deque<int> waiters;
+};
+
+struct EventFlag {
+ std::uint32_t bits, attr, option;
+ std::deque<int> waiters;
+};
+
+struct Mbx {
+ std::uint32_t attr, option;
+ std::deque<std::uint32_t> messages;
+ std::deque<int> waiters;
+};
+
+struct Fpl {
+ std::uint32_t attr, option, block_size, blocks, base;
+ std::vector<std::uint32_t> free;
+ std::deque<int> waiters;
+};
+
+struct VblankHandler {
+ int edge;
+ std::uint32_t handler, arg;
+};
+
+struct Alarm {
+ std::uint32_t handler, arg;
+ bool active;
+};
+
+std::map<int, Sema> g_semas;
+std::map<int, EventFlag> g_events;
+std::map<int, Mbx> g_mbxs;
+std::map<int, Fpl> g_fpls;
+std::vector<VblankHandler> g_vblank_handlers;
+std::vector<int> g_vblank_start_waiters, g_vblank_end_waiters;
+std::map<std::uint64_t, Alarm> g_alarms;
+std::uint64_t g_next_alarm = 1;
+int g_next_object = 1;
+
+void signal_sema(Cpu &c, int id, bool from_interrupt) {
+ auto it = g_semas.find(id);
+ if (it == g_semas.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownSema); return; }
+ Sema &s = it->second;
+ c.r[2] = 0;
+ if (!s.waiters.empty()) {
+ const int t = s.waiters.front();
+ s.waiters.pop_front();
+ if (Thread *th = thread(t)) wake(*th, 0);
+ if (!from_interrupt) reschedule();
+ } else if (s.count < s.max || s.max <= 0) {
+ ++s.count;
+ }
+}
+
+bool event_matches(const EventFlag &e, std::uint32_t bits, std::uint32_t mode) {
+ return (mode & 1u) ? (e.bits & bits) != 0 : (e.bits & bits) == bits;
+}
+
+void event_take(EventFlag &e, std::uint32_t bits, std::uint32_t mode, std::uint32_t result_ptr) {
+ if (result_ptr) write32(result_ptr, e.bits);
+ if (mode & 0x10u) e.bits &= ~bits;
+ if (mode & 0x20u) e.bits = 0;
+}
+
+void set_event(Cpu &c, int id, std::uint32_t bits, bool from_interrupt) {
+ auto it = g_events.find(id);
+ if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
+ EventFlag &e = it->second;
+ e.bits |= bits;
+ c.r[2] = 0;
+ for (auto w = e.waiters.begin(); w != e.waiters.end();) {
+ Thread *t = thread(*w);
+ if (t && event_matches(e, t->event_bits, t->event_mode)) {
+ event_take(e, t->event_bits, t->event_mode, t->event_result);
+ wake(*t, 0);
+ w = e.waiters.erase(w);
+ if (!from_interrupt) reschedule();
+ } else {
+ ++w;
+ }
+ }
+}
+
+void send_mbx(Cpu &c, int id, std::uint32_t message, bool from_interrupt) {
+ auto it = g_mbxs.find(id);
+ if (it == g_mbxs.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownMbx); return; }
+ Mbx &m = it->second;
+ c.r[2] = 0;
+ if (!m.waiters.empty()) {
+ const int t = m.waiters.front();
+ m.waiters.pop_front();
+ if (Thread *th = thread(t)) {
+ if (th->message_out) write32(th->message_out, message);
+ wake(*th, 0);
+ }
+ if (!from_interrupt) reschedule();
+ } else {
+ m.messages.push_back(message);
+ }
+}
+
+void fire_alarm(std::uint64_t key) {
+ auto it = g_alarms.find(key);
+ if (it == g_alarms.end() || !it->second.active) return;
+ const Alarm a = it->second;
+ g_alarms.erase(it);
+ const std::uint32_t again = call_guest(a.handler, a.arg);
+ if (again) {
+ const std::uint64_t k = g_next_alarm++;
+ g_alarms[k] = Alarm{a.handler, a.arg, true};
+ schedule(now() + again, [k]() { fire_alarm(k); });
+ }
+}
+
+void write_clock(std::uint32_t p, std::uint64_t cycles) {
+ write32(p, static_cast<std::uint32_t>(cycles));
+ write32(p + 4, static_cast<std::uint32_t>(cycles >> 32));
+}
+
+std::uint64_t read_clock(std::uint32_t p) {
+ return read32(p) | (static_cast<std::uint64_t>(read32(p + 4)) << 32);
+}
+
+void install_sysmem() {
+ register_hle_library("sysmem", 0x0101);
+ def("sysmem", 4, "AllocSysMemory", [](Cpu &c) { c.r[2] = alloc(arg(c, 1), static_cast<int>(arg(c, 0)), arg(c, 2)); });
+ def("sysmem", 5, "FreeSysMemory", [](Cpu &c) { free(arg(c, 0)); c.r[2] = 0; });
+ def("sysmem", 6, "QueryMemSize", [](Cpu &c) { c.r[2] = kRamSize; });
+ def("sysmem", 7, "QueryMaxFreeMemSize", [](Cpu &c) { c.r[2] = free_max(); });
+ def("sysmem", 8, "QueryTotalFreeMemSize", [](Cpu &c) { c.r[2] = free_total(); });
+ def("sysmem", 9, "QueryBlockTopAddress", [](Cpu &c) { c.r[2] = arg(c, 0); });
+ def("sysmem", 10, "QueryBlockSize", [](Cpu &c) { c.r[2] = 0; });
+ def("sysmem", 14, "Kprintf", [](Cpu &c) { print(format(c, arg(c, 0), 1)); c.r[2] = 0; });
+}
+
+void install_loadcore() {
+ register_hle_library("loadcore", 0x0101);
+ def("loadcore", 4, "FlushIcache", [](Cpu &c) { c.r[2] = 0; });
+ def("loadcore", 5, "FlushDcache", [](Cpu &c) { c.r[2] = 0; });
+ def("loadcore", 6, "RegisterLibraryEntries", [](Cpu &c) {
+ const std::uint32_t table = arg(c, 0);
+ char raw[9] = {};
+ std::memcpy(raw, ram_ptr(table + 12), 8);
+ register_library(raw, table);
+ c.r[2] = 0;
+ });
+ def("loadcore", 7, "ReleaseLibraryEntries", [](Cpu &c) { c.r[2] = 0; });
+ def("loadcore", 12, "QueryBootMode", [](Cpu &c) { c.r[2] = 0; });
+ def("loadcore", 27, "SetRebootTimeLibraryHandlingMode", [](Cpu &c) { c.r[2] = 0; });
+}
+
+void install_intrman() {
+ register_hle_library("intrman", 0x0102);
+ def("intrman", 4, "RegisterIntrHandler", [](Cpu &c) {
+ register_interrupt(arg(c, 0), arg(c, 2), arg(c, 3), arg(c, 1));
+ c.r[2] = 0;
+ });
+ def("intrman", 5, "ReleaseIntrHandler", [](Cpu &c) { release_interrupt(arg(c, 0)); c.r[2] = 0; });
+ def("intrman", 6, "EnableIntr", [](Cpu &c) { enable_interrupt(arg(c, 0), true); c.r[2] = 0; });
+ def("intrman", 7, "DisableIntr", [](Cpu &c) {
+ enable_interrupt(arg(c, 0), false);
+ if (arg(c, 1)) write32(arg(c, 1), arg(c, 0));
+ c.r[2] = 0;
+ });
+ def("intrman", 8, "CpuDisableIntr", [](Cpu &c) { interrupt_state(true); c.r[2] = 0; });
+ def("intrman", 9, "CpuEnableIntr", [](Cpu &c) { interrupt_state(false); c.r[2] = 0; });
+ def("intrman", 17, "CpuSuspendIntr", [](Cpu &c) {
+ const bool was = interrupts_suspended();
+ if (arg(c, 0)) write32(arg(c, 0), was ? 0u : 1u);
+ interrupt_state(true);
+ c.r[2] = was ? static_cast<std::uint32_t>(-102) : 0u;
+ });
+ def("intrman", 18, "CpuResumeIntr", [](Cpu &c) {
+ interrupt_state(arg(c, 0) == 0);
+ c.r[2] = 0;
+ });
+ def("intrman", 23, "QueryIntrContext", [](Cpu &c) { c.r[2] = in_interrupt() ? 1u : 0u; });
+}
+
+void install_thbase() {
+ register_hle_library("thbase", 0x0101);
+ def("thbase", 4, "CreateThread", [](Cpu &c) {
+ const std::uint32_t p = arg(c, 0);
+ c.r[2] = static_cast<std::uint32_t>(create_thread(read32(p + 8), read32(p + 12), static_cast<int>(read32(p + 16)), c.r[28], read32(p), read32(p + 4)));
+ });
+ def("thbase", 5, "DeleteThread", [](Cpu &c) { c.r[2] = 0; });
+ def("thbase", 6, "StartThread", [](Cpu &c) {
+ Thread *t = thread(static_cast<int>(arg(c, 0)));
+ if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
+ start_thread(t->id, arg(c, 1));
+ c.r[2] = 0;
+ });
+ def("thbase", 7, "StartThreadArgs", [](Cpu &c) {
+ Thread *t = thread(static_cast<int>(arg(c, 0)));
+ if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
+ start_thread(t->id, arg(c, 1), arg(c, 2));
+ c.r[2] = 0;
+ });
+ auto exit_thread = [](Cpu &c) {
+ Thread *t = current();
+ if (!t) return;
+ t->context = c;
+ t->status = kDormant;
+ auto on_exit = std::move(t->on_exit);
+ t->on_exit = nullptr;
+ if (on_exit) on_exit();
+ reschedule();
+ };
+ def("thbase", 8, "ExitThread", exit_thread);
+ def("thbase", 9, "ExitDeleteThread", exit_thread);
+ auto terminate = [](Cpu &c) {
+ Thread *t = thread(static_cast<int>(arg(c, 0)));
+ if (t && t != current()) {
+ t->status = kDormant;
+ t->wait = kWaitNone;
+ }
+ c.r[2] = t ? 0u : static_cast<std::uint32_t>(kErrorUnknownThread);
+ };
+ def("thbase", 10, "TerminateThread", terminate);
+ def("thbase", 11, "iTerminateThread", terminate);
+ def("thbase", 12, "DisableDispatchThread", [](Cpu &c) { c.r[2] = 0; });
+ def("thbase", 13, "EnableDispatchThread", [](Cpu &c) { c.r[2] = 0; });
+ auto change_priority = [](Cpu &c) {
+ Thread *t = thread(static_cast<int>(arg(c, 0)));
+ if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
+ int prio = static_cast<int>(arg(c, 1));
+ if (prio == 0) prio = t->init_priority;
+ t->priority = prio;
+ reschedule();
+ c.r[2] = 0;
+ };
+ def("thbase", 14, "ChangeThreadPriority", change_priority);
+ def("thbase", 15, "iChangeThreadPriority", change_priority);
+ auto rotate = [](Cpu &c) {
+ Thread *t = current();
+ static std::uint64_t order = 1ull << 40;
+ if (t && (arg(c, 0) == 0 || static_cast<int>(arg(c, 0)) == t->priority)) {
+ t->order = ++order;
+ reschedule();
+ }
+ c.r[2] = 0;
+ };
+ def("thbase", 16, "RotateThreadReadyQueue", rotate);
+ def("thbase", 17, "iRotateThreadReadyQueue", rotate);
+ auto release_wait = [](Cpu &c) {
+ Thread *t = thread(static_cast<int>(arg(c, 0)));
+ if (t) {
+ for (auto &[id, s] : g_semas) s.waiters.erase(std::remove(s.waiters.begin(), s.waiters.end(), t->id), s.waiters.end());
+ for (auto &[id, e] : g_events) e.waiters.erase(std::remove(e.waiters.begin(), e.waiters.end(), t->id), e.waiters.end());
+ wake(*t, static_cast<std::uint32_t>(-418));
+ reschedule();
+ }
+ c.r[2] = t ? 0u : static_cast<std::uint32_t>(kErrorUnknownThread);
+ };
+ def("thbase", 18, "ReleaseWaitThread", release_wait);
+ def("thbase", 19, "iReleaseWaitThread", release_wait);
+ def("thbase", 20, "GetThreadId", [](Cpu &c) { c.r[2] = current() ? static_cast<std::uint32_t>(current()->id) : 0u; });
+ def("thbase", 21, "CheckThreadStack", [](Cpu &c) { c.r[2] = 0x1000; });
+ auto refer = [](Cpu &c) {
+ Thread *t = thread(static_cast<int>(arg(c, 0)));
+ const std::uint32_t p = arg(c, 1);
+ if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
+ if (p) {
+ write32(p + 0, t->attr);
+ write32(p + 4, t->option);
+ write32(p + 8, static_cast<std::uint32_t>(t->status));
+ write32(p + 12, t->entry);
+ write32(p + 16, t->stack);
+ write32(p + 20, t->stack_size);
+ write32(p + 24, t->gp);
+ write32(p + 28, static_cast<std::uint32_t>(t->init_priority));
+ write32(p + 32, static_cast<std::uint32_t>(t->priority));
+ write32(p + 36, static_cast<std::uint32_t>(t->wait));
+ write32(p + 40, static_cast<std::uint32_t>(t->wait_id));
+ write32(p + 44, static_cast<std::uint32_t>(t->wakeups));
+ }
+ c.r[2] = 0;
+ };
+ def("thbase", 22, "ReferThreadStatus", refer);
+ def("thbase", 23, "iReferThreadStatus", refer);
+ def("thbase", 24, "SleepThread", [](Cpu &c) {
+ Thread *t = current();
+ c.r[2] = 0;
+ if (t && t->wakeups > 0) { --t->wakeups; return; }
+ block(c, kWaitSleep, 0);
+ });
+ auto wakeup = [](Cpu &c) {
+ Thread *t = thread(static_cast<int>(arg(c, 0)));
+ if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
+ if (t->status == kWait && t->wait == kWaitSleep) {
+ wake(*t, 0);
+ reschedule();
+ } else {
+ ++t->wakeups;
+ }
+ c.r[2] = 0;
+ };
+ def("thbase", 25, "WakeupThread", wakeup);
+ def("thbase", 26, "iWakeupThread", wakeup);
+ auto cancel_wakeup = [](Cpu &c) {
+ Thread *t = thread(static_cast<int>(arg(c, 0)));
+ c.r[2] = t ? static_cast<std::uint32_t>(t->wakeups) : static_cast<std::uint32_t>(kErrorUnknownThread);
+ if (t) t->wakeups = 0;
+ };
+ def("thbase", 27, "CancelWakeupThread", cancel_wakeup);
+ def("thbase", 28, "iCancelWakeupThread", cancel_wakeup);
+ def("thbase", 29, "SuspendThread", [](Cpu &c) { c.r[2] = 0; });
+ def("thbase", 31, "ResumeThread", [](Cpu &c) { c.r[2] = 0; });
+ def("thbase", 33, "DelayThread", [](Cpu &c) {
+ Thread *t = current();
+ c.r[2] = 0;
+ if (!t) return;
+ const int id = t->id;
+ block(c, kWaitDelay, 0);
+ schedule(now() + std::max<std::uint64_t>(1, usec_to_cycles(arg(c, 0))), [id]() {
+ Thread *th = thread(id);
+ if (th && th->wait == kWaitDelay) wake(*th, 0);
+ });
+ });
+ def("thbase", 34, "GetSystemTime", [](Cpu &c) { write_clock(arg(c, 0), now()); c.r[2] = 0; });
+ auto set_alarm = [](Cpu &c) {
+ const std::uint64_t delay = read_clock(arg(c, 0));
+ const std::uint64_t key = g_next_alarm++;
+ g_alarms[key] = Alarm{arg(c, 1), arg(c, 2), true};
+ schedule(now() + std::max<std::uint64_t>(1, delay), [key]() { fire_alarm(key); });
+ c.r[2] = 0;
+ };
+ def("thbase", 35, "SetAlarm", set_alarm);
+ def("thbase", 36, "iSetAlarm", set_alarm);
+ auto cancel_alarm = [](Cpu &c) {
+ for (auto &[k, a] : g_alarms)
+ if (a.handler == arg(c, 0) && a.arg == arg(c, 1)) a.active = false;
+ c.r[2] = 0;
+ };
+ def("thbase", 37, "CancelAlarm", cancel_alarm);
+ def("thbase", 38, "iCancelAlarm", cancel_alarm);
+ def("thbase", 39, "USec2SysClock", [](Cpu &c) { write_clock(arg(c, 1), usec_to_cycles(arg(c, 0))); c.r[2] = 0; });
+ def("thbase", 40, "SysClock2USec", [](Cpu &c) {
+ const std::uint64_t usec = read_clock(arg(c, 0)) * 1000u / 36864u;
+ write32(arg(c, 1), static_cast<std::uint32_t>(usec / 1000000u));
+ write32(arg(c, 2), static_cast<std::uint32_t>(usec % 1000000u));
+ c.r[2] = 0;
+ });
+ def("thbase", 41, "GetSystemStatusFlag", [](Cpu &c) { c.r[2] = 0; });
+}
+
+void install_thsemap() {
+ register_hle_library("thsemap", 0x0101);
+ def("thsemap", 4, "CreateSema", [](Cpu &c) {
+ const std::uint32_t p = arg(c, 0);
+ const int id = g_next_object++;
+ g_semas[id] = Sema{static_cast<int>(read32(p + 8)), static_cast<int>(read32(p + 12)), read32(p), read32(p + 4), {}};
+ c.r[2] = static_cast<std::uint32_t>(id);
+ });
+ def("thsemap", 5, "DeleteSema", [](Cpu &c) {
+ auto it = g_semas.find(static_cast<int>(arg(c, 0)));
+ if (it == g_semas.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownSema); return; }
+ for (int t : it->second.waiters)
+ if (Thread *th = thread(t)) wake(*th, static_cast<std::uint32_t>(-425));
+ g_semas.erase(it);
+ reschedule();
+ c.r[2] = 0;
+ });
+ def("thsemap", 6, "SignalSema", [](Cpu &c) { signal_sema(c, static_cast<int>(arg(c, 0)), false); });
+ def("thsemap", 7, "iSignalSema", [](Cpu &c) { signal_sema(c, static_cast<int>(arg(c, 0)), true); });
+ def("thsemap", 8, "WaitSema", [](Cpu &c) {
+ auto it = g_semas.find(static_cast<int>(arg(c, 0)));
+ if (it == g_semas.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownSema); return; }
+ c.r[2] = 0;
+ if (it->second.count > 0) { --it->second.count; return; }
+ it->second.waiters.push_back(current() ? current()->id : 0);
+ block(c, kWaitSema, it->first);
+ });
+ def("thsemap", 9, "PollSema", [](Cpu &c) {
+ auto it = g_semas.find(static_cast<int>(arg(c, 0)));
+ if (it == g_semas.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownSema); return; }
+ if (it->second.count > 0) { --it->second.count; c.r[2] = 0; }
+ else c.r[2] = static_cast<std::uint32_t>(kErrorSemaZero);
+ });
+ auto refer = [](Cpu &c) {
+ auto it = g_semas.find(static_cast<int>(arg(c, 0)));
+ if (it == g_semas.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownSema); return; }
+ const std::uint32_t p = arg(c, 1);
+ write32(p + 0, it->second.attr);
+ write32(p + 4, it->second.option);
+ write32(p + 8, 0);
+ write32(p + 12, static_cast<std::uint32_t>(it->second.max));
+ write32(p + 16, static_cast<std::uint32_t>(it->second.count));
+ write32(p + 20, static_cast<std::uint32_t>(it->second.waiters.size()));
+ c.r[2] = 0;
+ };
+ def("thsemap", 11, "ReferSemaStatus", refer);
+ def("thsemap", 12, "iReferSemaStatus", refer);
+}
+
+void install_thevent() {
+ register_hle_library("thevent", 0x0101);
+ def("thevent", 4, "CreateEventFlag", [](Cpu &c) {
+ const std::uint32_t p = arg(c, 0);
+ const int id = g_next_object++;
+ g_events[id] = EventFlag{read32(p + 8), read32(p), read32(p + 4), {}};
+ c.r[2] = static_cast<std::uint32_t>(id);
+ });
+ def("thevent", 5, "DeleteEventFlag", [](Cpu &c) {
+ auto it = g_events.find(static_cast<int>(arg(c, 0)));
+ if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
+ for (int t : it->second.waiters)
+ if (Thread *th = thread(t)) wake(*th, static_cast<std::uint32_t>(-425));
+ g_events.erase(it);
+ c.r[2] = 0;
+ });
+ def("thevent", 6, "SetEventFlag", [](Cpu &c) { set_event(c, static_cast<int>(arg(c, 0)), arg(c, 1), false); });
+ def("thevent", 7, "iSetEventFlag", [](Cpu &c) { set_event(c, static_cast<int>(arg(c, 0)), arg(c, 1), true); });
+ auto clear = [](Cpu &c) {
+ auto it = g_events.find(static_cast<int>(arg(c, 0)));
+ if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
+ it->second.bits &= arg(c, 1);
+ c.r[2] = 0;
+ };
+ def("thevent", 8, "ClearEventFlag", clear);
+ def("thevent", 9, "iClearEventFlag", clear);
+ def("thevent", 10, "WaitEventFlag", [](Cpu &c) {
+ auto it = g_events.find(static_cast<int>(arg(c, 0)));
+ if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
+ EventFlag &e = it->second;
+ c.r[2] = 0;
+ if (event_matches(e, arg(c, 1), arg(c, 2))) {
+ event_take(e, arg(c, 1), arg(c, 2), arg(c, 3));
+ return;
+ }
+ Thread *t = current();
+ if (!t) return;
+ t->event_bits = arg(c, 1);
+ t->event_mode = arg(c, 2);
+ t->event_result = arg(c, 3);
+ e.waiters.push_back(t->id);
+ block(c, kWaitEvent, it->first);
+ });
+ auto poll = [](Cpu &c) {
+ auto it = g_events.find(static_cast<int>(arg(c, 0)));
+ if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
+ if (event_matches(it->second, arg(c, 1), arg(c, 2))) {
+ event_take(it->second, arg(c, 1), arg(c, 2), arg(c, 3));
+ c.r[2] = 0;
+ } else {
+ c.r[2] = static_cast<std::uint32_t>(kErrorEventCondition);
+ }
+ };
+ def("thevent", 11, "PollEventFlag", poll);
+ def("thevent", 12, "iPollEventFlag", poll);
+ auto refer = [](Cpu &c) {
+ auto it = g_events.find(static_cast<int>(arg(c, 0)));
+ if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
+ const std::uint32_t p = arg(c, 1);
+ write32(p + 0, it->second.attr);
+ write32(p + 4, it->second.option);
+ write32(p + 8, 0);
+ write32(p + 12, it->second.bits);
+ write32(p + 16, static_cast<std::uint32_t>(it->second.waiters.size()));
+ c.r[2] = 0;
+ };
+ def("thevent", 13, "ReferEventFlagStatus", refer);
+ def("thevent", 14, "iReferEventFlagStatus", refer);
+}
+
+void install_thmsgbx() {
+ register_hle_library("thmsgbx", 0x0101);
+ def("thmsgbx", 4, "CreateMbx", [](Cpu &c) {
+ const std::uint32_t p = arg(c, 0);
+ const int id = g_next_object++;
+ g_mbxs[id] = Mbx{read32(p), read32(p + 4), {}, {}};
+ c.r[2] = static_cast<std::uint32_t>(id);
+ });
+ def("thmsgbx", 5, "DeleteMbx", [](Cpu &c) { g_mbxs.erase(static_cast<int>(arg(c, 0))); c.r[2] = 0; });
+ def("thmsgbx", 6, "SendMbx", [](Cpu &c) { send_mbx(c, static_cast<int>(arg(c, 0)), arg(c, 1), false); });
+ def("thmsgbx", 7, "iSendMbx", [](Cpu &c) { send_mbx(c, static_cast<int>(arg(c, 0)), arg(c, 1), true); });
+ def("thmsgbx", 8, "ReceiveMbx", [](Cpu &c) {
+ auto it = g_mbxs.find(static_cast<int>(arg(c, 1)));
+ if (it == g_mbxs.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownMbx); return; }
+ c.r[2] = 0;
+ if (!it->second.messages.empty()) {
+ write32(arg(c, 0), it->second.messages.front());
+ it->second.messages.pop_front();
+ return;
+ }
+ Thread *t = current();
+ if (!t) return;
+ t->message_out = arg(c, 0);
+ it->second.waiters.push_back(t->id);
+ block(c, kWaitMbx, it->first);
+ });
+ def("thmsgbx", 9, "PollMbx", [](Cpu &c) {
+ auto it = g_mbxs.find(static_cast<int>(arg(c, 1)));
+ if (it == g_mbxs.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownMbx); return; }
+ if (it->second.messages.empty()) { c.r[2] = static_cast<std::uint32_t>(kErrorMbxNone); return; }
+ write32(arg(c, 0), it->second.messages.front());
+ it->second.messages.pop_front();
+ c.r[2] = 0;
+ });
+}
+
+void install_thfpool() {
+ register_hle_library("thfpool", 0x0101);
+ def("thfpool", 4, "CreateFpl", [](Cpu &c) {
+ const std::uint32_t p = arg(c, 0);
+ Fpl f{read32(p), read32(p + 4), (read32(p + 8) + 3u) & ~3u, read32(p + 12), 0, {}, {}};
+ f.base = alloc(f.block_size * f.blocks);
+ if (!f.base) { c.r[2] = static_cast<std::uint32_t>(kErrorNoMemory); return; }
+ for (std::uint32_t i = f.blocks; i-- > 0;) f.free.push_back(f.base + i * f.block_size);
+ const int id = g_next_object++;
+ g_fpls[id] = f;
+ c.r[2] = static_cast<std::uint32_t>(id);
+ });
+ def("thfpool", 5, "DeleteFpl", [](Cpu &c) {
+ auto it = g_fpls.find(static_cast<int>(arg(c, 0)));
+ if (it != g_fpls.end()) { free(it->second.base); g_fpls.erase(it); }
+ c.r[2] = 0;
+ });
+ def("thfpool", 6, "AllocateFpl", [](Cpu &c) {
+ auto it = g_fpls.find(static_cast<int>(arg(c, 0)));
+ if (it == g_fpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownFpl); return; }
+ if (!it->second.free.empty()) { c.r[2] = it->second.free.back(); it->second.free.pop_back(); return; }
+ it->second.waiters.push_back(current() ? current()->id : 0);
+ block(c, kWaitFpl, it->first);
+ });
+ auto poll = [](Cpu &c) {
+ auto it = g_fpls.find(static_cast<int>(arg(c, 0)));
+ if (it == g_fpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownFpl); return; }
+ if (it->second.free.empty()) { c.r[2] = 0; return; }
+ c.r[2] = it->second.free.back();
+ it->second.free.pop_back();
+ };
+ def("thfpool", 7, "pAllocateFpl", poll);
+ def("thfpool", 8, "ipAllocateFpl", poll);
+ def("thfpool", 9, "FreeFpl", [](Cpu &c) {
+ auto it = g_fpls.find(static_cast<int>(arg(c, 0)));
+ if (it == g_fpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownFpl); return; }
+ if (!it->second.waiters.empty()) {
+ const int t = it->second.waiters.front();
+ it->second.waiters.pop_front();
+ if (Thread *th = thread(t)) wake(*th, arg(c, 1));
+ reschedule();
+ } else {
+ it->second.free.push_back(arg(c, 1));
+ }
+ c.r[2] = 0;
+ });
+}
+
+void install_sysclib() {
+ register_hle_library("sysclib", 0x0103);
+ def("sysclib", 4, "setjmp", [](Cpu &c) {
+ const std::uint32_t p = arg(c, 0);
+ const int regs[12] = {31, 29, 30, 16, 17, 18, 19, 20, 21, 22, 23, 28};
+ for (int i = 0; i < 12; ++i) write32(p + 4u * static_cast<std::uint32_t>(i), c.r[regs[i]]);
+ c.r[2] = 0;
+ });
+ def("sysclib", 5, "longjmp", [](Cpu &c) {
+ const std::uint32_t p = arg(c, 0), value = arg(c, 1);
+ const int regs[12] = {31, 29, 30, 16, 17, 18, 19, 20, 21, 22, 23, 28};
+ for (int i = 0; i < 12; ++i) c.r[regs[i]] = read32(p + 4u * static_cast<std::uint32_t>(i));
+ c.pc = c.r[31];
+ c.npc = c.pc + 4;
+ c.r[2] = value ? value : 1u;
+ });
+ def("sysclib", 6, "_toupper", [](Cpu &c) { c.r[2] = static_cast<std::uint32_t>(std::toupper(static_cast<int>(arg(c, 0) & 0xFF))); });
+ def("sysclib", 7, "_tolower", [](Cpu &c) { c.r[2] = static_cast<std::uint32_t>(std::tolower(static_cast<int>(arg(c, 0) & 0xFF))); });
+ def("sysclib", 8, "look_ctype_table", [](Cpu &c) {
+ const int ch = static_cast<int>(arg(c, 0) & 0xFF);
+ std::uint32_t t = 0;
+ if (std::isupper(ch)) t |= 1;
+ if (std::islower(ch)) t |= 2;
+ if (std::isdigit(ch)) t |= 4;
+ if (std::isspace(ch)) t |= 8;
+ if (std::ispunct(ch)) t |= 16;
+ if (std::iscntrl(ch)) t |= 32;
+ if (std::isxdigit(ch)) t |= 64;
+ c.r[2] = t;
+ });
+ def("sysclib", 10, "memchr", [](Cpu &c) {
+ for (std::uint32_t i = 0; i < arg(c, 2); ++i)
+ if (read8(arg(c, 0) + i) == (arg(c, 1) & 0xFF)) { c.r[2] = arg(c, 0) + i; return; }
+ c.r[2] = 0;
+ });
+ def("sysclib", 11, "memcmp", [](Cpu &c) {
+ for (std::uint32_t i = 0; i < arg(c, 2); ++i) {
+ const int d = read8(arg(c, 0) + i) - read8(arg(c, 1) + i);
+ if (d) { c.r[2] = static_cast<std::uint32_t>(d); return; }
+ }
+ c.r[2] = 0;
+ });
+ auto copy = [](std::uint32_t dst, std::uint32_t src, std::uint32_t n) {
+ if (phys(dst) + n <= kRamSize && phys(src) + n <= kRamSize) std::memmove(ram_ptr(dst), ram_ptr(src), n);
+ else if (dst < src) for (std::uint32_t i = 0; i < n; ++i) write8(dst + i, read8(src + i));
+ else for (std::uint32_t i = n; i-- > 0;) write8(dst + i, read8(src + i));
+ };
+ def("sysclib", 12, "memcpy", [copy](Cpu &c) { copy(arg(c, 0), arg(c, 1), arg(c, 2)); c.r[2] = arg(c, 0); });
+ def("sysclib", 13, "memmove", [copy](Cpu &c) { copy(arg(c, 0), arg(c, 1), arg(c, 2)); c.r[2] = arg(c, 0); });
+ def("sysclib", 14, "memset", [](Cpu &c) {
+ if (phys(arg(c, 0)) + arg(c, 2) <= kRamSize) std::memset(ram_ptr(arg(c, 0)), static_cast<int>(arg(c, 1) & 0xFF), arg(c, 2));
+ else for (std::uint32_t i = 0; i < arg(c, 2); ++i) write8(arg(c, 0) + i, static_cast<std::uint8_t>(arg(c, 1)));
+ c.r[2] = arg(c, 0);
+ });
+ def("sysclib", 15, "bcmp", [](Cpu &c) {
+ c.r[2] = std::memcmp(ram_ptr(arg(c, 0)), ram_ptr(arg(c, 1)), arg(c, 2)) ? 1u : 0u;
+ });
+ def("sysclib", 16, "bcopy", [copy](Cpu &c) { copy(arg(c, 1), arg(c, 0), arg(c, 2)); });
+ def("sysclib", 17, "bzero", [](Cpu &c) { std::memset(ram_ptr(arg(c, 0)), 0, arg(c, 1)); });
+ def("sysclib", 19, "sprintf", [](Cpu &c) {
+ const std::string s = format(c, arg(c, 1), 2);
+ std::memcpy(ram_ptr(arg(c, 0)), s.c_str(), s.size() + 1);
+ c.r[2] = static_cast<std::uint32_t>(s.size());
+ });
+ def("sysclib", 20, "strcat", [](Cpu &c) {
+ const std::string a = ram_string(arg(c, 0), 4096), b = ram_string(arg(c, 1), 4096);
+ std::memcpy(ram_ptr(arg(c, 0) + static_cast<std::uint32_t>(a.size())), b.c_str(), b.size() + 1);
+ c.r[2] = arg(c, 0);
+ });
+ def("sysclib", 21, "strchr", [](Cpu &c) {
+ for (std::uint32_t p = arg(c, 0);; ++p) {
+ const std::uint8_t ch = read8(p);
+ if (ch == (arg(c, 1) & 0xFF)) { c.r[2] = p; return; }
+ if (!ch) { c.r[2] = 0; return; }
+ }
+ });
+ def("sysclib", 22, "strcmp", [](Cpu &c) {
+ const int r = std::strcmp(ram_string(arg(c, 0), 4096).c_str(), ram_string(arg(c, 1), 4096).c_str());
+ c.r[2] = static_cast<std::uint32_t>(r < 0 ? -1 : r > 0 ? 1 : 0);
+ });
+ def("sysclib", 23, "strcpy", [](Cpu &c) {
+ const std::string s = ram_string(arg(c, 1), 4096);
+ std::memcpy(ram_ptr(arg(c, 0)), s.c_str(), s.size() + 1);
+ c.r[2] = arg(c, 0);
+ });
+ def("sysclib", 25, "index", [](Cpu &c) {
+ const std::string s = ram_string(arg(c, 0), 4096);
+ const auto pos = s.find(static_cast<char>(arg(c, 1)));
+ c.r[2] = pos == std::string::npos ? 0u : arg(c, 0) + static_cast<std::uint32_t>(pos);
+ });
+ def("sysclib", 27, "strlen", [](Cpu &c) { c.r[2] = static_cast<std::uint32_t>(ram_string(arg(c, 0), 65536).size()); });
+ def("sysclib", 28, "strncat", [](Cpu &c) {
+ const std::string a = ram_string(arg(c, 0), 4096), b = ram_string(arg(c, 1), arg(c, 2));
+ std::memcpy(ram_ptr(arg(c, 0) + static_cast<std::uint32_t>(a.size())), b.c_str(), b.size() + 1);
+ c.r[2] = arg(c, 0);
+ });
+ def("sysclib", 29, "strncmp", [](Cpu &c) {
+ const int r = std::strncmp(ram_string(arg(c, 0), 4096).c_str(), ram_string(arg(c, 1), 4096).c_str(), arg(c, 2));
+ c.r[2] = static_cast<std::uint32_t>(r < 0 ? -1 : r > 0 ? 1 : 0);
+ });
+ def("sysclib", 30, "strncpy", [](Cpu &c) {
+ const std::string s = ram_string(arg(c, 1), arg(c, 2));
+ for (std::uint32_t i = 0; i < arg(c, 2); ++i) write8(arg(c, 0) + i, i < s.size() ? static_cast<std::uint8_t>(s[i]) : 0);
+ c.r[2] = arg(c, 0);
+ });
+ def("sysclib", 32, "strrchr", [](Cpu &c) {
+ const std::string s = ram_string(arg(c, 0), 4096);
+ const auto pos = s.rfind(static_cast<char>(arg(c, 1)));
+ c.r[2] = pos == std::string::npos ? 0u : arg(c, 0) + static_cast<std::uint32_t>(pos);
+ });
+ def("sysclib", 34, "strstr", [](Cpu &c) {
+ const std::string s = ram_string(arg(c, 0), 4096), n = ram_string(arg(c, 1), 4096);
+ const auto pos = s.find(n);
+ c.r[2] = pos == std::string::npos ? 0u : arg(c, 0) + static_cast<std::uint32_t>(pos);
+ });
+ def("sysclib", 36, "strtol", [](Cpu &c) {
+ const std::string s = ram_string(arg(c, 0), 256);
+ char *end = nullptr;
+ const long v = std::strtol(s.c_str(), &end, static_cast<int>(arg(c, 2)));
+ if (arg(c, 1)) write32(arg(c, 1), arg(c, 0) + static_cast<std::uint32_t>(end - s.c_str()));
+ c.r[2] = static_cast<std::uint32_t>(v);
+ });
+ def("sysclib", 38, "strtoul", [](Cpu &c) {
+ const std::string s = ram_string(arg(c, 0), 256);
+ char *end = nullptr;
+ const unsigned long v = std::strtoul(s.c_str(), &end, static_cast<int>(arg(c, 2)));
+ if (arg(c, 1)) write32(arg(c, 1), arg(c, 0) + static_cast<std::uint32_t>(end - s.c_str()));
+ c.r[2] = static_cast<std::uint32_t>(v);
+ });
+ def("sysclib", 40, "_wmemcopy", [copy](Cpu &c) { copy(arg(c, 0), arg(c, 1), arg(c, 2)); c.r[2] = arg(c, 0); });
+ def("sysclib", 41, "_wmemset", [](Cpu &c) {
+ for (std::uint32_t i = 0; i < arg(c, 2); i += 4) write32(arg(c, 0) + i, arg(c, 1));
+ c.r[2] = arg(c, 0);
+ });
+ def("sysclib", 42, "vsprintf", [](Cpu &c) {
+ const std::uint32_t list = arg(c, 2);
+ std::string out;
+ const std::string fmt = ram_string(arg(c, 1), 1024);
+ std::uint32_t ap = list;
+ for (std::size_t i = 0; i < fmt.size(); ++i) {
+ if (fmt[i] != '%') { out += fmt[i]; continue; }
+ std::string spec = "%";
+ ++i;
+ while (i < fmt.size() && std::strchr("-+ #0.0123456789", fmt[i])) spec += fmt[i++];
+ while (i < fmt.size() && (fmt[i] == 'l' || fmt[i] == 'h')) ++i;
+ if (i >= fmt.size()) break;
+ char buf[512];
+ const char conv = fmt[i];
+ if (conv == '%') { out += '%'; continue; }
+ const std::uint32_t v = read32(ap);
+ ap += 4;
+ if (conv == 's') std::snprintf(buf, sizeof buf, (spec + "s").c_str(), ram_string(v).c_str());
+ else if (conv == 'd' || conv == 'i') std::snprintf(buf, sizeof buf, (spec + "d").c_str(), static_cast<int>(v));
+ else if (conv == 'c') std::snprintf(buf, sizeof buf, (spec + "c").c_str(), static_cast<int>(v));
+ else std::snprintf(buf, sizeof buf, (spec + conv).c_str(), v);
+ out += buf;
+ }
+ std::memcpy(ram_ptr(arg(c, 0)), out.c_str(), out.size() + 1);
+ c.r[2] = static_cast<std::uint32_t>(out.size());
+ });
+}
+
+void install_stdio() {
+ register_hle_library("stdio", 0x0102);
+ def("stdio", 4, "printf", [](Cpu &c) {
+ const std::string s = format(c, arg(c, 0), 1);
+ print(s);
+ c.r[2] = static_cast<std::uint32_t>(s.size());
+ });
+ def("stdio", 6, "putchar", [](Cpu &c) { print(std::string(1, static_cast<char>(arg(c, 0)))); c.r[2] = arg(c, 0); });
+ def("stdio", 7, "puts", [](Cpu &c) { print(ram_string(arg(c, 0), 4096) + "\n"); c.r[2] = 0; });
+}
+
+void install_modload() {
+ register_hle_library("modload", 0x0102);
+ def("modload", 13, "SetCheckKelfPathCallback", [](Cpu &c) { c.r[2] = 0; });
+ def("modload", 16, "GetModuleIdList", [](Cpu &c) {
+ std::uint32_t n = 0;
+ for (const auto &[id, m] : modules()) {
+ if (n < arg(c, 1)) write32(arg(c, 0) + 4 * n, static_cast<std::uint32_t>(id));
+ ++n;
+ }
+ if (arg(c, 2)) write32(arg(c, 2), n);
+ c.r[2] = 0;
+ });
+ def("modload", 17, "ReferModuleStatus", [](Cpu &c) {
+ auto it = modules().find(static_cast<int>(arg(c, 0)));
+ if (it == modules().end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownModule); return; }
+ const std::uint32_t p = arg(c, 1);
+ std::memset(ram_ptr(p), 0, 0x50);
+ std::memcpy(ram_ptr(p), it->second.name.c_str(), std::min<std::size_t>(it->second.name.size(), 55));
+ write32(p + 0x38, static_cast<std::uint32_t>(it->first));
+ write32(p + 0x40, it->second.entry);
+ write32(p + 0x44, it->second.gp);
+ write32(p + 0x48, it->second.base);
+ write32(p + 0x4C, it->second.size);
+ c.r[2] = 0;
+ });
+ def("modload", 22, "SearchModuleByName", [](Cpu &c) {
+ std::string name = ram_string(arg(c, 0), 64);
+ for (const auto &[id, m] : modules()) {
+ std::string a = m.name, b = name;
+ for (char &ch : a) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
+ for (char &ch : b) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
+ if (a == b) { c.r[2] = static_cast<std::uint32_t>(id); return; }
+ }
+ c.r[2] = static_cast<std::uint32_t>(kErrorUnknownModule);
+ });
+}
+
+void install_vblank() {
+ register_hle_library("vblank", 0x0101);
+ def("vblank", 4, "WaitVblankStart", [](Cpu &c) {
+ c.r[2] = 0;
+ if (!current()) return;
+ g_vblank_start_waiters.push_back(current()->id);
+ block(c, kWaitVblank, 0);
+ });
+ def("vblank", 5, "WaitVblankEnd", [](Cpu &c) {
+ c.r[2] = 0;
+ if (!current()) return;
+ g_vblank_end_waiters.push_back(current()->id);
+ block(c, kWaitVblank, 1);
+ });
+ def("vblank", 6, "WaitVblank", [](Cpu &c) {
+ c.r[2] = 0;
+ if (!current()) return;
+ g_vblank_start_waiters.push_back(current()->id);
+ block(c, kWaitVblank, 0);
+ });
+ def("vblank", 7, "WaitNonVblank", [](Cpu &c) {
+ c.r[2] = 0;
+ if (!current()) return;
+ g_vblank_end_waiters.push_back(current()->id);
+ block(c, kWaitVblank, 1);
+ });
+ def("vblank", 8, "RegisterVblankHandler", [](Cpu &c) {
+ g_vblank_handlers.push_back(VblankHandler{static_cast<int>(arg(c, 0)), arg(c, 2), arg(c, 3)});
+ c.r[2] = 0;
+ });
+ def("vblank", 9, "ReleaseVblankHandler", [](Cpu &c) {
+ g_vblank_handlers.erase(std::remove_if(g_vblank_handlers.begin(), g_vblank_handlers.end(), [&](const VblankHandler &h) {
+ return h.edge == static_cast<int>(arg(c, 0)) && h.handler == arg(c, 1);
+ }), g_vblank_handlers.end());
+ c.r[2] = 0;
+ });
+}
+
+void install_timrman() {
+ register_hle_library("timrman", 0x0101);
+ def("timrman", 4, "AllocHardTimer", [](Cpu &c) { static std::uint32_t next = 1; c.r[2] = next++; });
+ def("timrman", 5, "ReferHardTimer", [](Cpu &c) { c.r[2] = 1; });
+ def("timrman", 6, "FreeHardTimer", [](Cpu &c) { c.r[2] = 0; });
+ def("timrman", 7, "SetTimerMode", [](Cpu &c) { c.r[2] = 0; });
+ def("timrman", 9, "SetTimerCounter", [](Cpu &c) { c.r[2] = 0; });
+ def("timrman", 11, "SetTimerCompare", [](Cpu &c) { c.r[2] = 0; });
+ def("timrman", 16, "GetHardTimerIntrCode", [](Cpu &c) { c.r[2] = 14; });
+}
+
+void install_dmacman() {
+ register_hle_library("dmacman", 0x0101);
+ for (std::uint32_t i : {16u, 17u, 28u, 32u, 33u, 34u, 35u})
+ def("dmacman", i, "dmac", [](Cpu &c) { c.r[2] = 0; });
+}
+
+void install_heaplib() {
+ register_hle_library("heaplib", 0x0101);
+ def("heaplib", 4, "CreateHeap", [](Cpu &c) { c.r[2] = kernel_alloc(16); });
+ def("heaplib", 5, "DeleteHeap", [](Cpu &c) { c.r[2] = 0; });
+ def("heaplib", 6, "AllocHeapMemory", [](Cpu &c) { c.r[2] = alloc(arg(c, 1)); });
+ def("heaplib", 7, "FreeHeapMemory", [](Cpu &c) { free(arg(c, 1)); c.r[2] = 0; });
+}
+
+void install_misc() {
+ register_hle_library("secrman", 0x0101);
+ for (std::uint32_t i : {4u, 5u, 6u}) def("secrman", i, "secrman", [](Cpu &c) { c.r[2] = 0; });
+}
+
+}
+
+void vblank_edge(bool start) {
+ auto &waiters = start ? g_vblank_start_waiters : g_vblank_end_waiters;
+ for (int id : waiters)
+ if (Thread *t = thread(id)) wake(*t, 0);
+ if (!waiters.empty()) reschedule();
+ waiters.clear();
+ for (const VblankHandler h : std::vector<VblankHandler>(g_vblank_handlers))
+ if ((h.edge == 0) == start) call_guest(h.handler, h.arg);
+}
+
+void install_libraries() {
+ g_semas.clear();
+ g_events.clear();
+ g_mbxs.clear();
+ g_fpls.clear();
+ g_vblank_handlers.clear();
+ g_vblank_start_waiters.clear();
+ g_vblank_end_waiters.clear();
+ g_alarms.clear();
+ g_next_object = 1;
+ install_sysmem();
+ install_loadcore();
+ install_intrman();
+ install_thbase();
+ install_thsemap();
+ install_thevent();
+ install_thmsgbx();
+ install_thfpool();
+ install_sysclib();
+ install_stdio();
+ install_modload();
+ install_vblank();
+ install_timrman();
+ install_dmacman();
+ install_heaplib();
+ install_misc();
+}
+
+}
+
+namespace ps2::iop {
+
+void vblank(bool start) {
+ hw::raise_interrupt(start ? 0u : 11u);
+ kernel::vblank_edge(start);
+}
+
+}
diff --git a/runtime/src/iop/spu2.cpp b/runtime/src/iop/spu2.cpp
new file mode 100644
index 0000000..eae06a0
--- /dev/null
+++ b/runtime/src/iop/spu2.cpp
@@ -0,0 +1,85 @@
+#include "spu2.hpp"
+
+#include "iop.hpp"
+
+#include <cstring>
+#include <vector>
+
+namespace ps2::iop::spu2 {
+
+namespace {
+
+constexpr std::uint32_t kRamWords = 1u << 20;
+
+std::vector<std::uint16_t> g_ram(kRamWords);
+std::uint16_t g_regs[0x400];
+
+struct Core {
+ std::uint32_t tsa;
+};
+Core g_cores[2];
+
+std::uint32_t reg_index(std::uint32_t a) { return (a & 0x7FFu) >> 1; }
+
+int core_of(std::uint32_t a) {
+ const std::uint32_t off = a & 0x7FFu;
+ if (off < 0x400u) return 0;
+ if (off < 0x760u) return 1;
+ return off < 0x788u ? 0 : 1;
+}
+
+std::uint32_t local(std::uint32_t a) {
+ const std::uint32_t off = a & 0x7FFu;
+ return off < 0x760u ? (off & 0x3FFu) : off;
+}
+
+}
+
+void reset() {
+ std::fill(g_ram.begin(), g_ram.end(), 0);
+ std::memset(g_regs, 0, sizeof g_regs);
+ std::memset(g_cores, 0, sizeof g_cores);
+}
+
+std::uint16_t *ram() { return g_ram.data(); }
+
+std::uint32_t read(std::uint32_t a, unsigned) {
+ const std::uint32_t off = local(a);
+ const int core = core_of(a);
+ if (off == 0x344u) return 0x0080u;
+ if (off == 0x1A8u) return g_cores[core].tsa >> 16;
+ if (off == 0x1AAu) return g_cores[core].tsa & 0xFFFFu;
+ return g_regs[reg_index(a)];
+}
+
+void write(std::uint32_t a, std::uint32_t v, unsigned size) {
+ const std::uint32_t off = local(a);
+ const int core = core_of(a);
+ if (size == 4) {
+ write(a, v & 0xFFFFu, 2);
+ write(a + 2, v >> 16, 2);
+ return;
+ }
+ v &= 0xFFFFu;
+ g_regs[reg_index(a)] = static_cast<std::uint16_t>(v);
+ Core &c = g_cores[core];
+ if (off == 0x1A8u) c.tsa = ((v & 0xFu) << 16) | (c.tsa & 0xFFFFu);
+ else if (off == 0x1AAu) c.tsa = (c.tsa & 0xF0000u) | v;
+ else if (off == 0x1ACu) {
+ g_ram[c.tsa & (kRamWords - 1)] = static_cast<std::uint16_t>(v);
+ c.tsa = (c.tsa + 1) & (kRamWords - 1);
+ }
+}
+
+void dma(int core, std::uint32_t madr, std::uint32_t words, bool to_spu) {
+ Core &c = g_cores[core];
+ for (std::uint32_t i = 0; i < words * 2; ++i) {
+ std::uint16_t *spu = &g_ram[(c.tsa + i) & (kRamWords - 1)];
+ std::uint8_t *iop = ram_ptr(madr + i * 2);
+ if (to_spu) std::memcpy(spu, iop, 2);
+ else std::memcpy(iop, spu, 2);
+ }
+ c.tsa = (c.tsa + words * 2) & (kRamWords - 1);
+}
+
+}
diff --git a/runtime/src/iop/spu2.hpp b/runtime/src/iop/spu2.hpp
new file mode 100644
index 0000000..b1da9cd
--- /dev/null
+++ b/runtime/src/iop/spu2.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <cstdint>
+
+namespace ps2::iop::spu2 {
+
+void reset();
+std::uint16_t *ram();
+std::uint32_t read(std::uint32_t a, unsigned size);
+void write(std::uint32_t a, std::uint32_t v, unsigned size);
+void dma(int core, std::uint32_t madr, std::uint32_t words, bool to_spu);
+
+}