PS2 games in the browser: static recompilation to WebAssembly with a native runtime
C++
runtime: dispatcher, EE kernel and a native runner
Samir Nuriff858751f947
diff --git a/CMakeLists.txt b/CMakeLists.txtindex d412c8e..18db941 100644--- a/CMakeLists.txt+++ b/CMakeLists.txt@@ -4,6 +4,8 @@ project(ps2-web-recomp CXX)set(CMAKE_CXX_STANDARD 20)set(CMAKE_CXX_STANDARD_REQUIRED ON)+set(PS2_GENERATED "" CACHE PATH "Folder with the C++ generated for a game")+if(NOT EMSCRIPTEN)add_executable(eerecomprecomp/main.cpp@@ -13,3 +15,24 @@ if(NOT EMSCRIPTEN)recomp/codegen.cpp)target_compile_options(eerecomp PRIVATE -Wall -Wextra)endif()++add_library(ps2runtime STATIC+ runtime/src/memory.cpp+ runtime/src/dispatch.cpp+ runtime/src/system.cpp+ runtime/src/kernel.cpp+ runtime/src/hw.cpp+ runtime/src/cop.cpp)+target_include_directories(ps2runtime PUBLIC runtime/include)+target_compile_options(ps2runtime PRIVATE -Wall -Wextra)++if(PS2_GENERATED)+ file(GLOB PS2_UNITS CONFIGURE_DEPENDS "${PS2_GENERATED}/*.cpp")+ add_library(ps2game STATIC ${PS2_UNITS})+ target_include_directories(ps2game PRIVATE "${PS2_GENERATED}")+ target_link_libraries(ps2game PUBLIC ps2runtime)+ target_compile_options(ps2game PRIVATE -Wno-unused-label -Wno-unused-variable)++ add_executable(ps2run host/main.cpp)+ target_link_libraries(ps2run PRIVATE ps2game ps2runtime)+endif()diff --git a/host/main.cpp b/host/main.cppnew file mode 100644index 0000000..b240bfb--- /dev/null+++ b/host/main.cpp@@ -0,0 +1,45 @@+#include "ps2/system.hpp"++#include <cstdio>+#include <cstdlib>+#include <cstring>+#include <string>+#include <vector>++void register_generated_code();++namespace {++int usage() {+ std::fprintf(stderr,+ "usage: ps2run <elf> [--arg text]... [--frames n] [--ntsc] [--misses file]\n"+ " [--trace-syscalls] [--trace-io] [--trace-threads]\n");+ return 2;+}++}++int main(int argc, char **argv) {+ if (argc < 2) return usage();+ std::vector<std::string> args{argv[1]};+ for (int i = 2; i < argc; ++i) {+ const std::string a = argv[i];+ if (a == "--arg" && i + 1 < argc) args.push_back(argv[++i]);+ else if (a == "--frames" && i + 1 < argc) ps2::g_options.max_frames = std::strtoull(argv[++i], nullptr, 10);+ else if (a == "--ntsc") ps2::g_options.pal = false;+ else if (a == "--misses" && i + 1 < argc) ps2::g_options.misses_path = argv[++i];+ else if (a == "--trace-syscalls") ps2::g_options.trace_syscalls = true;+ else if (a == "--trace-io") ps2::g_options.trace_io = true;+ else if (a == "--trace-threads") ps2::g_options.trace_threads = true;+ else return usage();+ }++ register_generated_code();+ std::uint32_t entry = 0;+ if (!ps2::load_elf(argv[1], entry)) {+ std::fprintf(stderr, "cannot load %s\n", argv[1]);+ return 1;+ }+ ps2::boot(entry, args);+ return ps2::run();+}diff --git a/recomp/codegen.cpp b/recomp/codegen.cppindex d93fef4..f4ac916 100644--- a/recomp/codegen.cpp+++ b/recomp/codegen.cpp@@ -193,6 +193,10 @@ private:simple(i);++pending_;falls = true;+ } else if (i.op == Eret) {+ flush();+ line("{ const std::uint32_t t = eret(c); c.pc = t; [[clang::musttail]] return dispatch(c, 0u, depth); }");+ falls = false;} else if (fl == Flow::Stop) {flush();line(std::format("stop(c, {}, \"{}\"); return;", hex(a), name(i.op)));@@ -235,7 +239,7 @@ private:}std::string jump(std::uint32_t t, std::uint32_t from) {- std::string check = t <= from ? std::format("if (c.budget < 0) {{ c.pc = {} | kUnwind; return; }} ", hex(t)) : "";+ std::string check = t <= from ? std::format("if (c.budget < 0 && preempt(c)) {{ c.pc = {} | kUnwind; return; }} ", hex(t)) : "";if (in_unit(t) && p_.is_code(t)) return check + "goto " + label(t) + ";";if (p_.is_code(t))return check + std::format("[[clang::musttail]] return {}(c, {}u, depth);", unit_name(layout_.unit_of(t)), id_of(t));diff --git a/runtime/include/ps2/generated.hpp b/runtime/include/ps2/generated.hppindex f41e74d..3b2c58f 100644--- a/runtime/include/ps2/generated.hpp+++ b/runtime/include/ps2/generated.hpp@@ -26,6 +26,7 @@ void register_units(const UnitInfo *units, std::uint32_t count);void dispatch(Cpu &c, std::uint32_t entry, std::uint32_t depth);void call(Cpu &c, std::uint32_t target, std::uint32_t depth);void bad_entry(Cpu &c, std::uint32_t unit_base);+bool preempt(Cpu &c);void syscall(Cpu &c, std::uint32_t pc);void breakpoint(Cpu &c, std::uint32_t pc);@@ -35,6 +36,7 @@ void stop(Cpu &c, std::uint32_t pc, const char *what);std::uint32_t mfc0(Cpu &c, std::uint32_t reg, std::uint32_t sel);void mtc0(Cpu &c, std::uint32_t reg, std::uint32_t value);void set_interrupts(Cpu &c, bool enabled);+std::uint32_t eret(Cpu &c);bool cpcond0(Cpu &c);std::uint32_t cfc1(Cpu &c, std::uint32_t reg);diff --git a/runtime/include/ps2/system.hpp b/runtime/include/ps2/system.hppnew file mode 100644index 0000000..feff013--- /dev/null+++ b/runtime/include/ps2/system.hpp@@ -0,0 +1,56 @@+#pragma once++#include "cpu.hpp"++#include <cstdint>+#include <functional>+#include <string>+#include <vector>++namespace ps2 {++inline constexpr std::uint64_t kEeClock = 294912000ull;+inline constexpr std::uint32_t kHandlerReturn = 0x00001000u;+inline constexpr std::uint32_t kIdle = 0x00001010u;++extern Cpu g_cpu;++struct Options {+ bool trace_syscalls = false;+ bool trace_io = false;+ bool trace_threads = false;+ bool pal = true;+ std::uint64_t max_frames = 0;+ std::string misses_path;+};++extern Options g_options;++struct ThreadContext {+ Reg128 r[32];+ Reg128 hi, lo;+ std::uint32_t sa, pc;+ std::uint32_t f[32];+ std::uint32_t facc, fcr31;+};++void save_context(const Cpu &c, ThreadContext &t);+void load_context(Cpu &c, const ThreadContext &t);++std::uint64_t now();+void set_budget(Cpu &c, std::int64_t cycles);+void schedule(int event, std::uint64_t at, std::function<void()> action);+bool preempt(Cpu &c);++bool has_code(std::uint32_t pc);+void raise_intc(unsigned cause);+void request_reschedule();++bool load_elf(const std::string &path, std::uint32_t &entry);+void boot(std::uint32_t entry, const std::vector<std::string> &args);+int run();+void halt(const std::string &reason);+bool halted();+std::uint64_t frame_count();++}diff --git a/runtime/src/cop.cpp b/runtime/src/cop.cppnew file mode 100644index 0000000..98667fc--- /dev/null+++ b/runtime/src/cop.cpp@@ -0,0 +1,68 @@+#include "hw.hpp"+#include "ps2/generated.hpp"+#include "ps2/system.hpp"++#include <cstdio>++namespace ps2 {++std::uint32_t cfc1(Cpu &c, std::uint32_t reg) {+ if (reg == 0) return 0x2E30u;+ if (reg == 31) return c.fcr31;+ return 0;+}++void ctc1(Cpu &c, std::uint32_t reg, std::uint32_t value) {+ if (reg == 31) c.fcr31 = value;+}++std::uint32_t cfc2(Cpu &c, std::uint32_t reg) {+ Vu0Regs &v = c.vu0;+ switch (reg) {+ case 16: return v.status;+ case 17: return v.mac;+ case 18: return v.clip;+ case 20: return v.r;+ case 21: return v.i;+ case 22: return v.q;+ case 26: return v.tpc;+ case 27: return v.cmsar0;+ case 29: return 0;+ default:+ std::fprintf(stderr, "[vu0] cfc2 %u\n", reg);+ return 0;+ }+}++void ctc2(Cpu &c, std::uint32_t reg, std::uint32_t value) {+ Vu0Regs &v = c.vu0;+ switch (reg) {+ case 16: v.status = (v.status & 0x3Fu) | (value & 0xFC0u); break;+ case 17: v.mac = value; break;+ case 18: v.clip = value & 0xFFFFFFu; break;+ case 20: v.r = value & 0x7FFFFFu; break;+ case 21: v.i = value; break;+ case 22: v.q = value; break;+ case 27: v.cmsar0 = value & 0xFFFFu; break;+ case 28: break;+ case 31:+ std::fprintf(stderr, "[vu1] start at 0x%X through CMSAR1 (not implemented)\n", value);+ break;+ default:+ std::fprintf(stderr, "[vu0] ctc2 %u = 0x%08X\n", reg, value);+ break;+ }+}++void vcallms(Cpu &, std::uint32_t address) {+ static int reported = 0;+ if (reported++ < 8) std::fprintf(stderr, "[vu0] microprogram at 0x%04X (not implemented)\n", address);+}++bool vu0_busy(Cpu &) { return false; }+void vu0_wait(Cpu &) {}+std::uint8_t *vu0_data() { return g_vu0_mem; }++bool cpcond0(Cpu &) { return true; }++}diff --git a/runtime/src/dispatch.cpp b/runtime/src/dispatch.cppnew file mode 100644index 0000000..a5b91b2--- /dev/null+++ b/runtime/src/dispatch.cpp@@ -0,0 +1,92 @@+#include "ps2/generated.hpp"+#include "ps2/system.hpp"++#include <algorithm>+#include <cstdio>+#include <fstream>+#include <set>+#include <string>+#include <vector>++namespace ps2 {++namespace {++std::vector<UnitInfo> g_units;+std::vector<const UnitInfo *> g_index;+std::uint32_t g_origin = 0;+std::uint32_t g_unit_size = 1;+std::set<std::uint32_t> g_misses;++const UnitInfo *unit_for(std::uint32_t pc) {+ const std::uint32_t slot = (pc - g_origin) / g_unit_size;+ if (pc < g_origin || slot >= g_index.size()) return nullptr;+ return g_index[slot];+}++void record_miss(std::uint32_t pc) {+ if (!g_misses.insert(pc).second || g_options.misses_path.empty()) return;+ std::ofstream out(g_options.misses_path, std::ios::app);+ out << std::hex << pc << "\n";+}++}++void register_units(const UnitInfo *units, std::uint32_t count) {+ g_units.assign(units, units + count);+ if (g_units.empty()) return;+ std::sort(g_units.begin(), g_units.end(), [](const UnitInfo &a, const UnitInfo &b) { return a.base < b.base; });+ g_origin = g_units.front().base;+ g_unit_size = g_units.front().size;+ g_index.assign((g_units.back().base - g_origin) / g_unit_size + 1, nullptr);+ for (const UnitInfo &u : g_units) g_index[(u.base - g_origin) / g_unit_size] = &u;+}++bool has_code(std::uint32_t pc) {+ const UnitInfo *u = unit_for(pc);+ return u && u->entries[(pc - u->base) >> 2] != 0;+}++void dispatch(Cpu &c, std::uint32_t, std::uint32_t depth) {+ const std::uint32_t pc = c.pc;+ if (pc & kUnwind) return;+ if (pc == kHandlerReturn || pc == kIdle) return;+ const UnitInfo *u = unit_for(pc);+ const std::uint16_t id = u ? u->entries[(pc - u->base) >> 2] : 0;+ if (!id) {+ record_miss(pc);+ std::fprintf(stderr, "[ee] no translated code at 0x%08X (ra 0x%08X)\n", pc, c.r[31].w[0]);+ halt("missing code");+ c.pc = pc | kUnwind;+ return;+ }+ u->function(c, id, depth);+}++void call(Cpu &c, std::uint32_t target, std::uint32_t depth) {+ c.pc = target;+ if (depth >= kMaxDepth) return;+ dispatch(c, 0, depth);+}++void bad_entry(Cpu &c, std::uint32_t unit_base) {+ std::fprintf(stderr, "[ee] bad entry into unit 0x%08X for pc 0x%08X\n", unit_base, c.pc);+ halt("bad entry");+ c.pc |= kUnwind;+}++void stop(Cpu &c, std::uint32_t pc, const char *what) {+ std::fprintf(stderr, "[ee] stopped at 0x%08X: %s\n", pc, what);+ halt(what);+ c.pc = pc | kUnwind;+}++void breakpoint(Cpu &c, std::uint32_t pc) {+ std::fprintf(stderr, "[ee] break at 0x%08X (ra 0x%08X)\n", pc, c.r[31].w[0]);+}++void trap(Cpu &c, std::uint32_t pc) {+ std::fprintf(stderr, "[ee] trap at 0x%08X (ra 0x%08X)\n", pc, c.r[31].w[0]);+}++}diff --git a/runtime/src/hw.cpp b/runtime/src/hw.cppnew file mode 100644index 0000000..bcec9ae--- /dev/null+++ b/runtime/src/hw.cpp@@ -0,0 +1,186 @@+#include "hw.hpp"++#include "kernel.hpp"+#include "ps2/memory.hpp"+#include "ps2/system.hpp"++#include <cstdio>+#include <cstring>+#include <map>+#include <set>++namespace ps2::hw {++namespace {++constexpr std::uint32_t kIntcStat = 0x1000F000u, kIntcMask = 0x1000F010u;+constexpr std::uint32_t kDmacStat = 0x1000E010u;+constexpr std::uint32_t kGsCsr = 0x12001000u, kGsImr = 0x12001010u;++std::uint32_t g_intc_stat = 0, g_intc_mask = 0;+std::uint32_t g_dmac_stat = 0;+std::uint64_t g_gs_csr = 0x551B0000ull, g_gs_imr = 0x7F00ull;+std::uint32_t g_sif[8] = {};+std::map<std::uint32_t, std::uint64_t> g_regs;+std::set<std::uint32_t> g_reported;+std::uint32_t g_crt[3] = {};++void report(const char *what, std::uint32_t a, std::uint64_t v) {+ if (g_options.trace_io || g_reported.insert(a).second)+ std::fprintf(stderr, "[io] %s 0x%08X = 0x%llX (pc 0x%08X)\n", what, a, static_cast<unsigned long long>(v), g_cpu.pc);+}++std::uint32_t timer_count(std::uint32_t base) {+ const std::uint32_t mode = static_cast<std::uint32_t>(g_regs[base + 0x10]);+ const std::uint64_t bus = now() / 2;+ std::uint64_t ticks;+ switch (mode & 3u) {+ case 0: ticks = bus; break;+ case 1: ticks = bus / 16; break;+ case 2: ticks = bus / 256; break;+ default: ticks = now() / 18874u; break;+ }+ return static_cast<std::uint32_t>((ticks - g_regs[base + 0x40]) & 0xFFFFu);+}++bool is_timer(std::uint32_t a) { return a < 0x10002000u && (a & 0x7FFu) < 0x40u; }++}++void reset() {+ g_intc_stat = g_intc_mask = g_dmac_stat = 0;+ g_gs_csr = 0x551B0000ull;+ g_gs_imr = 0x7F00ull;+ std::memset(g_sif, 0, sizeof g_sif);+ g_regs.clear();+ g_regs[0x10001810u] = 0x183u;+}++void vblank_start() {+ g_gs_csr ^= 0x2000u;+ g_gs_csr |= 0x8u;+ intc_raise(2);+ if (!(g_gs_imr & 0x800u)) intc_raise(0);+ schedule(kEventVblankEnd, now() + 18874u * 22u, [] { intc_raise(3); });+}++std::uint32_t intc_pending() { return g_intc_stat & g_intc_mask; }++void intc_raise(unsigned cause) {+ g_intc_stat |= 1u << cause;+ if (g_intc_mask & (1u << cause)) kernel::wake_idle();+}++void intc_ack(unsigned cause) { g_intc_stat &= ~(1u << cause); }++bool intc_set_mask(unsigned cause, bool enabled) {+ const std::uint32_t bit = 1u << cause;+ const bool was = g_intc_mask & bit;+ if (enabled) g_intc_mask |= bit;+ else g_intc_mask &= ~bit;+ return was != enabled;+}++std::uint32_t dmac_pending() {+ const std::uint32_t cis = g_dmac_stat & 0x3FFu, cim = (g_dmac_stat >> 16) & 0x3FFu;+ return cis & cim;+}++void dmac_ack(unsigned channel) { g_dmac_stat &= ~(1u << channel); }++bool dmac_set_mask(unsigned channel, bool enabled) {+ const std::uint32_t bit = 0x10000u << channel;+ const bool was = g_dmac_stat & bit;+ if (enabled) g_dmac_stat |= bit;+ else g_dmac_stat &= ~bit;+ return was != enabled;+}++std::uint64_t gs_imr() { return g_gs_imr; }+void gs_set_imr(std::uint64_t value) { g_gs_imr = value; }++void gs_set_crt(std::uint32_t interlace, std::uint32_t mode, std::uint32_t field) {+ g_crt[0] = interlace;+ g_crt[1] = mode;+ g_crt[2] = field;+ std::fprintf(stderr, "[gs] SetGsCrt interlace %u mode 0x%X field %u\n", interlace, mode, field);+}++std::uint32_t sif_get(std::uint32_t reg) {+ if (reg & 0x80000000u) return g_sif[7];+ return g_sif[reg & 7u];+}++void sif_set(std::uint32_t reg, std::uint32_t value) {+ if (reg & 0x80000000u) g_sif[7] = value;+ else g_sif[reg & 7u] = value;+}++std::uint32_t read32(std::uint32_t a) {+ if (a == kIntcStat) return g_intc_stat;+ if (a == kIntcMask) return g_intc_mask;+ if (a == kDmacStat) return g_dmac_stat;+ if (a == kGsCsr) return static_cast<std::uint32_t>(g_gs_csr);+ if (a == kGsCsr + 4) return static_cast<std::uint32_t>(g_gs_csr >> 32);+ if (a == kGsImr) return static_cast<std::uint32_t>(g_gs_imr);+ if (is_timer(a) && (a & 0x3Fu) == 0) return timer_count(a);+ if (a >= 0x1000F200u && a < 0x1000F280u) return g_sif[(a >> 4) & 7u];+ if (a == 0x1000F130u) return 0;+ if (a == 0x1000F520u) return static_cast<std::uint32_t>(g_regs[0x1000F590u]);+ auto it = g_regs.find(a);+ const std::uint64_t v = it == g_regs.end() ? 0 : it->second;+ report("read", a, v);+ return static_cast<std::uint32_t>(v);+}++void write32(std::uint32_t a, std::uint32_t v) {+ if (a == kIntcStat) { g_intc_stat &= ~v; return; }+ if (a == kIntcMask) { g_intc_mask ^= v; return; }+ if (a == kDmacStat) {+ g_dmac_stat &= ~(v & 0xFFFFu);+ g_dmac_stat ^= v & 0xFFFF0000u;+ return;+ }+ if (a == kGsCsr) {+ g_gs_csr &= ~static_cast<std::uint64_t>(v & 0x1Fu);+ if (v & 0x200u) g_gs_csr = 0x551B0000ull | (g_gs_csr & 0x2000u);+ return;+ }+ if (a == kGsImr) { g_gs_imr = v; return; }+ if (is_timer(a) && (a & 0x3Fu) == 0) {+ g_regs[a + 0x40] = 0;+ g_regs[a + 0x40] = static_cast<std::uint64_t>(timer_count(a)) - v;+ return;+ }+ if (a >= 0x1000F200u && a < 0x1000F280u) { g_sif[(a >> 4) & 7u] = v; return; }+ report("write", a, v);+ g_regs[a] = v;+}++std::uint64_t read64(std::uint32_t a) {+ if (a == kGsCsr) return g_gs_csr;+ if (a == kGsImr) return g_gs_imr;+ return read32(a) | (static_cast<std::uint64_t>(read32(a + 4)) << 32);+}++void write64(std::uint32_t a, std::uint64_t v) {+ if (a == kGsCsr || a == kGsImr) { write32(a, static_cast<std::uint32_t>(v)); return; }+ if (a >= 0x12000000u && a < 0x12002000u) {+ report("write64", a, v);+ g_regs[a] = v;+ return;+ }+ write32(a, static_cast<std::uint32_t>(v));+ write32(a + 4, static_cast<std::uint32_t>(v >> 32));+}++void read128(std::uint32_t a, Reg128 &out) {+ report("read128", a, 0);+ std::memset(&out, 0, sizeof out);+}++void write128(std::uint32_t a, const Reg128 &v) {+ report("write128", a, v.d[0]);+}++}diff --git a/runtime/src/hw.hpp b/runtime/src/hw.hppnew file mode 100644index 0000000..3be577b--- /dev/null+++ b/runtime/src/hw.hpp@@ -0,0 +1,55 @@+#pragma once++#include "ps2/cpu.hpp"++#include <cstdint>++namespace ps2 {++extern std::uint8_t g_vu0_code[4096];+extern std::uint8_t g_vu0_mem[4096];+extern std::uint8_t g_vu1_code[16384];+extern std::uint8_t g_vu1_mem[16384];++std::uint32_t physical(std::uint32_t a);++namespace hw {++enum Event {+ kEventVblank,+ kEventVblankEnd,+ kEventTimer0,+ kEventTimer1,+ kEventTimer2,+ kEventTimer3,+ kEventDma0,+ kEventIop = kEventDma0 + 10,+ kEventCount+};++void vblank_start();+std::uint32_t intc_pending();+void intc_raise(unsigned cause);+void intc_ack(unsigned cause);+bool intc_set_mask(unsigned cause, bool enabled);+std::uint32_t dmac_pending();+void dmac_ack(unsigned channel);+bool dmac_set_mask(unsigned channel, bool enabled);+std::uint64_t gs_imr();+void gs_set_imr(std::uint64_t value);+void gs_set_crt(std::uint32_t interlace, std::uint32_t mode, std::uint32_t field);+std::uint32_t sif_get(std::uint32_t reg);+void sif_set(std::uint32_t reg, std::uint32_t value);++std::uint32_t read32(std::uint32_t a);+void write32(std::uint32_t a, std::uint32_t v);+std::uint64_t read64(std::uint32_t a);+void write64(std::uint32_t a, std::uint64_t v);+void read128(std::uint32_t a, Reg128 &out);+void write128(std::uint32_t a, const Reg128 &v);++void reset();++}++}diff --git a/runtime/src/kernel.cpp b/runtime/src/kernel.cppnew file mode 100644index 0000000..4a59b5b--- /dev/null+++ b/runtime/src/kernel.cpp@@ -0,0 +1,772 @@+#include "kernel.hpp"++#include "hw.hpp"+#include "ps2/generated.hpp"+#include "ps2/memory.hpp"+#include "ps2/system.hpp"++#include <algorithm>+#include <cstdio>+#include <cstring>+#include <deque>+#include <map>+#include <vector>++namespace ps2::kernel {++namespace {++enum Status { kRun = 1, kReady = 2, kWait = 4, kSuspend = 8, kWaitSuspend = 12, kDormant = 16 };+enum WaitType { kWaitNone, kWaitSleep, kWaitSema };++constexpr std::uint32_t kKernelStackTop = 0x00080000u;+constexpr std::uint32_t kSyscallTable = 0x00001800u;+constexpr std::uint32_t kContextReserve = 0x2A0u;+constexpr int kMaxPriority = 128;++struct Thread {+ int id{};+ int status{kDormant};+ int priority{};+ int init_priority{};+ std::uint32_t entry{};+ std::uint32_t stack{};+ std::uint32_t stack_size{};+ std::uint32_t gp{};+ std::uint32_t heap{};+ std::uint32_t option{};+ std::uint32_t attr{};+ int wakeups{};+ int suspends{};+ WaitType wait{kWaitNone};+ int wait_id{};+ std::uint64_t order{};+ ThreadContext context{};+};++struct Semaphore {+ int count{};+ int max{};+ int init{};+ std::uint32_t attr{};+ std::uint32_t option{};+ std::deque<int> waiters;+};++struct Handler {+ int id{};+ std::uint32_t cause{};+ std::uint32_t address{};+ std::uint32_t arg{};+ std::uint32_t gp{};+};++struct Alarm {+ std::uint32_t callback{};+ std::uint32_t arg{};+ std::uint32_t gp{};+ std::uint64_t due{};+};++std::map<int, Thread> g_threads;+std::map<int, Semaphore> g_semas;+std::vector<Handler> g_intc_handlers;+std::vector<Handler> g_dmac_handlers;+std::map<int, Alarm> g_alarms;+int g_current = 0;+int g_next_thread = 1;+int g_next_sema = 1;+int g_next_handler = 1;+int g_next_alarm = 1;+std::uint64_t g_order = 0;+bool g_in_handler = false;+bool g_reschedule = false;+std::vector<int> g_pending_alarms;+std::uint32_t g_vsync_flag = 0, g_vsync_data = 0;+std::uint32_t g_osd_config = 0;++std::uint32_t arg(const Cpu &c, int i) { return c.r[4 + i].w[0]; }+void ret(Cpu &c, std::int64_t v) { c.r[2].sd[0] = v; }++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;+}++void make_ready(Thread &t) {+ t.status = kReady;+ t.order = ++g_order;+ g_reschedule = true;+}++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 switch_to(Cpu &c, Thread *next) {+ Thread *cur = current();+ if (cur == next) return;+ if (cur && (cur->status == kRun || cur->status == kReady || cur->status == kWait || cur->status == kSuspend || cur->status == kWaitSuspend)) {+ save_context(c, cur->context);+ if (cur->status == kRun) cur->status = kReady;+ }+ if (next) {+ next->status = kRun;+ g_current = next->id;+ load_context(c, next->context);+ if (g_options.trace_threads) std::fprintf(stderr, "[thread] -> %d at 0x%08X\n", next->id, next->context.pc);+ } else {+ g_current = 0;+ c.pc = kIdle;+ if (g_options.trace_threads) std::fprintf(stderr, "[thread] -> idle\n");+ }+ c.pc |= kUnwind;+}++void reschedule(Cpu &c) {+ g_reschedule = false;+ if (g_in_handler) return;+ Thread *cur = current();+ Thread *best = best_ready();+ if (best == cur && cur && cur->status == kRun) return;+ switch_to(c, best);+}++void block_current(Cpu &c, WaitType type, int id) {+ Thread *t = current();+ t->status = kWait;+ t->wait = type;+ t->wait_id = id;+ save_context(c, t->context);+ reschedule(c);+}++void release(Thread &t, std::int64_t result) {+ t.wait = kWaitNone;+ t.context.r[2].sd[0] = result;+ if (t.status == kWaitSuspend) t.status = kSuspend;+ else make_ready(t);+}++std::uint32_t run_guest(Cpu &c, std::uint32_t address, std::uint32_t a0, std::uint32_t a1, std::uint32_t a2, std::uint32_t gp,+ std::uint32_t a3 = 0) {+ ThreadContext saved;+ save_context(c, saved);+ const bool nested = g_in_handler;+ g_in_handler = true;+ c.r[4].sd[0] = static_cast<std::int32_t>(a0);+ c.r[5].sd[0] = static_cast<std::int32_t>(a1);+ c.r[6].sd[0] = static_cast<std::int32_t>(a2);+ c.r[7].sd[0] = static_cast<std::int32_t>(a3);+ if (gp) c.r[28].sd[0] = static_cast<std::int32_t>(gp);+ c.r[29].sd[0] = static_cast<std::int32_t>(kKernelStackTop - (nested ? 0x4000u : 0u));+ c.r[31].sd[0] = static_cast<std::int32_t>(kHandlerReturn);+ c.pc = address;+ while (!halted()) {+ c.pc &= ~kUnwind;+ if (c.pc == kHandlerReturn) break;+ if (c.budget <= 0) set_budget(c, 20000);+ dispatch(c, 0, 0);+ }+ const std::uint32_t result = c.r[2].w[0];+ load_context(c, saved);+ g_in_handler = nested;+ return result;+}++void run_intc(Cpu &c, unsigned cause) {+ hw::intc_ack(cause);+ const std::vector<Handler> handlers = g_intc_handlers;+ for (const Handler &h : handlers) {+ if (h.cause != cause) continue;+ const std::int32_t result = static_cast<std::int32_t>(run_guest(c, h.address, cause, h.arg, 0, h.gp));+ if (result < 0) break;+ }+}++void run_dmac(Cpu &c, unsigned channel) {+ hw::dmac_ack(channel);+ const std::vector<Handler> handlers = g_dmac_handlers;+ for (const Handler &h : handlers) {+ if (h.cause != channel) continue;+ const std::int32_t result = static_cast<std::int32_t>(run_guest(c, h.address, channel, h.arg, 0, h.gp));+ if (result < 0) break;+ }+}++bool interrupts_enabled() {+ const std::uint32_t status = g_cpu.cop0[12];+ return (status & 0x10001u) == 0x10001u && !(status & 6u);+}++void add_handler(Cpu &c, std::vector<Handler> &list) {+ Handler h{g_next_handler++, arg(c, 0), arg(c, 1), arg(c, 3), c.r[28].w[0]};+ const auto next = static_cast<std::int32_t>(arg(c, 2));+ if (next == 0) list.insert(list.begin(), h);+ else if (next == -1) list.push_back(h);+ else {+ auto it = std::find_if(list.begin(), list.end(), [&](const Handler &x) { return x.id == next; });+ list.insert(it, h);+ }+ ret(c, h.id);+}++void remove_handler(Cpu &c, std::vector<Handler> &list) {+ const int id = static_cast<int>(arg(c, 1));+ list.erase(std::remove_if(list.begin(), list.end(), [&](const Handler &h) { return h.id == id; }), list.end());+ ret(c, 0);+}++void fire_alarm(int id);++void arm_alarm(int id) {+ schedule(hw::kEventCount + id, g_alarms[id].due, [id]() { fire_alarm(id); });+}++void fire_alarm(int id) {+ if (g_alarms.count(id)) g_pending_alarms.push_back(id);+}++void run_alarms(Cpu &c) {+ while (!g_pending_alarms.empty()) {+ const int id = g_pending_alarms.front();+ g_pending_alarms.erase(g_pending_alarms.begin());+ auto it = g_alarms.find(id);+ if (it == g_alarms.end()) continue;+ const Alarm alarm = it->second;+ g_alarms.erase(it);+ run_guest(c, alarm.callback, static_cast<std::uint32_t>(id), static_cast<std::uint32_t>(now() / 18874u), alarm.arg, alarm.gp);+ g_reschedule = true;+ }+}++int create_thread(Cpu &c) {+ const std::uint32_t p = arg(c, 0);+ Thread t;+ t.id = g_next_thread++;+ t.status = kDormant;+ t.entry = ld32(p + 4);+ t.stack = ld32(p + 8);+ t.stack_size = ld32(p + 12);+ t.gp = ld32(p + 16);+ t.init_priority = t.priority = static_cast<int>(ld32(p + 20));+ t.attr = ld32(p + 28);+ t.option = ld32(p + 32);+ t.heap = current() ? current()->heap : 0;+ g_threads[t.id] = t;+ if (g_options.trace_threads)+ std::fprintf(stderr, "[thread] create %d entry 0x%08X stack 0x%08X+0x%X prio %d\n", t.id, t.entry, t.stack, t.stack_size, t.priority);+ return t.id;+}++void reset_thread(Thread &t, std::uint32_t argument) {+ std::memset(&t.context, 0, sizeof t.context);+ t.context.pc = t.entry;+ t.context.r[4].sd[0] = static_cast<std::int32_t>(argument);+ t.context.r[28].sd[0] = static_cast<std::int32_t>(t.gp);+ t.context.r[29].sd[0] = static_cast<std::int32_t>(t.stack + t.stack_size - kContextReserve);+ t.context.r[31].sd[0] = static_cast<std::int32_t>(kIdle);+ t.priority = t.init_priority;+ t.wakeups = 0;+ t.wait = kWaitNone;+}++void exit_current(Cpu &c, bool remove) {+ Thread *t = current();+ if (!t) return;+ t->status = kDormant;+ if (remove) {+ g_threads.erase(t->id);+ g_current = 0;+ }+ reschedule(c);+}++void write_thread_status(int id, std::uint32_t p) {+ Thread *t = thread(id);+ if (!t || !p) return;+ st32(p + 0, static_cast<std::uint32_t>(t->status));+ st32(p + 4, t->entry);+ st32(p + 8, t->stack);+ st32(p + 12, t->stack_size);+ st32(p + 16, t->gp);+ st32(p + 20, static_cast<std::uint32_t>(t->init_priority));+ st32(p + 24, static_cast<std::uint32_t>(t->priority));+ st32(p + 28, t->attr);+ st32(p + 32, t->option);+ st32(p + 36, t->wait == kWaitSema ? 2u : t->wait == kWaitSleep ? 1u : 0u);+ st32(p + 40, static_cast<std::uint32_t>(t->wait_id));+ st32(p + 44, static_cast<std::uint32_t>(t->wakeups));+}++void signal_sema(Cpu &c, int id, bool interrupt) {+ auto it = g_semas.find(id);+ if (it == g_semas.end()) {+ ret(c, -1);+ return;+ }+ Semaphore &s = it->second;+ ret(c, id);+ if (!s.waiters.empty()) {+ const int waiter = s.waiters.front();+ s.waiters.pop_front();+ if (Thread *t = thread(waiter)) release(*t, id);+ if (!interrupt) reschedule(c);+ } else {+ ++s.count;+ }+}++void wait_sema(Cpu &c, int id) {+ auto it = g_semas.find(id);+ if (it == g_semas.end()) {+ ret(c, -1);+ return;+ }+ Semaphore &s = it->second;+ ret(c, id);+ if (s.count > 0) {+ --s.count;+ return;+ }+ if (g_in_handler) {+ std::fprintf(stderr, "[kernel] WaitSema(%d) inside an interrupt handler\n", id);+ return;+ }+ s.waiters.push_back(g_current);+ block_current(c, kWaitSema, id);+}++void sif_set_dma(Cpu &c);++const char *syscall_name(std::uint32_t n);++}++void reset() {+ g_threads.clear();+ g_semas.clear();+ g_intc_handlers.clear();+ g_dmac_handlers.clear();+ g_alarms.clear();+ g_current = 0;+ g_next_thread = g_next_sema = g_next_handler = g_next_alarm = 1;+ g_in_handler = g_reschedule = false;+ g_pending_alarms.clear();+ std::memset(g_ram + kSyscallTable, 0, 0x400);+}++void start_main_thread(std::uint32_t entry, std::uint32_t gp, std::uint32_t argc, std::uint32_t argv) {+ Thread t;+ t.id = g_next_thread++;+ t.status = kRun;+ t.entry = entry;+ t.gp = gp;+ g_threads[t.id] = t;+ g_current = t.id;+ Cpu &c = g_cpu;+ std::memset(&c, 0, sizeof c);+ c.vu0.vf[0].w[3] = 0x3F800000u;+ c.pc = entry;+ c.r[4].sd[0] = static_cast<std::int32_t>(argc);+ c.r[5].sd[0] = static_cast<std::int32_t>(argv);+ c.cop0[12] = 0x70010C01u;+ c.cop0[15] = 0x2E20u;+}++bool must_unwind() {+ if (g_in_handler) return false;+ if (g_reschedule || !g_pending_alarms.empty()) return true;+ return interrupts_enabled() && (hw::intc_pending() || hw::dmac_pending());+}++bool in_handler() { return g_in_handler; }++void service(Cpu &c) {+ if (g_in_handler) return;+ run_alarms(c);+ if (interrupts_enabled()) {+ for (unsigned guard = 0; guard < 16; ++guard) {+ const std::uint32_t pending = hw::intc_pending();+ const std::uint32_t dmac = hw::dmac_pending();+ if (!pending && !dmac) break;+ if (dmac) run_dmac(c, static_cast<unsigned>(std::countr_zero(dmac)));+ else run_intc(c, static_cast<unsigned>(std::countr_zero(pending)));+ }+ }+ if (g_reschedule || c.pc == kIdle) reschedule(c);+ c.pc &= ~kUnwind;+}++void on_vblank_start() {+ if (g_vsync_flag) {+ st32(g_vsync_flag, 1);+ if (g_vsync_data) st64(g_vsync_data, hw::sif_get(0x80000000u));+ }+}++void wake_idle() { g_reschedule = true; }++void handle_syscall(Cpu &c, std::uint32_t pc) {+ std::uint32_t n = c.r[3].w[0];+ if (n & 0x80000000u) n = 0u - n;+ if (n < 0x100u) {+ const std::uint32_t custom = ld32(kSyscallTable + n * 4u);+ if (custom && has_code(custom & 0x1FFFFFFFu)) {+ const std::uint32_t result = run_guest(c, custom & 0x1FFFFFFFu, arg(c, 0), arg(c, 1), arg(c, 2), c.r[28].w[0], arg(c, 3));+ ret(c, static_cast<std::int32_t>(result));+ return;+ }+ }+ if (g_options.trace_syscalls)+ std::fprintf(stderr, "[sys] %s(0x%02X) %08X %08X %08X %08X from 0x%08X thread %d\n",+ syscall_name(n), n, arg(c, 0), arg(c, 1), arg(c, 2), arg(c, 3), pc, g_current);+ switch (n) {+ case 0x02: hw::gs_set_crt(arg(c, 0), arg(c, 1), arg(c, 2)); ret(c, 0); break;+ case 0x04: halt("Exit"); break;+ case 0x06: case 0x07: halt("program asked to run another executable"); break;+ case 0x10: add_handler(c, g_intc_handlers); break;+ case 0x11: remove_handler(c, g_intc_handlers); break;+ case 0x12: add_handler(c, g_dmac_handlers); break;+ case 0x13: remove_handler(c, g_dmac_handlers); break;+ case 0x14: case 0x1A: ret(c, hw::intc_set_mask(arg(c, 0), true) ? 1 : 0); break;+ case 0x15: case 0x1B: ret(c, hw::intc_set_mask(arg(c, 0), false) ? 1 : 0); break;+ case 0x16: case 0x1C: ret(c, hw::dmac_set_mask(arg(c, 0), true) ? 1 : 0); break;+ case 0x17: case 0x1D: ret(c, hw::dmac_set_mask(arg(c, 0), false) ? 1 : 0); break;+ case 0x18: case 0x1E: {+ const int id = g_next_alarm++;+ g_alarms[id] = Alarm{arg(c, 1), arg(c, 2), c.r[28].w[0], now() + static_cast<std::uint64_t>(arg(c, 0) & 0xFFFFu) * 18874u};+ arm_alarm(id);+ ret(c, id);+ break;+ }+ case 0x19: case 0x1F: g_alarms.erase(static_cast<int>(arg(c, 0))); ret(c, 0); break;+ case 0x20: ret(c, create_thread(c)); break;+ case 0x21: g_threads.erase(static_cast<int>(arg(c, 0))); ret(c, 0); break;+ case 0x22: {+ Thread *t = thread(static_cast<int>(arg(c, 0)));+ if (!t) { ret(c, -1); break; }+ reset_thread(*t, arg(c, 1));+ ret(c, t->id);+ make_ready(*t);+ reschedule(c);+ break;+ }+ case 0x23: exit_current(c, false); break;+ case 0x24: exit_current(c, true); break;+ case 0x25: case 0x26: {+ 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());+ t->status = kDormant;+ t->wait = kWaitNone;+ }+ ret(c, t ? 0 : -1);+ break;+ }+ case 0x29: case 0x2A: {+ Thread *t = thread(static_cast<int>(arg(c, 0)));+ if (!t) { ret(c, -1); break; }+ ret(c, t->priority);+ t->priority = static_cast<int>(arg(c, 1)) & (kMaxPriority - 1);+ if (t->status == kReady) t->order = ++g_order;+ if (n == 0x29) reschedule(c);+ else g_reschedule = true;+ break;+ }+ case 0x2B: case 0x2C: {+ const int prio = static_cast<int>(arg(c, 0)) & (kMaxPriority - 1);+ Thread *t = current();+ ret(c, prio);+ if (t && t->priority == prio) {+ t->order = ++g_order;+ } else {+ Thread *first = nullptr;+ for (auto &[id, x] : g_threads)+ if (x.status == kReady && x.priority == prio && (!first || x.order < first->order)) first = &x;+ if (first) first->order = ++g_order;+ }+ if (n == 0x2B) reschedule(c);+ else g_reschedule = true;+ break;+ }+ case 0x2D: case 0x2E: {+ Thread *t = thread(static_cast<int>(arg(c, 0)));+ if (t && (t->status == kWait || t->status == kWaitSuspend)) {+ for (auto &[id, s] : g_semas) s.waiters.erase(std::remove(s.waiters.begin(), s.waiters.end(), t->id), s.waiters.end());+ release(*t, -418);+ if (n == 0x2D) reschedule(c);+ }+ ret(c, t ? t->id : -1);+ break;+ }+ case 0x2F: ret(c, g_current); break;+ case 0x30: case 0x31: write_thread_status(static_cast<int>(arg(c, 0)), arg(c, 1)); ret(c, thread(static_cast<int>(arg(c, 0))) ? thread(static_cast<int>(arg(c, 0)))->status : -1); break;+ case 0x32: {+ Thread *t = current();+ ret(c, g_current);+ if (t->wakeups > 0) { --t->wakeups; break; }+ block_current(c, kWaitSleep, 0);+ break;+ }+ case 0x33: case 0x34: {+ Thread *t = thread(static_cast<int>(arg(c, 0)));+ ret(c, t ? t->id : -1);+ if (!t) break;+ if (t->wait == kWaitSleep) {+ release(*t, t->id);+ if (n == 0x33) reschedule(c);+ } else {+ ++t->wakeups;+ }+ break;+ }+ case 0x35: case 0x36: {+ Thread *t = thread(static_cast<int>(arg(c, 0)));+ ret(c, t ? t->wakeups : -1);+ if (t) t->wakeups = 0;+ break;+ }+ case 0x37: case 0x38: {+ Thread *t = thread(static_cast<int>(arg(c, 0)));+ if (t && t != current()) {+ if (t->status == kWait) t->status = kWaitSuspend;+ else if (t->status == kReady) t->status = kSuspend;+ ++t->suspends;+ }+ ret(c, t ? t->id : -1);+ break;+ }+ case 0x39: case 0x3A: {+ Thread *t = thread(static_cast<int>(arg(c, 0)));+ if (t && t->suspends > 0 && --t->suspends == 0) {+ if (t->status == kWaitSuspend) t->status = kWait;+ else if (t->status == kSuspend) make_ready(*t);+ if (n == 0x39) reschedule(c);+ }+ ret(c, t ? t->id : -1);+ break;+ }+ case 0x3C: {+ Thread *t = current();+ const std::uint32_t stack = arg(c, 1), size = arg(c, 2);+ const std::uint32_t top = stack == 0xFFFFFFFFu ? kRamSize - 0x1000u : stack + size;+ t->stack = top - size;+ t->stack_size = size;+ t->gp = arg(c, 0);+ ret(c, top - kContextReserve);+ break;+ }+ case 0x3D: {+ Thread *t = current();+ t->heap = arg(c, 1) == 0xFFFFFFFFu ? t->stack : arg(c, 0) + arg(c, 1);+ ret(c, t->heap);+ break;+ }+ case 0x3E: ret(c, current()->heap); break;+ case 0x40: {+ const std::uint32_t p = arg(c, 0);+ Semaphore s;+ s.count = static_cast<int>(ld32(p + 0));+ s.max = static_cast<int>(ld32(p + 4));+ s.init = static_cast<int>(ld32(p + 8));+ s.attr = ld32(p + 16);+ s.option = ld32(p + 20);+ s.count = s.init;+ const int id = g_next_sema++;+ g_semas[id] = s;+ ret(c, id);+ break;+ }+ case 0x41: {+ auto it = g_semas.find(static_cast<int>(arg(c, 0)));+ if (it == g_semas.end()) { ret(c, -1); break; }+ for (int waiter : it->second.waiters)+ if (Thread *t = thread(waiter)) release(*t, -425);+ g_semas.erase(it);+ ret(c, static_cast<std::int32_t>(arg(c, 0)));+ reschedule(c);+ break;+ }+ case 0x42: signal_sema(c, static_cast<int>(arg(c, 0)), false); break;+ case 0x43: signal_sema(c, static_cast<int>(arg(c, 0)), true); break;+ case 0x44: wait_sema(c, static_cast<int>(arg(c, 0))); break;+ case 0x45: case 0x46: {+ auto it = g_semas.find(static_cast<int>(arg(c, 0)));+ if (it == g_semas.end() || it->second.count <= 0) { ret(c, -1); break; }+ --it->second.count;+ ret(c, it->first);+ break;+ }+ case 0x47: case 0x48: {+ auto it = g_semas.find(static_cast<int>(arg(c, 0)));+ if (it == g_semas.end()) { ret(c, -1); break; }+ const std::uint32_t p = arg(c, 1);+ st32(p + 0, static_cast<std::uint32_t>(it->second.count));+ st32(p + 4, static_cast<std::uint32_t>(it->second.max));+ st32(p + 8, static_cast<std::uint32_t>(it->second.init));+ st32(p + 12, static_cast<std::uint32_t>(it->second.waiters.size()));+ st32(p + 16, it->second.attr);+ st32(p + 20, it->second.option);+ ret(c, it->first);+ break;+ }+ case 0x4A: g_osd_config = ld32(arg(c, 0)); ret(c, 0); break;+ case 0x4B: st32(arg(c, 0), g_osd_config); ret(c, 0); break;+ case 0x64: case 0x68: ret(c, 0); break;+ case 0x70: ret(c, static_cast<std::int64_t>(hw::gs_imr())); break;+ case 0x71: { const std::uint64_t old = hw::gs_imr(); hw::gs_set_imr(arg(c, 0)); ret(c, static_cast<std::int64_t>(old)); break; }+ case 0x73: g_vsync_flag = arg(c, 0); g_vsync_data = arg(c, 1); ret(c, 0); break;+ case 0x74:+ if (arg(c, 0) < 0x100u) st32(kSyscallTable + arg(c, 0) * 4u, arg(c, 1));+ else std::fprintf(stderr, "[sys] SetSyscall(0x%X) not supported\n", arg(c, 0));+ ret(c, 0);+ break;+ case 0x76: ret(c, -1); break;+ case 0x77: sif_set_dma(c); break;+ case 0x78: ret(c, 0); break;+ case 0x79: hw::sif_set(arg(c, 0), arg(c, 1)); ret(c, 0); break;+ case 0x7A: ret(c, static_cast<std::int32_t>(hw::sif_get(arg(c, 0)))); break;+ case 0x7C: ret(c, 0); break;+ case 0x7E: ret(c, 0); break;+ case 0x7F: ret(c, kRamSize); break;+ default:+ std::fprintf(stderr, "[sys] unhandled syscall 0x%02X from 0x%08X\n", n, pc);+ ret(c, 0);+ break;+ }+}++namespace {++void sif_set_dma(Cpu &c) {+ std::fprintf(stderr, "[sif] SifSetDma(0x%08X, %u) not implemented yet\n", arg(c, 0), arg(c, 1));+ ret(c, 1);+}++const char *syscall_name(std::uint32_t n) {+ switch (n) {+ case 0x02: return "GsSetCrt";+ case 0x04: return "Exit";+ case 0x06: return "LoadExecPS2";+ case 0x07: return "ExecPS2";+ case 0x10: return "AddIntcHandler";+ case 0x11: return "RemoveIntcHandler";+ case 0x12: return "AddDmacHandler";+ case 0x13: return "RemoveDmacHandler";+ case 0x14: return "EnableIntc";+ case 0x15: return "DisableIntc";+ case 0x16: return "EnableDmac";+ case 0x17: return "DisableDmac";+ case 0x18: return "SetAlarm";+ case 0x19: return "ReleaseAlarm";+ case 0x1A: return "iEnableIntc";+ case 0x1B: return "iDisableIntc";+ case 0x1C: return "iEnableDmac";+ case 0x1D: return "iDisableDmac";+ case 0x1E: return "iSetAlarm";+ case 0x1F: return "iReleaseAlarm";+ case 0x20: return "CreateThread";+ case 0x21: return "DeleteThread";+ case 0x22: return "StartThread";+ case 0x23: return "ExitThread";+ case 0x24: return "ExitDeleteThread";+ case 0x25: return "TerminateThread";+ case 0x26: return "iTerminateThread";+ case 0x29: return "ChangeThreadPriority";+ case 0x2A: return "iChangeThreadPriority";+ case 0x2B: return "RotateThreadReadyQueue";+ case 0x2C: return "iRotateThreadReadyQueue";+ case 0x2D: return "ReleaseWaitThread";+ case 0x2E: return "iReleaseWaitThread";+ case 0x2F: return "GetThreadId";+ case 0x30: return "ReferThreadStatus";+ case 0x31: return "iReferThreadStatus";+ case 0x32: return "SleepThread";+ case 0x33: return "WakeupThread";+ case 0x34: return "iWakeupThread";+ case 0x35: return "CancelWakeupThread";+ case 0x36: return "iCancelWakeupThread";+ case 0x37: return "SuspendThread";+ case 0x38: return "iSuspendThread";+ case 0x39: return "ResumeThread";+ case 0x3A: return "iResumeThread";+ case 0x3C: return "SetupThread";+ case 0x3D: return "SetupHeap";+ case 0x3E: return "EndOfHeap";+ case 0x40: return "CreateSema";+ case 0x41: return "DeleteSema";+ case 0x42: return "SignalSema";+ case 0x43: return "iSignalSema";+ case 0x44: return "WaitSema";+ case 0x45: return "PollSema";+ case 0x46: return "iPollSema";+ case 0x47: return "ReferSemaStatus";+ case 0x48: return "iReferSemaStatus";+ case 0x4A: return "SetOsdConfigParam";+ case 0x4B: return "GetOsdConfigParam";+ case 0x64: return "FlushCache";+ case 0x68: return "iFlushCache";+ case 0x70: return "GsGetIMR";+ case 0x71: return "GsPutIMR";+ case 0x73: return "SetVSyncFlag";+ case 0x74: return "SetSyscall";+ case 0x76: return "SifDmaStat";+ case 0x77: return "SifSetDma";+ case 0x78: return "SifSetDChain";+ case 0x79: return "SifSetReg";+ case 0x7A: return "SifGetReg";+ case 0x7C: return "Deci2Call";+ case 0x7E: return "MachineType";+ case 0x7F: return "GetMemorySize";+ default: return "?";+ }+}++}++}++namespace ps2 {++void syscall(Cpu &c, std::uint32_t pc) { kernel::handle_syscall(c, pc); }++std::uint32_t mfc0(Cpu &c, std::uint32_t reg, std::uint32_t) {+ switch (reg) {+ case 9: return static_cast<std::uint32_t>(now());+ case 12: return c.cop0[12];+ case 15: return 0x2E20u;+ default: return c.cop0[reg];+ }+}++void mtc0(Cpu &c, std::uint32_t reg, std::uint32_t value) {+ c.cop0[reg] = value;+}++std::uint32_t eret(Cpu &c) {+ std::uint32_t &status = c.cop0[12];+ if (status & 4u) {+ status &= ~4u;+ return c.cop0[30];+ }+ status &= ~2u;+ return c.cop0[14];+}++void set_interrupts(Cpu &c, bool enabled) {+ c.cop0[12] = enabled ? (c.cop0[12] | 0x10000u) : (c.cop0[12] & ~0x10000u);+}++}diff --git a/runtime/src/kernel.hpp b/runtime/src/kernel.hppnew file mode 100644index 0000000..4523da8--- /dev/null+++ b/runtime/src/kernel.hpp@@ -0,0 +1,19 @@+#pragma once++#include "ps2/cpu.hpp"++#include <cstdint>++namespace ps2::kernel {++void reset();+void start_main_thread(std::uint32_t entry, std::uint32_t gp, std::uint32_t argc, std::uint32_t argv);+void handle_syscall(Cpu &c, std::uint32_t pc);+void service(Cpu &c);+bool must_unwind();+bool in_handler();+void on_vblank_start();+void on_hblank();+void wake_idle();++}diff --git a/runtime/src/memory.cpp b/runtime/src/memory.cppnew file mode 100644index 0000000..135cefc--- /dev/null+++ b/runtime/src/memory.cpp@@ -0,0 +1,120 @@+#include "hw.hpp"+#include "ps2/memory.hpp"+#include "ps2/system.hpp"++#include <cstdio>+#include <cstring>++namespace ps2 {++alignas(64) std::uint8_t g_ram[kRamSize + 64];+alignas(64) std::uint8_t g_spr[kScratchpadSize];+alignas(64) std::uint8_t g_vu0_code[4096];+alignas(64) std::uint8_t g_vu0_mem[4096];+alignas(64) std::uint8_t g_vu1_code[16384];+alignas(64) std::uint8_t g_vu1_mem[16384];++namespace {++enum class Region { Ram, Scratchpad, Io, Vu, Rom, None };++struct Target {+ Region region;+ std::uint8_t *host;+ std::uint32_t address;+};++std::uint8_t *vu_memory(std::uint32_t p) {+ switch ((p >> 12) & 0xFu) {+ case 0x0: return g_vu0_code + (p & 0xFFFu);+ case 0x4: return g_vu0_mem + (p & 0xFFFu);+ case 0x8: case 0x9: case 0xA: case 0xB: return g_vu1_code + (p & 0x3FFFu);+ case 0xC: case 0xD: case 0xE: case 0xF: return g_vu1_mem + (p & 0x3FFFu);+ default: return nullptr;+ }+}++Target resolve(std::uint32_t a) {+ if ((a >> 14) == (kScratchpadBase >> 14)) return {Region::Scratchpad, g_spr + (a & (kScratchpadSize - 1)), a};+ const std::uint32_t p = physical(a);+ if (p < 0x10000000u) return {Region::Ram, g_ram + (p & (kRamSize - 1)), p};+ if (p >= 0x11000000u && p < 0x11010000u) {+ if (std::uint8_t *host = vu_memory(p)) return {Region::Vu, host, p};+ }+ if (p >= 0x10000000u && p < 0x13000000u) return {Region::Io, nullptr, p};+ if (p >= 0x1FC00000u && p < 0x20000000u) return {Region::Rom, nullptr, p};+ return {Region::None, nullptr, p};+}++void unmapped(const char *what, std::uint32_t a) {+ std::fprintf(stderr, "[mem] %s at unmapped 0x%08X (pc 0x%08X)\n", what, a, g_cpu.pc);+}++template <typename T>+T read_slow(std::uint32_t a) {+ const Target t = resolve(a);+ if (t.host) {+ T v;+ std::memcpy(&v, t.host, sizeof v);+ return v;+ }+ if (t.region == Region::Io) {+ if constexpr (sizeof(T) == 8) return hw::read64(t.address);+ else {+ const std::uint32_t word = hw::read32(t.address & ~3u);+ return static_cast<T>(word >> ((t.address & 3u) * 8u));+ }+ }+ if (t.region != Region::Rom) unmapped("read", a);+ return 0;+}++template <typename T>+void write_slow(std::uint32_t a, T v) {+ const Target t = resolve(a);+ if (t.host) {+ std::memcpy(t.host, &v, sizeof v);+ return;+ }+ if (t.region == Region::Io) {+ if constexpr (sizeof(T) == 8) hw::write64(t.address, v);+ else hw::write32(t.address, static_cast<std::uint32_t>(v));+ return;+ }+ unmapped("write", a);+}++}++std::uint32_t physical(std::uint32_t a) {+ if (a >= 0x80000000u && a < 0xC0000000u) return a & 0x1FFFFFFFu;+ const std::uint32_t top = a >> 28;+ if (top == 2u || top == 3u) return a & 0x0FFFFFFFu;+ return a;+}++std::uint8_t slow_ld8(std::uint32_t a) { return read_slow<std::uint8_t>(a); }+std::uint16_t slow_ld16(std::uint32_t a) { return read_slow<std::uint16_t>(a); }+std::uint32_t slow_ld32(std::uint32_t a) { return read_slow<std::uint32_t>(a); }+std::uint64_t slow_ld64(std::uint32_t a) { return read_slow<std::uint64_t>(a); }++void slow_ld128(std::uint32_t a, Reg128 &out) {+ const Target t = resolve(a);+ if (t.host) std::memcpy(&out, t.host, 16);+ else if (t.region == Region::Io) hw::read128(t.address, out);+ else std::memset(&out, 0, 16);+}++void slow_st8(std::uint32_t a, std::uint8_t v) { write_slow(a, v); }+void slow_st16(std::uint32_t a, std::uint16_t v) { write_slow(a, v); }+void slow_st32(std::uint32_t a, std::uint32_t v) { write_slow(a, v); }+void slow_st64(std::uint32_t a, std::uint64_t v) { write_slow(a, v); }++void slow_st128(std::uint32_t a, const Reg128 &v) {+ const Target t = resolve(a);+ if (t.host) std::memcpy(t.host, &v, 16);+ else if (t.region == Region::Io) hw::write128(t.address, v);+ else unmapped("write128", a);+}++}diff --git a/runtime/src/system.cpp b/runtime/src/system.cppnew file mode 100644index 0000000..cf6ea50--- /dev/null+++ b/runtime/src/system.cpp@@ -0,0 +1,188 @@+#include "hw.hpp"+#include "kernel.hpp"+#include "ps2/generated.hpp"+#include "ps2/memory.hpp"+#include "ps2/system.hpp"++#include <algorithm>+#include <cstdio>+#include <cstring>+#include <fstream>+#include <iterator>++namespace ps2 {++Cpu g_cpu;+Options g_options;++namespace {++constexpr std::int64_t kMaxSlice = 20000;++struct Event {+ int id;+ std::uint64_t at;+ std::function<void()> action;+};++std::uint64_t g_base = 0;+std::int64_t g_given = 0;+std::vector<Event> g_events;+bool g_halted = false;+std::string g_halt_reason;+std::uint64_t g_frames = 0;++std::uint64_t next_event_time() {+ std::uint64_t t = UINT64_MAX;+ for (const Event &e : g_events) t = std::min(t, e.at);+ return t;+}++void run_due_events() {+ for (;;) {+ const std::uint64_t t = now();+ auto it = std::min_element(g_events.begin(), g_events.end(), [](const Event &a, const Event &b) { return a.at < b.at; });+ if (it == g_events.end() || it->at > t) return;+ auto action = std::move(it->action);+ g_events.erase(it);+ action();+ }+}++void refill(Cpu &c) {+ const std::uint64_t t = now(), next = next_event_time();+ std::int64_t slice = kMaxSlice;+ if (next != UINT64_MAX) slice = std::clamp<std::int64_t>(static_cast<std::int64_t>(next - std::min(next, t)), 1, kMaxSlice);+ set_budget(c, slice);+}++std::uint64_t frame_cycles() { return kEeClock / (g_options.pal ? 50u : 60u); }++void vblank() {+ ++g_frames;+ hw::vblank_start();+ kernel::on_vblank_start();+ if (g_options.max_frames && g_frames >= g_options.max_frames) halt("frame limit reached");+ schedule(hw::kEventVblank, now() + frame_cycles(), vblank);+}++void idle(Cpu &c) {+ const std::uint64_t next = next_event_time();+ if (next == UINT64_MAX) {+ halt("deadlock: every thread waits and no event is pending");+ return;+ }+ g_base = std::max(now(), next);+ g_given = 0;+ c.budget = 0;+ run_due_events();+}++}++void save_context(const Cpu &c, ThreadContext &t) {+ std::memcpy(t.r, c.r, sizeof t.r);+ t.hi = c.hi;+ t.lo = c.lo;+ t.sa = c.sa;+ t.pc = c.pc & ~kUnwind;+ std::memcpy(t.f, c.f, sizeof t.f);+ t.facc = c.facc;+ t.fcr31 = c.fcr31;+}++void load_context(Cpu &c, const ThreadContext &t) {+ std::memcpy(c.r, t.r, sizeof t.r);+ c.hi = t.hi;+ c.lo = t.lo;+ c.sa = t.sa;+ c.pc = t.pc;+ std::memcpy(c.f, t.f, sizeof t.f);+ c.facc = t.facc;+ c.fcr31 = t.fcr31;+}++std::uint64_t now() { return g_base + static_cast<std::uint64_t>(g_given - g_cpu.budget); }++void set_budget(Cpu &c, std::int64_t cycles) {+ g_base = now();+ g_given = cycles;+ c.budget = static_cast<std::int32_t>(cycles);+}++void schedule(int event, std::uint64_t at, std::function<void()> action) {+ g_events.erase(std::remove_if(g_events.begin(), g_events.end(), [&](const Event &e) { return e.id == event; }), g_events.end());+ g_events.push_back({event, at, std::move(action)});+}++bool preempt(Cpu &c) {+ run_due_events();+ refill(c);+ return g_halted || kernel::must_unwind();+}++void halt(const std::string &reason) {+ if (!g_halted) std::fprintf(stderr, "[ee] halted: %s\n", reason.c_str());+ g_halted = true;+ g_halt_reason = reason;+}++bool halted() { return g_halted; }++std::uint64_t frame_count() { return g_frames; }++bool load_elf(const std::string &path, std::uint32_t &entry) {+ std::ifstream file(path, std::ios::binary);+ if (!file) return false;+ const std::vector<std::uint8_t> data{std::istreambuf_iterator<char>(file), {}};+ if (data.size() < 52 || std::memcmp(data.data(), "\x7f" "ELF", 4) != 0) return false;+ const auto u32 = [&](std::size_t o) { std::uint32_t v; std::memcpy(&v, data.data() + o, 4); return v; };+ const auto u16 = [&](std::size_t o) { std::uint16_t v; std::memcpy(&v, data.data() + o, 2); return v; };+ entry = u32(24);+ const std::uint32_t phoff = u32(28);+ for (std::uint32_t i = 0; i < u16(44); ++i) {+ const std::size_t ph = phoff + i * u16(42);+ if (u32(ph) != 1) continue;+ const std::uint32_t offset = u32(ph + 4), vaddr = physical(u32(ph + 8)), filesz = u32(ph + 16), memsz = u32(ph + 20);+ if (vaddr + memsz > kRamSize || offset + filesz > data.size()) return false;+ std::memcpy(g_ram + vaddr, data.data() + offset, filesz);+ std::memset(g_ram + vaddr + filesz, 0, memsz - filesz);+ }+ return true;+}++void boot(std::uint32_t entry, const std::vector<std::string> &args) {+ hw::reset();+ kernel::reset();+ std::uint32_t argv = 0x00000800u, payload = argv + 4u * static_cast<std::uint32_t>(args.size() + 1);+ for (std::size_t i = 0; i < args.size(); ++i) {+ store<std::uint32_t>(g_ram + argv + 4 * i, payload);+ std::memcpy(g_ram + payload, args[i].c_str(), args[i].size() + 1);+ payload += static_cast<std::uint32_t>(args[i].size() + 1);+ }+ store<std::uint32_t>(g_ram + argv + 4 * args.size(), 0);+ kernel::start_main_thread(entry, 0, static_cast<std::uint32_t>(args.size()), argv);+ schedule(hw::kEventVblank, frame_cycles(), vblank);+}++int run() {+ Cpu &c = g_cpu;+ set_budget(c, kMaxSlice);+ while (!g_halted) {+ c.pc &= ~kUnwind;+ run_due_events();+ kernel::service(c);+ if (g_halted) break;+ if (c.pc == kIdle) {+ idle(c);+ continue;+ }+ if (c.budget <= 0) refill(c);+ dispatch(c, 0, 0);+ }+ std::fprintf(stderr, "[ee] stopped after %llu frames, %llu cycles: %s\n",+ static_cast<unsigned long long>(g_frames), static_cast<unsigned long long>(now()), g_halt_reason.c_str());+ return 0;+}++}