Skip to content

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.txt
index 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(eerecomp
recomp/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.cpp
new file mode 100644
index 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.cpp
index 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.hpp
index 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.hpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.hpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.hpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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;
+}
+
+}