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.cppnew file mode 100644index 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.cppnew file mode 100644index 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 ®) {+ 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.hppnew file mode 100644index 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.hppnew file mode 100644index 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.cppnew file mode 100644index 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.hppnew file mode 100644index 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.cppnew file mode 100644index 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.cppnew file mode 100644index 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.hppnew file mode 100644index 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);++}